开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
objistr.hpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：34k
源码类别：

生物技术

开发平台：

C/C++

objistr.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objistr.hpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:38:53  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.103
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef OBJISTR__HPP
  11. #define OBJISTR__HPP
  13. /*  $Id: objistr.hpp,v 1000.5 2004/06/01 19:38:53 gouriano Exp $
  14. * ===========================================================================
  15. *
  16. *                            PUBLIC DOMAIN NOTICE
  17. *               National Center for Biotechnology Information
  18. *
  19. *  This software/database is a "United States Government Work" under the
  20. *  terms of the United States Copyright Act.  It was written as part of
  21. *  the author's official duties as a United States Government employee and
  22. *  thus cannot be copyrighted.  This software/database is freely available
  23. *  to the public for use. The National Library of Medicine and the U.S.
  24. *  Government have not placed any restriction on its use or reproduction.
  25. *
  26. *  Although all reasonable efforts have been taken to ensure the accuracy
  27. *  and reliability of the software and data, the NLM and the U.S.
  28. *  Government do not and cannot warrant the performance or results that
  29. *  may be obtained by using this software or data. The NLM and the U.S.
  30. *  Government disclaim all warranties, express or implied, including
  31. *  warranties of performance, merchantability or fitness for any particular
  32. *  purpose.
  33. *
  34. *  Please cite the author in any work or product based on this material.
  35. *
  36. * ===========================================================================
  37. *
  38. * Author: Eugene Vasilchenko
  39. *
  40. * File Description:
  41. *   !!! PUT YOUR DESCRIPTION HERE !!!
  42. */
  44. #include <corelib/ncbistd.hpp>
  45. #include <corelib/ncbiobj.hpp>
  46. #include <corelib/ncbiutil.hpp>
  47. #include <serial/serialdef.hpp>
  48. #include <serial/typeinfo.hpp>
  49. #include <util/strbuffer.hpp>
  50. #include <serial/objlist.hpp>
  51. #include <serial/objstack.hpp>
  52. #include <serial/objhook.hpp>
  53. #include <serial/hookdatakey.hpp>
  54. #include <serial/pathhook.hpp>
  57. /** @addtogroup ObjStreamSupport
  58.  *
  59.  * @{
  60.  */
  63. struct asnio;
  65. BEGIN_NCBI_SCOPE
  67. class CMemberId;
  68. class CItemsInfo;
  69. class CItemInfo;
  70. class CMemberInfo;
  71. class CVariantInfo;
  72. class CDelayBuffer;
  73. class CByteSource;
  74. class CByteSourceReader;
  76. class CObjectInfo;
  77. class CObjectInfoMI;
  79. class CClassTypeInfo;
  80. class CChoiceTypeInfo;
  81. class CContainerTypeInfo;
  82. class CObjectStreamCopier;
  83. class CAliasTypeInfo;
  85. class CReadObjectHook;
  86. class CReadClassMemberHook;
  87. class CReadChoiceVariantHook;
  88. class CSkipObjectHook;
  89. class CSkipClassMemberHook;
  90. class CSkipChoiceVariantHook;
  92. class CReadObjectInfo;
  93. class CReadObjectList;
  95. class CPackString;
  97. class NCBI_XSERIAL_EXPORT CObjectIStream : public CObjectStack
  98. {
  99. public:
  100.     // typedefs
  101.     typedef size_t TObjectIndex;
  103.     // open methods
  104.     virtual void Open(CByteSourceReader& reader);
  105.     void Open(CByteSource& source);
  106.     void Open(CNcbiIstream& inStream, bool deleteInStream = false);
  107.     void Close(void);
  108.     void ResetLocalHooks(void);
  110.     static CObjectIStream* Open(ESerialDataFormat format,
  111.                                 CNcbiIstream& inStream,
  112.                                 bool deleteInStream = false);
  113.     static CObjectIStream* Open(ESerialDataFormat format,
  114.                                 const string& fileName,
  115.                                 TSerialOpenFlags openFlags = 0);
  116.     static CObjectIStream* Open(const string& fileName,
  117.                                 ESerialDataFormat format);
  119.     bool DetectLoops(void) const;
  121.     // when enabled, stream verifies data on input
  122.     // and throws CSerialException with eFormatError err.code
  124.     // for this particular stream
  125.     void SetVerifyData(ESerialVerifyData verify);
  126.     ESerialVerifyData GetVerifyData(void) const;
  127.     // for streams created by the current thread
  128.     static  void SetVerifyDataThread(ESerialVerifyData verify);
  129.     // for streams created by the current process
  130.     static  void SetVerifyDataGlobal(ESerialVerifyData verify);
  132.     // for this particular stream
  133.     void SetSkipUnknownMembers(ESerialSkipUnknown skip);
  134.     ESerialSkipUnknown GetSkipUnknownMembers(void);
  135.     // for streams created by the current thread
  136.     static  void SetSkipUnknownThread(ESerialSkipUnknown skip);
  137.     // for streams created by the current process
  138.     static  void SetSkipUnknownGlobal(ESerialSkipUnknown skip);
  140.     // constructors
  141. protected:
  142.     CObjectIStream(ESerialDataFormat format);
  143.     CObjectIStream(CNcbiIstream& in, bool deleteIn = false);
  145. public:
  146.     virtual ~CObjectIStream(void);
  148.     // get data format
  149.     ESerialDataFormat GetDataFormat(void) const;
  151.     // USER INTERFACE
  152.     // root reader
  153.     void Read(const CObjectInfo& object);
  154.     void Read(TObjectPtr object, TTypeInfo type);
  155.     CObjectInfo Read(const CObjectTypeInfo& type);
  156.     CObjectInfo Read(TTypeInfo type);
  157.     void Skip(const CObjectTypeInfo& type);
  158.     void Skip(TTypeInfo type);
  160.     // file header readers
  161.     virtual string ReadFileHeader(void);
  162.     void SkipFileHeader(TTypeInfo typeInfo);
  163.     virtual string PeekNextTypeName(void);
  165.     enum ENoFileHeader {
  166.         eNoFileHeader
  167.     };
  168.     void Read(const CObjectInfo& object, ENoFileHeader noFileHeader);
  169.     void Read(TObjectPtr object, TTypeInfo type, ENoFileHeader noFileHeader);
  170.     void Skip(TTypeInfo type, ENoFileHeader noFileHeader);
  172.     // subtree reader
  173.     void ReadObject(const CObjectInfo& object);
  174.     void ReadObject(TObjectPtr object, TTypeInfo typeInfo);
  175.     void SkipObject(const CObjectTypeInfo& objectType);
  176.     void SkipObject(TTypeInfo typeInfo);
  178.     // temporary reader
  179.     void ReadSeparateObject(const CObjectInfo& object);
  181.     // member
  182.     void ReadClassMember(const CObjectInfoMI& member);
  184.     // variant
  185.     void ReadChoiceVariant(const CObjectInfoCV& object);
  187.     // END OF USER INTERFACE
  189.     // internal reader
  190.     void ReadExternalObject(TObjectPtr object, TTypeInfo typeInfo);
  191.     void SkipExternalObject(TTypeInfo typeInfo);
  193.     CObjectInfo ReadObject(void);
  195.     virtual void EndOfRead(void);
  196.     
  197.     // try to read enum value name, "" if none
  198.     virtual TEnumValueType ReadEnum(const CEnumeratedTypeValues& values) = 0;
  200.     // std C types readers
  201.     // bool
  202.     void ReadStd(bool& data);
  203.     void SkipStd(const bool &);
  205.     // char
  206.     void ReadStd(char& data);
  207.     void SkipStd(const char& );
  209.     // integer numbers
  210.     void ReadStd(signed char& data);
  211.     void ReadStd(unsigned char& data);
  212.     void SkipStd(const signed char& );
  213.     void SkipStd(const unsigned char& );
  214.     void ReadStd(short& data);
  215.     void ReadStd(unsigned short& data);
  216.     void SkipStd(const short& );
  217.     void SkipStd(const unsigned short& );
  218.     void ReadStd(int& data);
  219.     void ReadStd(unsigned& data);
  220.     void SkipStd(const int& );
  221.     void SkipStd(const unsigned& );
  222. #if SIZEOF_LONG == 4
  223.     void ReadStd(long& data);
  224.     void ReadStd(unsigned long& data);
  225.     void SkipStd(const long& );
  226.     void SkipStd(const unsigned long& );
  227. #endif
  228.     void ReadStd(Int8& data);
  229.     void ReadStd(Uint8& data);
  230.     void SkipStd(const Int8& );
  231.     void SkipStd(const Uint8& );
  233.     // float numbers
  234.     void ReadStd(float& data);
  235.     void ReadStd(double& data);
  236.     void SkipStd(const float& );
  237.     void SkipStd(const double& );
  238. #if SIZEOF_LONG_DOUBLE != 0
  239.     virtual void ReadStd(long double& data);
  240.     virtual void SkipStd(const long double& );
  241. #endif
  243.     // string
  244.     void ReadStd(string& data);
  245.     void SkipStd(const string& );
  246.     void ReadStd(CStringUTF8& data);
  247.     void SkipStd(CStringUTF8& data);
  249.     // C string
  250.     void ReadStd(char* & data);
  251.     void ReadStd(const char* & data);
  252.     void SkipStd(char* const& );
  253.     void SkipStd(const char* const& );
  255.     // primitive readers
  256.     // bool
  257.     virtual bool ReadBool(void) = 0;
  258.     virtual void SkipBool(void) = 0;
  260.     // char
  261.     virtual char ReadChar(void) = 0;
  262.     virtual void SkipChar(void) = 0;
  264.     // integer numbers
  265.     virtual Int1 ReadInt1(void);
  266.     virtual Uint1 ReadUint1(void);
  267.     virtual Int2 ReadInt2(void);
  268.     virtual Uint2 ReadUint2(void);
  269.     virtual Int4 ReadInt4(void);
  270.     virtual Uint4 ReadUint4(void);
  271.     virtual Int8 ReadInt8(void) = 0;
  272.     virtual Uint8 ReadUint8(void) = 0;
  274.     virtual void SkipInt1(void);
  275.     virtual void SkipUint1(void);
  276.     virtual void SkipInt2(void);
  277.     virtual void SkipUint2(void);
  278.     virtual void SkipInt4(void);
  279.     virtual void SkipUint4(void);
  280.     virtual void SkipInt8(void);
  281.     virtual void SkipUint8(void);
  283.     virtual void SkipSNumber(void) = 0;
  284.     virtual void SkipUNumber(void) = 0;
  286.     // float numbers
  287.     virtual float ReadFloat(void);
  288.     virtual double ReadDouble(void) = 0;
  289.     virtual void SkipFloat(void);
  290.     virtual void SkipDouble(void);
  291. #if SIZEOF_LONG_DOUBLE != 0
  292.     virtual long double ReadLDouble(void);
  293.     virtual void SkipLDouble(void);
  294. #endif
  295.     virtual void SkipFNumber(void) = 0;
  297.     // string
  298.     virtual void ReadString(string& s,
  299.                             EStringType type = eStringTypeVisible) = 0;
  300.     virtual void ReadString(string& s,
  301.                             CPackString& pack_string,
  302.                             EStringType type = eStringTypeVisible);
  303.     virtual void SkipString(EStringType type = eStringTypeVisible) = 0;
  305.     // StringStore
  306.     virtual void ReadStringStore(string& s);
  307.     virtual void SkipStringStore(void);
  308.     
  309.     // C string
  310.     virtual char* ReadCString(void);
  311.     virtual void SkipCString(void);
  313.     // null
  314.     virtual void ReadNull(void) = 0;
  315.     virtual void SkipNull(void) = 0;
  317.     // any content object
  318.     virtual void ReadAnyContentObject(CAnyContentObject& obj) = 0;
  319.     virtual void SkipAnyContentObject(void) = 0;
  321.     // octet string
  322.     virtual void SkipByteBlock(void) = 0;
  324.     // reads type info
  325.     virtual pair<TObjectPtr, TTypeInfo> ReadPointer(TTypeInfo declaredType);
  326.     enum EPointerType {
  327.         eNullPointer,
  328.         eObjectPointer,
  329.         eThisPointer,
  330.         eOtherPointer
  331.     };
  333.     void SkipPointer(TTypeInfo declaredType);
  335.     // low level readers:
  336.     enum EFailFlags {
  337.         fNoError       = 0,             eNoError     = fNoError,
  338.         fEOF           = 1 << 0,        eEOF         = fEOF,
  339.         fReadError     = 1 << 1,        eReadError   = fReadError,
  340.         fFormatError   = 1 << 2,        eFormatError = fFormatError,
  341.         fOverflow      = 1 << 3,        eOverflow    = fOverflow,
  342.         fInvalidData   = 1 << 4,        eInvalidData = fInvalidData,
  343.         fIllegalCall   = 1 << 5,        eIllegalCall = fIllegalCall,
  344.         fFail          = 1 << 6,        eFail        = fFail,
  345.         fNotOpen       = 1 << 7,        eNotOpen     = fNotOpen,
  346.         fMissingValue  = 1 << 8,        eMissingValue= fMissingValue
  347.     };
  348.     typedef int TFailFlags;
  350.     bool fail(void) const;
  351.     TFailFlags GetFailFlags(void) const;
  352.     TFailFlags SetFailFlags(TFailFlags flags, const char* message);
  353.     TFailFlags ClearFailFlags(TFailFlags flags);
  354.     bool InGoodState(void);
  355.     virtual string GetStackTrace(void) const;
  356.     virtual string GetPosition(void) const;
  357.     size_t GetStreamOffset(void) const;
  358.     void   SetStreamOffset(size_t pos);
  360.     void ThrowError1(const char* file, int line,
  361.                      TFailFlags fail, const char* message);
  362.     void ThrowError1(const char* file, int line,
  363.                      TFailFlags fail, const string& message);
  364. #define ThrowError(flag, mess) ThrowError1(__FILE__, __LINE__,flag,mess)
  366.     enum EFlags {
  367.         fFlagNone                = 0,
  368.         eFlagNone                = fFlagNone,
  369.         fFlagAllowNonAsciiChars  = 1 << 0,
  370.         eFlagAllowNonAsciiChars  = fFlagAllowNonAsciiChars
  371.     };
  372.     typedef int TFlags;
  373.     TFlags GetFlags(void) const;
  374.     TFlags SetFlags(TFlags flags);
  375.     TFlags ClearFlags(TFlags flags);
  377.     class ByteBlock
  378.     {
  379.     public:
  380.         ByteBlock(CObjectIStream& in);
  381.         ~ByteBlock(void);
  383.         void End(void);
  385.         CObjectIStream& GetStream(void) const;
  387.         size_t Read(void* dst, size_t length, bool forceLength = false);
  389.         bool KnownLength(void) const;
  390.         size_t GetExpectedLength(void) const;
  392.         void SetLength(size_t length);
  393.         void EndOfBlock(void);
  394.         
  395.     private:
  396.         CObjectIStream& m_Stream;
  397.         bool m_KnownLength;
  398.         bool m_Ended;
  399.         size_t m_Length;
  401.         friend class CObjectIStream;
  402.     };
  403.     class CharBlock
  404.     {
  405.     public:
  406.         CharBlock(CObjectIStream& in);
  407.         ~CharBlock(void);
  409.         void End(void);
  411.         CObjectIStream& GetStream(void) const;
  413.         size_t Read(char* dst, size_t length, bool forceLength = false);
  415.         bool KnownLength(void) const;
  416.         size_t GetExpectedLength(void) const;
  418.         void SetLength(size_t length);
  419.         void EndOfBlock(void);
  420.         
  421.     private:
  422.         CObjectIStream& m_Stream;
  423.         bool m_KnownLength;
  424.         bool m_Ended;
  425.         size_t m_Length;
  427.         friend class CObjectIStream;
  428.     };
  431. #if HAVE_NCBI_C
  432.     // ASN.1 interface
  433.     class AsnIo
  434.     {
  435.     public:
  436.         AsnIo(CObjectIStream& in, const string& rootTypeName);
  437.         ~AsnIo(void);
  439.         void End(void);
  441.         CObjectIStream& GetStream(void) const;
  443.         size_t Read(char* data, size_t length);
  444.         
  445.         operator asnio*(void);
  446.         asnio* operator->(void);
  447.         const string& GetRootTypeName(void) const;
  449.     private:
  450.         CObjectIStream& m_Stream;
  451.         bool m_Ended;
  452.         string m_RootTypeName;
  453.         asnio* m_AsnIo;
  454.         
  455.     public:
  456.         size_t m_Count;
  457.     };
  458.     friend class AsnIo;
  459. public:
  460. #endif
  461.     
  462.     // mid level I/O
  463.     // named type
  464.     MLIOVIR void ReadNamedType(TTypeInfo namedTypeInfo,
  465.                                TTypeInfo typeInfo, TObjectPtr object);
  466.     MLIOVIR void SkipNamedType(TTypeInfo namedTypeInfo,
  467.                                TTypeInfo typeInfo);
  469.     // container
  470.     MLIOVIR void ReadContainer(const CContainerTypeInfo* containerType,
  471.                                TObjectPtr containerPtr);
  472.     MLIOVIR void SkipContainer(const CContainerTypeInfo* containerType);
  473.     
  474.     // class
  475.     MLIOVIR void ReadClassSequential(const CClassTypeInfo* classType,
  476.                                      TObjectPtr classPtr);
  477.     MLIOVIR void ReadClassRandom(const CClassTypeInfo* classType,
  478.                                  TObjectPtr classPtr);
  479.     MLIOVIR void SkipClassSequential(const CClassTypeInfo* classType);
  480.     MLIOVIR void SkipClassRandom(const CClassTypeInfo* classType);
  482.     // choice
  483.     MLIOVIR void ReadChoice(const CChoiceTypeInfo* choiceType,
  484.                             TObjectPtr choicePtr);
  485.     MLIOVIR void SkipChoice(const CChoiceTypeInfo* choiceType);
  487.     // alias
  488.     MLIOVIR void ReadAlias(const CAliasTypeInfo* aliasType,
  489.                            TObjectPtr aliasPtr);
  490.     MLIOVIR void SkipAlias(const CAliasTypeInfo* aliasType);
  492.     // low level I/O
  493.     // named type (alias)
  494.     virtual void BeginNamedType(TTypeInfo namedTypeInfo);
  495.     virtual void EndNamedType(void);
  497.     // container
  498.     virtual void BeginContainer(const CContainerTypeInfo* containerType) = 0;
  499.     virtual void EndContainer(void) = 0;
  500.     virtual bool BeginContainerElement(TTypeInfo elementType) = 0;
  501.     virtual void EndContainerElement(void);
  503.     // class
  504.     virtual void BeginClass(const CClassTypeInfo* classInfo) = 0;
  505.     virtual void EndClass(void);
  507.     virtual TMemberIndex BeginClassMember(const CClassTypeInfo* classType) = 0;
  508.     virtual TMemberIndex BeginClassMember(const CClassTypeInfo* classType,
  509.                                           TMemberIndex pos) = 0;
  510.     virtual void EndClassMember(void);
  511.     virtual void UndoClassMember(void) {}
  513.     // choice
  514.     virtual void BeginChoice(const CChoiceTypeInfo* choiceType);
  515.     virtual void EndChoice(void);
  516.     virtual TMemberIndex BeginChoiceVariant(const CChoiceTypeInfo* choiceType) = 0;
  517.     virtual void EndChoiceVariant(void);
  519.     // byte block
  520.     virtual void BeginBytes(ByteBlock& block) = 0;
  521.     virtual size_t ReadBytes(ByteBlock& block, char* buffer, size_t count) = 0;
  522.     virtual void EndBytes(const ByteBlock& block);
  524.     // char block
  525.     virtual void BeginChars(CharBlock& block) = 0;
  526.     virtual size_t ReadChars(CharBlock& block, char* buffer, size_t count) = 0;
  527.     virtual void EndChars(const CharBlock& block);
  529.     // report error about unended block
  530.     void Unended(const string& msg);
  531.     // report error about unended object stack frame
  532.     virtual void UnendedFrame(void);
  534.     void SetPathReadObjectHook( const string& path, CReadObjectHook*        hook);
  535.     void SetPathSkipObjectHook( const string& path, CSkipObjectHook*        hook);
  536.     void SetPathReadMemberHook( const string& path, CReadClassMemberHook*   hook);
  537.     void SetPathSkipMemberHook( const string& path, CSkipClassMemberHook*   hook);
  538.     void SetPathReadVariantHook(const string& path, CReadChoiceVariantHook* hook);
  539.     void SetPathSkipVariantHook(const string& path, CSkipChoiceVariantHook* hook);
  541.     // report error about class members
  542.     void DuplicatedMember(const CMemberInfo* memberInfo);
  543.     void ExpectedMember(const CMemberInfo* memberInfo);
  545.     void StartDelayBuffer(void);
  546.     CRef<CByteSource> EndDelayBuffer(void);
  547.     void EndDelayBuffer(CDelayBuffer& buffer,
  548.                         const CItemInfo* itemInfo, TObjectPtr objectPtr);
  550.     void SetDiscardCurrObject(bool discard=true)
  551.         {m_DiscardCurrObject = discard;}
  552.     bool GetDiscardCurrObject(void) const
  553.         {return m_DiscardCurrObject;}
  555.     bool HaveMoreData(void);
  557. protected:
  558.     friend class CObjectStreamCopier;
  560.     // low level readers
  561.     pair<TObjectPtr, TTypeInfo> ReadObjectInfo(void);
  562.     virtual EPointerType ReadPointerType(void) = 0;
  563.     virtual TObjectIndex ReadObjectPointer(void) = 0;
  564.     virtual string ReadOtherPointer(void) = 0;
  565.     virtual void ReadOtherPointerEnd(void);
  567.     void RegisterObject(TTypeInfo typeInfo);
  568.     void RegisterObject(TObjectPtr object, TTypeInfo typeInfo);
  569.     const CReadObjectInfo& GetRegisteredObject(TObjectIndex index);
  570.     virtual void x_SetPathHooks(bool set);
  572. public:
  573.     // open helpers
  574.     static CObjectIStream* Create(ESerialDataFormat format);
  575.     static CObjectIStream* Create(ESerialDataFormat format,
  576.                                   CByteSource& source);
  577.     static CObjectIStream* Create(ESerialDataFormat format,
  578.                                   CByteSourceReader& reader);
  579. private:
  580.     static CRef<CByteSource> GetSource(ESerialDataFormat format,
  581.                                        const string& fileName,
  582.                                        TSerialOpenFlags openFlags = 0);
  583.     static CRef<CByteSource> GetSource(CNcbiIstream& inStream,
  584.                                        bool deleteInStream = false);
  586.     static CObjectIStream* CreateObjectIStreamAsn(void);
  587.     static CObjectIStream* CreateObjectIStreamAsnBinary(void);
  588.     static CObjectIStream* CreateObjectIStreamXml(void);
  590. protected:
  591.     CIStreamBuffer m_Input;
  592.     bool m_DiscardCurrObject;
  593.     ESerialDataFormat   m_DataFormat;
  594.     
  595. private:
  596.     ESerialVerifyData   m_VerifyData;
  597.     static ESerialVerifyData ms_VerifyDataDefault;
  598.     static ESerialVerifyData x_GetVerifyDataDefault(void);
  599.     ESerialSkipUnknown m_SkipUnknown;
  600.     static ESerialSkipUnknown ms_SkipUnknownDefault;
  601.     static ESerialSkipUnknown x_GetSkipUnknownDefault(void);
  603.     AutoPtr<CReadObjectList> m_Objects;
  605.     TFailFlags m_Fail;
  606.     TFlags m_Flags;
  607.     CStreamObjectPathHook<CReadObjectHook*>                m_PathReadObjectHooks;
  608.     CStreamObjectPathHook<CSkipObjectHook*>                m_PathSkipObjectHooks;
  609.     CStreamPathHook<CMemberInfo*, CReadClassMemberHook*>   m_PathReadMemberHooks;
  610.     CStreamPathHook<CMemberInfo*, CSkipClassMemberHook*>   m_PathSkipMemberHooks;
  611.     CStreamPathHook<CVariantInfo*,CReadChoiceVariantHook*> m_PathReadVariantHooks;
  612.     CStreamPathHook<CVariantInfo*,CSkipChoiceVariantHook*> m_PathSkipVariantHooks;
  614. public:
  615.     // hook support
  616.     CLocalHookSet<CReadObjectHook> m_ObjectHookKey;
  617.     CLocalHookSet<CReadClassMemberHook> m_ClassMemberHookKey;
  618.     CLocalHookSet<CReadChoiceVariantHook> m_ChoiceVariantHookKey;
  619.     CLocalHookSet<CSkipObjectHook> m_ObjectSkipHookKey;
  620.     CLocalHookSet<CSkipClassMemberHook> m_ClassMemberSkipHookKey;
  621.     CLocalHookSet<CSkipChoiceVariantHook> m_ChoiceVariantSkipHookKey;
  622. };
  624. inline
  625. bool GoodVisibleChar(char c);
  627. char ReplaceVisibleChar(char c, EFixNonPrint fix_method, size_t at_line);
  629. inline
  630. void FixVisibleChar(char& c, EFixNonPrint fix_method, size_t at_line = 0);
  633. /// Guard class for CObjectIStream::StartDelayBuffer/EndDelayBuffer
  634. ///
  635. /// CObjectIStream::StartDelayBuffer() should be follwed by 
  636. /// CObjectIStream::EndDelayBuffer() call. If it's not called we have a delay 
  637. /// buffer leak. This class works as an guard (or auto pointer) to avoid call
  638. /// leaks.
  639. class NCBI_XSERIAL_EXPORT CStreamDelayBufferGuard 
  640. {
  641. public:
  642.     /// Construct instance on a given CObjectIStream object.
  643.     /// Call istr.StartDelayBuffer()
  644.     ///
  645.     /// @param istr  guard protected instance
  646.     CStreamDelayBufferGuard(CObjectIStream& istr);
  648.     ~CStreamDelayBufferGuard();
  650.     /// Redirect call to protected CObjectIStream
  651.     /// After this call guarding is finished.
  652.     CRef<CByteSource> EndDelayBuffer(void);
  654.     /// Redirect call to protected CObjectIStream
  655.     /// After this call guarding is finished.
  656.     void EndDelayBuffer(CDelayBuffer&    buffer,
  657.                         const CItemInfo* itemInfo, 
  658.                         TObjectPtr       objectPtr);
  659.     
  660. private:
  661.     CStreamDelayBufferGuard(const CStreamDelayBufferGuard&);
  662.     CStreamDelayBufferGuard& operator=(const CStreamDelayBufferGuard& );
  663. private:
  664.     CObjectIStream*  m_ObjectIStream;
  665. };
  669. /* @} */
  672. #include <serial/objistr.inl>
  674. END_NCBI_SCOPE
  676. #endif  /* OBJISTR__HPP */
  680. /* ---------------------------------------------------------------------------
  681. * $Log: objistr.hpp,v $
  682. * Revision 1000.5  2004/06/01 19:38:53  gouriano
  683. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.103
  684. *
  685. * Revision 1.103  2004/04/30 13:28:40  gouriano
  686. * Remove obsolete function declarations
  687. *
  688. * Revision 1.102  2004/03/23 15:39:52  gouriano
  689. * Added setup options for skipping unknown data members
  690. *
  691. * Revision 1.101  2004/03/05 20:28:37  gouriano
  692. * make it possible to skip unknown data fields
  693. *
  694. * Revision 1.100  2004/02/09 18:21:52  gouriano
  695. * enforced checking environment vars when setting initialization
  696. * verification parameters
  697. *
  698. * Revision 1.99  2004/01/22 20:47:25  gouriano
  699. * Added new exception error code (eMissingValue)
  700. *
  701. * Revision 1.98  2004/01/05 14:24:08  gouriano
  702. * Added possibility to set serialization hooks by stack path
  703. *
  704. * Revision 1.97  2003/12/31 21:02:20  gouriano
  705. * added possibility to seek (when possible) in CObjectIStream
  706. *
  707. * Revision 1.96  2003/11/26 19:59:37  vasilche
  708. * GetPosition() and GetDataFormat() methods now are implemented
  709. * in parent classes CObjectIStream and CObjectOStream to avoid
  710. * pure virtual method call in destructors.
  711. *
  712. * Revision 1.95  2003/11/19 15:42:09  vasilche
  713. * Added CObjectIStream::HaveMoreData().
  714. *
  715. * Revision 1.94  2003/11/13 14:06:45  gouriano
  716. * Elaborated data verification on read/write/get to enable skipping mandatory class data members
  717. *
  718. * Revision 1.93  2003/10/21 21:08:45  grichenk
  719. * Fixed aliases-related bug in XML stream
  720. *
  721. * Revision 1.92  2003/09/30 16:10:34  vasilche
  722. * Added one more variant of object streams creation.
  723. *
  724. * Revision 1.91  2003/09/25 12:39:08  kuznets
  725. * Added dllexport for CStreamDelayBufferGuard
  726. *
  727. * Revision 1.90  2003/09/24 20:55:13  kuznets
  728. * Implemented CStreamDelayBufferGuard
  729. *
  730. * Revision 1.89  2003/09/16 14:49:15  gouriano
  731. * Enhanced AnyContent objects to support XML namespaces and attribute info items.
  732. *
  733. * Revision 1.88  2003/09/10 20:57:23  gouriano
  734. * added possibility to ignore missing mandatory members on reading
  735. *
  736. * Revision 1.87  2003/08/26 19:24:48  gouriano
  737. * added possibility to discard a member of an STL container
  738. * (from a read hook)
  739. *
  740. * Revision 1.86  2003/08/19 18:32:37  vasilche
  741. * Optimized reading and writing strings.
  742. * Avoid string reallocation when checking char values.
  743. * Try to reuse old string data when string reference counting is not working.
  744. *
  745. * Revision 1.85  2003/08/13 15:47:02  gouriano
  746. * implemented serialization of AnyContent objects
  747. *
  748. * Revision 1.84  2003/07/29 18:47:46  vasilche
  749. * Fixed thread safeness of object stream hooks.
  750. *
  751. * Revision 1.83  2003/05/22 20:08:41  gouriano
  752. * added UTF8 strings
  753. *
  754. * Revision 1.82  2003/05/15 17:45:25  gouriano
  755. * added GetStreamOffset method
  756. *
  757. * Revision 1.81  2003/04/15 16:18:20  siyan
  758. * Added doxygen support
  759. *
  760. * Revision 1.80  2003/03/10 18:52:37  gouriano
  761. * use new structured exceptions (based on CException)
  762. *
  763. * Revision 1.79  2003/01/28 15:26:23  vasilche
  764. * Added low level CObjectIStream::EndDelayBuffer(void);
  765. *
  766. * Revision 1.78  2002/12/23 18:38:51  dicuccio
  767. * Added WIn32 export specifier: NCBI_XSERIAL_EXPORT.
  768. * Moved all CVS logs to the end.
  769. *
  770. * Revision 1.77  2002/12/13 21:51:05  gouriano
  771. * corrected reading of choices
  772. *
  773. * Revision 1.76  2002/12/12 21:10:26  gouriano
  774. * implemented handling of complex XML containers
  775. *
  776. * Revision 1.75  2002/11/14 20:49:52  gouriano
  777. * added BeginChoice/EndChoice methods
  778. *
  779. * Revision 1.74  2002/11/04 21:28:59  grichenk
  780. * Fixed usage of const CRef<> and CRef<> constructor
  781. *
  782. * Revision 1.73  2002/10/25 14:49:29  vasilche
  783. * NCBI C Toolkit compatibility code extracted to libxcser library.
  784. * Serial streams flags names were renamed to fXxx.
  785. *
  786. * Names of flags
  787. *
  788. * Revision 1.72  2002/10/15 13:45:15  gouriano
  789. * added "UndoClassMember" function
  790. *
  791. * Revision 1.71  2002/09/09 18:13:59  grichenk
  792. * Added CObjectHookGuard class.
  793. * Added methods to be used by hooks for data
  794. * reading and skipping.
  795. *
  796. * Revision 1.70  2001/10/17 20:41:19  grichenk
  797. * Added CObjectOStream::CharBlock class
  798. *
  799. * Revision 1.69  2001/07/17 14:52:39  kholodov
  800. * Fixed: replaced int argument by size_t in CheckVisibleChar() and
  801. * ReplaceVisibleChar to avoid truncation in 64 bit mode.
  802. *
  803. * Revision 1.68  2001/06/11 14:34:55  grichenk
  804. * Added support for numeric tags in ASN.1 specifications and data streams.
  805. *
  806. * Revision 1.67  2001/06/07 17:12:46  grichenk
  807. * Redesigned checking and substitution of non-printable characters
  808. * in VisibleString
  809. *
  810. * Revision 1.66  2001/05/17 14:59:11  lavr
  811. * Typos corrected
  812. *
  813. * Revision 1.65  2001/05/16 17:55:33  grichenk
  814. * Redesigned support for non-blocking stream read operations
  815. *
  816. * Revision 1.64  2001/05/11 20:41:11  grichenk
  817. * Added support for non-blocking stream reading
  818. *
  819. * Revision 1.63  2001/01/05 20:10:35  vasilche
  820. * CByteSource, CIStrBuffer, COStrBuffer, CLightString, CChecksum, CWeakMap
  821. * were moved to util.
  822. *
  823. * Revision 1.62  2001/01/05 13:57:18  vasilche
  824. * Fixed overloaded method ambiguity on Mac.
  825. *
  826. * Revision 1.61  2000/12/26 22:23:44  vasilche
  827. * Fixed errors of compilation on Mac.
  828. *
  829. * Revision 1.60  2000/12/26 17:26:09  vasilche
  830. * Added one more Read() interface method.
  831. *
  832. * Revision 1.59  2000/12/15 21:28:46  vasilche
  833. * Moved some typedefs/enums from corelib/ncbistd.hpp.
  834. * Added flags to CObjectIStream/CObjectOStream: eFlagAllowNonAsciiChars.
  835. * TByte typedef replaced by Uint1.
  836. *
  837. * Revision 1.58  2000/12/15 15:37:59  vasilche
  838. * Added support of Int8 and long double.
  839. * Enum values now have type Int4 instead of long.
  840. *
  841. * Revision 1.57  2000/10/20 19:29:15  vasilche
  842. * Adapted for MSVC which doesn't like explicit operator templates.
  843. *
  844. * Revision 1.56  2000/10/20 15:51:26  vasilche
  845. * Fixed data error processing.
  846. * Added interface for constructing container objects directly into output stream.
  847. * object.hpp, object.inl and object.cpp were split to
  848. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  849. *
  850. * Revision 1.55  2000/10/17 18:45:24  vasilche
  851. * Added possibility to turn off object cross reference detection in
  852. * CObjectIStream and CObjectOStream.
  853. *
  854. * Revision 1.54  2000/10/13 20:59:12  vasilche
  855. * Avoid using of ssize_t absent on some compilers.
  856. *
  857. * Revision 1.53  2000/10/13 20:22:46  vasilche
  858. * Fixed warnings on 64 bit compilers.
  859. * Fixed missing typename in templates.
  860. *
  861. * Revision 1.52  2000/10/13 16:28:31  vasilche
  862. * Reduced header dependency.
  863. * Avoid use of templates with virtual methods.
  864. * Reduced amount of different maps used.
  865. * All this lead to smaller compiled code size (libraries and programs).
  866. *
  867. * Revision 1.51  2000/10/03 17:22:34  vasilche
  868. * Reduced header dependency.
  869. * Reduced size of debug libraries on WorkShop by 3 times.
  870. * Fixed tag allocation for parent classes.
  871. * Fixed CObject allocation/deallocation in streams.
  872. * Moved instantiation of several templates in separate source file.
  873. *
  874. * Revision 1.50  2000/09/29 16:18:13  vasilche
  875. * Fixed binary format encoding/decoding on 64 bit compulers.
  876. * Implemented CWeakMap<> for automatic cleaning map entries.
  877. * Added cleaning local hooks via CWeakMap<>.
  878. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  879. * Added some user interface methods to CObjectIStream, CObjectOStream and
  880. * CObjectStreamCopier.
  881. *
  882. * Revision 1.49  2000/09/18 20:00:04  vasilche
  883. * Separated CVariantInfo and CMemberInfo.
  884. * Implemented copy hooks.
  885. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  886. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  887. *
  888. * Revision 1.48  2000/09/01 13:16:00  vasilche
  889. * Implemented class/container/choice iterators.
  890. * Implemented CObjectStreamCopier for copying data without loading into memory.
  891. *
  892. * Revision 1.47  2000/08/15 19:44:40  vasilche
  893. * Added Read/Write hooks:
  894. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  895. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  896. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  897. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  898. *
  899. * Revision 1.46  2000/07/03 18:42:35  vasilche
  900. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  901. * Reduced header dependency.
  902. *
  903. * Revision 1.45  2000/06/16 20:01:20  vasilche
  904. * Avoid use of unexpected_exception() which is unimplemented on Mac.
  905. *
  906. * Revision 1.44  2000/06/16 16:31:06  vasilche
  907. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  908. *
  909. * Revision 1.43  2000/06/07 19:45:42  vasilche
  910. * Some code cleaning.
  911. * Macros renaming in more clear way.
  912. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  913. *
  914. * Revision 1.42  2000/06/01 19:06:56  vasilche
  915. * Added parsing of XML data.
  916. *
  917. * Revision 1.41  2000/05/24 20:08:13  vasilche
  918. * Implemented XML dump.
  919. *
  920. * Revision 1.40  2000/05/09 16:38:33  vasilche
  921. * CObject::GetTypeInfo now moved to CObjectGetTypeInfo::GetTypeInfo to reduce possible errors.
  922. * Added write context to CObjectOStream.
  923. * Inlined most of methods of helping class Member, Block, ByteBlock etc.
  924. *
  925. * Revision 1.39  2000/05/04 16:22:23  vasilche
  926. * Cleaned and optimized blocks and members.
  927. *
  928. * Revision 1.38  2000/04/28 16:58:02  vasilche
  929. * Added classes CByteSource and CByteSourceReader for generic reading.
  930. * Added delayed reading of choice variants.
  931. *
  932. * Revision 1.37  2000/04/13 14:50:17  vasilche
  933. * Added CObjectIStream::Open() and CObjectOStream::Open() for easier use.
  934. *
  935. * Revision 1.36  2000/04/06 16:10:50  vasilche
  936. * Fixed bug with iterators in choices.
  937. * Removed unneeded calls to ReadExternalObject/WriteExternalObject.
  938. * Added output buffering to text ASN.1 data.
  939. *
  940. * Revision 1.35  2000/03/14 14:43:29  vasilche
  941. * Fixed error reporting.
  942. *
  943. * Revision 1.34  2000/03/07 14:05:30  vasilche
  944. * Added stream buffering to ASN.1 binary input.
  945. * Optimized class loading/storing.
  946. * Fixed bugs in processing OPTIONAL fields.
  947. *
  948. * Revision 1.33  2000/01/10 20:04:07  vasilche
  949. * Fixed duplicate name.
  950. *
  951. * Revision 1.32  2000/01/10 19:46:31  vasilche
  952. * Fixed encoding/decoding of REAL type.
  953. * Fixed encoding/decoding of StringStore.
  954. * Fixed encoding/decoding of NULL type.
  955. * Fixed error reporting.
  956. * Reduced object map (only classes).
  957. *
  958. * Revision 1.31  2000/01/05 19:43:44  vasilche
  959. * Fixed error messages when reading from ASN.1 binary file.
  960. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  961. * Added TAG support to key/value of map.
  962. * Added support of NULL variant in CHOICE.
  963. *
  964. * Revision 1.30  1999/12/20 15:29:31  vasilche
  965. * Fixed bug with old ASN structures.
  966. *
  967. * Revision 1.29  1999/12/17 19:04:53  vasilche
  968. * Simplified generation of GetTypeInfo methods.
  969. *
  970. * Revision 1.28  1999/10/18 20:11:15  vasilche
  971. * Enum values now have long type.
  972. * Fixed template generation for enums.
  973. *
  974. * Revision 1.27  1999/10/04 16:22:08  vasilche
  975. * Fixed bug with old ASN.1 structures.
  976. *
  977. * Revision 1.26  1999/09/27 14:17:59  vasilche
  978. * Fixed bug with overloaded constructors of Block.
  979. *
  980. * Revision 1.25  1999/09/24 18:19:13  vasilche
  981. * Removed dependency on NCBI toolkit.
  982. *
  983. * Revision 1.24  1999/09/23 18:56:51  vasilche
  984. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  985. *
  986. * Revision 1.23  1999/09/22 20:11:48  vasilche
  987. * Modified for compilation on IRIX native c++ compiler.
  988. *
  989. * Revision 1.22  1999/09/14 18:54:03  vasilche
  990. * Fixed bugs detected by gcc & egcs.
  991. * Removed unneeded includes.
  992. *
  993. * Revision 1.21  1999/08/16 16:07:43  vasilche
  994. * Added ENUMERATED type.
  995. *
  996. * Revision 1.20  1999/08/13 15:53:43  vasilche
  997. * C++ analog of asntool: datatool
  998. *
  999. * Revision 1.19  1999/07/26 18:31:28  vasilche
  1000. * Implemented skipping of unused values.
  1001. * Added more useful error report.
  1002. *
  1003. * Revision 1.18  1999/07/22 20:36:37  vasilche
  1004. * Fixed 'using namespace' declaration for MSVC.
  1005. *
  1006. * Revision 1.17  1999/07/22 17:33:40  vasilche
  1007. * Unified reading/writing of objects in all three formats.
  1008. *
  1009. * Revision 1.16  1999/07/21 14:19:55  vasilche
  1010. * Added serialization of bool.
  1011. *
  1012. * Revision 1.15  1999/07/19 15:50:15  vasilche
  1013. * Added interface to old ASN.1 routines.
  1014. * Added naming of key/value in STL map.
  1015. *
  1016. * Revision 1.14  1999/07/15 16:54:42  vasilche
  1017. * Implemented vector<X> & vector<char> as special case.
  1018. *
  1019. * Revision 1.13  1999/07/09 16:32:53  vasilche
  1020. * Added OCTET STRING write/read.
  1021. *
  1022. * Revision 1.12  1999/07/07 21:15:03  vasilche
  1023. * Cleaned processing of string types (string, char*, const char*).
  1024. *
  1025. * Revision 1.11  1999/07/02 21:31:43  vasilche
  1026. * Implemented reading from ASN.1 binary format.
  1027. *
  1028. * Revision 1.10  1999/07/01 17:55:19  vasilche
  1029. * Implemented ASN.1 binary write.
  1030. *
  1031. * Revision 1.9  1999/06/30 16:04:27  vasilche
  1032. * Added support for old ASN.1 structures.
  1033. *
  1034. * Revision 1.8  1999/06/24 14:44:39  vasilche
  1035. * Added binary ASN.1 output.
  1036. *
  1037. * Revision 1.7  1999/06/17 20:42:00  vasilche
  1038. * Fixed storing/loading of pointers.
  1039. *
  1040. * Revision 1.6  1999/06/16 20:35:21  vasilche
  1041. * Cleaned processing of blocks of data.
  1042. * Added input from ASN.1 text format.
  1043. *
  1044. * Revision 1.5  1999/06/15 16:20:01  vasilche
  1045. * Added ASN.1 object output stream.
  1046. *
  1047. * Revision 1.4  1999/06/10 21:06:38  vasilche
  1048. * Working binary output and almost working binary input.
  1049. *
  1050. * Revision 1.3  1999/06/07 19:30:15  vasilche
  1051. * More bug fixes
  1052. *
  1053. * Revision 1.2  1999/06/04 20:51:32  vasilche
  1054. * First compilable version of serialization.
  1055. *
  1056. * Revision 1.1  1999/05/19 19:56:24  vasilche
  1057. * Commit just in case.
  1058. *
  1059. * ===========================================================================
  1060. */