objistr.hpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: objistr.hpp,v $
 * PRODUCTION Revision 1000.5  2004/06/01 19:38:53  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.103
 * PRODUCTION
 * ===========================================================================
 */

#ifndef OBJISTR__HPP
#define OBJISTR__HPP

/*  $Id: objistr.hpp,v 1000.5 2004/06/01 19:38:53 gouriano Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*               National Center for Biotechnology Information
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government have not placed any restriction on its use or reproduction.
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
*  Please cite the author in any work or product based on this material.
*
* ===========================================================================
*
* Author: Eugene Vasilchenko
*
* File Description:
*   !!! PUT YOUR DESCRIPTION HERE !!!
*/

#include <corelib/ncbistd.hpp>
#include <corelib/ncbiobj.hpp>
#include <corelib/ncbiutil.hpp>
#include <serial/serialdef.hpp>
#include <serial/typeinfo.hpp>
#include <util/strbuffer.hpp>
#include <serial/objlist.hpp>
#include <serial/objstack.hpp>
#include <serial/objhook.hpp>
#include <serial/hookdatakey.hpp>
#include <serial/pathhook.hpp>


/** @addtogroup ObjStreamSupport
 *
 * @{
 */


struct asnio;

BEGIN_NCBI_SCOPE

class CMemberId;
class CItemsInfo;
class CItemInfo;
class CMemberInfo;
class CVariantInfo;
class CDelayBuffer;
class CByteSource;
class CByteSourceReader;

class CObjectInfo;
class CObjectInfoMI;

class CClassTypeInfo;
class CChoiceTypeInfo;
class CContainerTypeInfo;
class CObjectStreamCopier;
class CAliasTypeInfo;

class CReadObjectHook;
class CReadClassMemberHook;
class CReadChoiceVariantHook;
class CSkipObjectHook;
class CSkipClassMemberHook;
class CSkipChoiceVariantHook;

class CReadObjectInfo;
class CReadObjectList;

class CPackString;

class NCBI_XSERIAL_EXPORT CObjectIStream : public CObjectStack
{
public:
    // typedefs
    typedef size_t TObjectIndex;

    // open methods
    virtual void Open(CByteSourceReader& reader);
    void Open(CByteSource& source);
    void Open(CNcbiIstream& inStream, bool deleteInStream = false);
    void Close(void);
    void ResetLocalHooks(void);

    static CObjectIStream* Open(ESerialDataFormat format,
                                CNcbiIstream& inStream,
                                bool deleteInStream = false);
    static CObjectIStream* Open(ESerialDataFormat format,
                                const string& fileName,
                                TSerialOpenFlags openFlags = 0);
    static CObjectIStream* Open(const string& fileName,
                                ESerialDataFormat format);

    bool DetectLoops(void) const;

    // when enabled, stream verifies data on input
    // and throws CSerialException with eFormatError err.code

    // for this particular stream
    void SetVerifyData(ESerialVerifyData verify);
    ESerialVerifyData GetVerifyData(void) const;
    // for streams created by the current thread
    static  void SetVerifyDataThread(ESerialVerifyData verify);
    // for streams created by the current process
    static  void SetVerifyDataGlobal(ESerialVerifyData verify);

    // for this particular stream
    void SetSkipUnknownMembers(ESerialSkipUnknown skip);
    ESerialSkipUnknown GetSkipUnknownMembers(void);
    // for streams created by the current thread
    static  void SetSkipUnknownThread(ESerialSkipUnknown skip);
    // for streams created by the current process
    static  void SetSkipUnknownGlobal(ESerialSkipUnknown skip);

    // constructors
protected:
    CObjectIStream(ESerialDataFormat format);
    CObjectIStream(CNcbiIstream& in, bool deleteIn = false);

public:
    virtual ~CObjectIStream(void);

    // get data format
    ESerialDataFormat GetDataFormat(void) const;

    // USER INTERFACE
    // root reader
    void Read(const CObjectInfo& object);
    void Read(TObjectPtr object, TTypeInfo type);
    CObjectInfo Read(const CObjectTypeInfo& type);
    CObjectInfo Read(TTypeInfo type);
    void Skip(const CObjectTypeInfo& type);
    void Skip(TTypeInfo type);

    // file header readers
    virtual string ReadFileHeader(void);
    void SkipFileHeader(TTypeInfo typeInfo);
    virtual string PeekNextTypeName(void);

    enum ENoFileHeader {
        eNoFileHeader
    };
    void Read(const CObjectInfo& object, ENoFileHeader noFileHeader);
    void Read(TObjectPtr object, TTypeInfo type, ENoFileHeader noFileHeader);
    void Skip(TTypeInfo type, ENoFileHeader noFileHeader);

    // subtree reader
    void ReadObject(const CObjectInfo& object);
    void ReadObject(TObjectPtr object, TTypeInfo typeInfo);
    void SkipObject(const CObjectTypeInfo& objectType);
    void SkipObject(TTypeInfo typeInfo);

    // temporary reader
    void ReadSeparateObject(const CObjectInfo& object);

    // member
    void ReadClassMember(const CObjectInfoMI& member);

    // variant
    void ReadChoiceVariant(const CObjectInfoCV& object);

    // END OF USER INTERFACE

    // internal reader
    void ReadExternalObject(TObjectPtr object, TTypeInfo typeInfo);
    void SkipExternalObject(TTypeInfo typeInfo);

    CObjectInfo ReadObject(void);

    virtual void EndOfRead(void);
    
    // try to read enum value name, "" if none
    virtual TEnumValueType ReadEnum(const CEnumeratedTypeValues& values) = 0;

    // std C types readers
    // bool
    void ReadStd(bool& data);
    void SkipStd(const bool &);

    // char
    void ReadStd(char& data);
    void SkipStd(const char& );

    // integer numbers
    void ReadStd(signed char& data);
    void ReadStd(unsigned char& data);
    void SkipStd(const signed char& );
    void SkipStd(const unsigned char& );
    void ReadStd(short& data);
    void ReadStd(unsigned short& data);
    void SkipStd(const short& );
    void SkipStd(const unsigned short& );
    void ReadStd(int& data);
    void ReadStd(unsigned& data);
    void SkipStd(const int& );
    void SkipStd(const unsigned& );
#if SIZEOF_LONG == 4
    void ReadStd(long& data);
    void ReadStd(unsigned long& data);
    void SkipStd(const long& );
    void SkipStd(const unsigned long& );
#endif
    void ReadStd(Int8& data);
    void ReadStd(Uint8& data);
    void SkipStd(const Int8& );
    void SkipStd(const Uint8& );

    // float numbers
    void ReadStd(float& data);
    void ReadStd(double& data);
    void SkipStd(const float& );
    void SkipStd(const double& );
#if SIZEOF_LONG_DOUBLE != 0
    virtual void ReadStd(long double& data);
    virtual void SkipStd(const long double& );
#endif

    // string
    void ReadStd(string& data);
    void SkipStd(const string& );
    void ReadStd(CStringUTF8& data);
    void SkipStd(CStringUTF8& data);

    // C string
    void ReadStd(char* & data);
    void ReadStd(const char* & data);
    void SkipStd(char* const& );
    void SkipStd(const char* const& );

    // primitive readers
    // bool
    virtual bool ReadBool(void) = 0;
    virtual void SkipBool(void) = 0;

    // char
    virtual char ReadChar(void) = 0;
    virtual void SkipChar(void) = 0;

    // integer numbers
    virtual Int1 ReadInt1(void);
    virtual Uint1 ReadUint1(void);
    virtual Int2 ReadInt2(void);
    virtual Uint2 ReadUint2(void);
    virtual Int4 ReadInt4(void);
    virtual Uint4 ReadUint4(void);
    virtual Int8 ReadInt8(void) = 0;
    virtual Uint8 ReadUint8(void) = 0;

    virtual void SkipInt1(void);
    virtual void SkipUint1(void);
    virtual void SkipInt2(void);
    virtual void SkipUint2(void);
    virtual void SkipInt4(void);
    virtual void SkipUint4(void);
    virtual void SkipInt8(void);
    virtual void SkipUint8(void);

    virtual void SkipSNumber(void) = 0;
    virtual void SkipUNumber(void) = 0;

    // float numbers
    virtual float ReadFloat(void);
    virtual double ReadDouble(void) = 0;
    virtual void SkipFloat(void);
    virtual void SkipDouble(void);
#if SIZEOF_LONG_DOUBLE != 0
    virtual long double ReadLDouble(void);
    virtual void SkipLDouble(void);
#endif
    virtual void SkipFNumber(void) = 0;

    // string
    virtual void ReadString(string& s,
                            EStringType type = eStringTypeVisible) = 0;
    virtual void ReadString(string& s,
                            CPackString& pack_string,
                            EStringType type = eStringTypeVisible);
    virtual void SkipString(EStringType type = eStringTypeVisible) = 0;

    // StringStore
    virtual void ReadStringStore(string& s);
    virtual void SkipStringStore(void);
    
    // C string
    virtual char* ReadCString(void);
    virtual void SkipCString(void);

    // null
    virtual void ReadNull(void) = 0;
    virtual void SkipNull(void) = 0;

    // any content object
    virtual void ReadAnyContentObject(CAnyContentObject& obj) = 0;
    virtual void SkipAnyContentObject(void) = 0;

    // octet string
    virtual void SkipByteBlock(void) = 0;

    // reads type info
    virtual pair<TObjectPtr, TTypeInfo> ReadPointer(TTypeInfo declaredType);
    enum EPointerType {
        eNullPointer,
        eObjectPointer,
        eThisPointer,
        eOtherPointer
    };

    void SkipPointer(TTypeInfo declaredType);

    // low level readers:
    enum EFailFlags {
        fNoError       = 0,             eNoError     = fNoError,
        fEOF           = 1 << 0,        eEOF         = fEOF,
        fReadError     = 1 << 1,        eReadError   = fReadError,
        fFormatError   = 1 << 2,        eFormatError = fFormatError,
        fOverflow      = 1 << 3,        eOverflow    = fOverflow,
        fInvalidData   = 1 << 4,        eInvalidData = fInvalidData,
        fIllegalCall   = 1 << 5,        eIllegalCall = fIllegalCall,
        fFail          = 1 << 6,        eFail        = fFail,
        fNotOpen       = 1 << 7,        eNotOpen     = fNotOpen,
        fMissingValue  = 1 << 8,        eMissingValue= fMissingValue
    };
    typedef int TFailFlags;

    bool fail(void) const;
    TFailFlags GetFailFlags(void) const;
    TFailFlags SetFailFlags(TFailFlags flags, const char* message);
    TFailFlags ClearFailFlags(TFailFlags flags);
    bool InGoodState(void);