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

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

生物技术

开发平台：

C/C++

objostr.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objostr.hpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:39:02  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.86
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef OBJOSTR__HPP
  11. #define OBJOSTR__HPP
  13. /*  $Id: objostr.hpp,v 1000.4 2004/06/01 19:39:02 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/ncbifloat.h>
  46. #include <corelib/ncbiobj.hpp>
  47. #include <corelib/ncbiutil.hpp>
  48. #include <serial/serialdef.hpp>
  49. #include <serial/typeinfo.hpp>
  50. #include <util/strbuffer.hpp>
  51. #include <serial/objlist.hpp>
  52. #include <serial/objstack.hpp>
  53. #include <serial/hookdatakey.hpp>
  54. #include <serial/objhook.hpp>
  55. #include <serial/pathhook.hpp>
  58. /** @addtogroup ObjStreamSupport
  59.  *
  60.  * @{
  61.  */
  64. struct asnio;
  66. BEGIN_NCBI_SCOPE
  68. class CMemberId;
  69. class CDelayBuffer;
  71. class CConstObjectInfo;
  72. class CConstObjectInfoMI;
  74. class CWriteObjectHook;
  75. class CWriteClassMembersHook;
  76. class CWriteChoiceVariantHook;
  78. class CContainerTypeInfo;
  79. class CClassTypeInfo;
  80. class CChoiceTypeInfo;
  81. class CObjectStreamCopier;
  82. class CAliasTypeInfo;
  84. class CWriteObjectInfo;
  85. class CWriteObjectList;
  87. class NCBI_XSERIAL_EXPORT CObjectOStream : public CObjectStack
  88. {
  89. public:
  90.     typedef size_t TObjectIndex;
  92.     // open methods
  93.     static CObjectOStream* Open(ESerialDataFormat format,
  94.                                 const string& fileName,
  95.                                 TSerialOpenFlags openFlags = 0);
  96.     static CObjectOStream* Open(const string& fileName,
  97.                                 ESerialDataFormat format);
  98.     static CObjectOStream* Open(ESerialDataFormat format,
  99.                                 CNcbiOstream& outStream,
  100.                                 bool deleteOutStream = false);
  102.     void Close(void);
  103.     void ResetLocalHooks(void);
  105.     // when enabled, stream verifies data on output
  106.     // and throws CUnassignedMember exception
  108.     // for this particular stream
  109.     void SetVerifyData(ESerialVerifyData verify);
  110.     ESerialVerifyData GetVerifyData(void) const;
  111.     // for streams created by the current thread
  112.     static  void SetVerifyDataThread(ESerialVerifyData verify);
  113.     // for streams created by the current process
  114.     static  void SetVerifyDataGlobal(ESerialVerifyData verify);
  116.     void SetUseIndentation(bool set);
  117.     bool GetUseIndentation(void) const;
  119.     // constructors
  120. protected:
  121.     CObjectOStream(ESerialDataFormat format,
  122.                    CNcbiOstream& out, bool deleteOut = false);
  124. public:
  125.     virtual ~CObjectOStream(void);
  127.     // get data format
  128.     ESerialDataFormat GetDataFormat(void) const;
  130.     // USER INTERFACE
  131.     // flush buffer
  132.     void FlushBuffer(void);
  133.     // flush buffer and underlying stream
  134.     void Flush(void);
  136.     // root writer
  137.     void Write(const CConstObjectInfo& object);
  138.     void Write(TConstObjectPtr object, TTypeInfo type);
  139.     void Write(TConstObjectPtr object, const CTypeRef& type);
  141.     // subtree writer
  142.     void WriteObject(const CConstObjectInfo& object);
  143.     void WriteObject(TConstObjectPtr object, TTypeInfo typeInfo);
  145.     void CopyObject(TTypeInfo objectType,
  146.                     CObjectStreamCopier& copier);
  147.     
  148.     void WriteSeparateObject(const CConstObjectInfo& object);
  150.     // internal writer
  151.     void WriteExternalObject(TConstObjectPtr object, TTypeInfo typeInfo);
  153.     // member interface
  154.     void WriteClassMember(const CConstObjectInfoMI& member);
  156.     // choice variant interface
  157.     void WriteChoiceVariant(const CConstObjectInfoCV& member);
  159.     // Separator management
  160.     string GetSeparator(void) const;
  161.     void SetSeparator(const string sep);
  162.     // Controls auto-output of the separator after each object. By default
  163.     // this flag is true for text ASN.1 streams only.
  164.     bool GetAutoSeparator(void);
  165.     void SetAutoSeparator(bool value);
  167.     CObjectOStream& operator<< (CObjectOStream& (*mod)(CObjectOStream& os));
  168.     friend CObjectOStream& Separator(CObjectOStream& os);
  170.     // END OF USER INTERFACE
  172.     // low level writers
  174.     // root object
  175.     virtual void WriteFileHeader(TTypeInfo type);
  176.     virtual void EndOfWrite(void);
  178.     // std C types readers
  179.     // bool
  180.     void WriteStd(const bool& data);
  182.     // char
  183.     void WriteStd(const char& data);
  185.     // integer number
  186.     void WriteStd(const signed char& data);
  187.     void WriteStd(const unsigned char& data);
  188.     void WriteStd(const short& data);
  189.     void WriteStd(const unsigned short& data);
  190.     void WriteStd(const int& data);
  191.     void WriteStd(const unsigned int& data);
  192. #if SIZEOF_LONG == 4
  193.     void WriteStd(const long& data);
  194.     void WriteStd(const unsigned long& data);
  195. #endif
  196.     void WriteStd(const Int8& data);
  197.     void WriteStd(const Uint8& data);
  199.     // float number
  200.     void WriteStd(const float& data);
  201.     void WriteStd(const double& data);
  202. #if SIZEOF_LONG_DOUBLE != 0
  203.     void WriteStd(const long double& data);
  204. #endif
  206.     // string
  207.     void WriteStd(const string& data);
  208.     void WriteStd(const CStringUTF8& data);
  210.     // C string; VisualAge can't cope with refs here.
  211.     void WriteStd(const char* const data);
  212.     void WriteStd(char* const data);
  214.     // primitive writers
  215.     // bool
  216.     virtual void WriteBool(bool data) = 0;
  218.     // char
  219.     virtual void WriteChar(char data) = 0;
  221.     // integer numbers
  222.     virtual void WriteInt4(Int4 data) = 0;
  223.     virtual void WriteUint4(Uint4 data) = 0;
  224.     virtual void WriteInt8(Int8 data) = 0;
  225.     virtual void WriteUint8(Uint8 data) = 0;
  227.     // float numbers
  228.     virtual void WriteFloat(float data);
  229.     virtual void WriteDouble(double data) = 0;
  230. #if SIZEOF_LONG_DOUBLE != 0
  231.     virtual void WriteLDouble(long double data);
  232. #endif
  234.     // string
  235.     virtual void WriteString(const string& str,
  236.                              EStringType type = eStringTypeVisible) = 0;
  237.     virtual void CopyString(CObjectIStream& in) = 0;
  239.     // StringStore
  240.     virtual void WriteStringStore(const string& data) = 0;
  241.     virtual void CopyStringStore(CObjectIStream& in) = 0;
  243.     // C string
  244.     virtual void WriteCString(const char* str) = 0;
  246.     // NULL
  247.     virtual void WriteNull(void) = 0;
  249.     // enum
  250.     virtual void WriteEnum(const CEnumeratedTypeValues& values,
  251.                            TEnumValueType value) = 0;
  252.     virtual void CopyEnum(const CEnumeratedTypeValues& values,
  253.                           CObjectIStream& in) = 0;
  255.     // any content object
  256.     virtual void WriteAnyContentObject(const CAnyContentObject& obj) = 0;
  257.     virtual void CopyAnyContentObject(CObjectIStream& in) = 0;
  259.     // delayed buffer
  260.     virtual bool Write(CByteSource& source);
  262.     // low level readers:
  263.     enum EFailFlags {
  264.         fNoError       = 0,             eNoError     = fNoError,
  265.         fEOF           = 1 << 0,        eEOF         = fEOF,
  266.         fWriteError    = 1 << 1,        eWriteError  = fWriteError,
  267.         fFormatError   = 1 << 2,        eFormatError = fFormatError,
  268.         fOverflow      = 1 << 3,        eOverflow    = fOverflow,
  269.         fInvalidData   = 1 << 4,        eInvalidData = fInvalidData,
  270.         fIllegalCall   = 1 << 5,        eIllegalCall = fIllegalCall,
  271.         fFail          = 1 << 6,        eFail        = fFail,
  272.         fNotOpen       = 1 << 7,        eNotOpen     = fNotOpen,
  273.         fUnassigned    = 1 << 8,        eUnassigned  = fUnassigned
  274.     };
  275.     typedef int TFailFlags;
  276.     bool fail(void) const;
  277.     TFailFlags GetFailFlags(void) const;
  278.     TFailFlags SetFailFlagsNoError(TFailFlags flags);
  279.     TFailFlags SetFailFlags(TFailFlags flags, const char* message);
  280.     TFailFlags ClearFailFlags(TFailFlags flags);
  281.     bool InGoodState(void);
  282.     virtual string GetStackTrace(void) const;
  283.     virtual string GetPosition(void) const;
  284.     size_t GetStreamOffset(void) const;
  286.     enum EFlags {
  287.         fFlagNone                = 0,
  288.         eFlagNone                = fFlagNone,
  289.         fFlagAllowNonAsciiChars  = 1 << 0,
  290.         eFlagAllowNonAsciiChars  = fFlagAllowNonAsciiChars
  291.     };
  292.     typedef int TFlags;
  293.     TFlags GetFlags(void) const;
  294.     TFlags SetFlags(TFlags flags);
  295.     TFlags ClearFlags(TFlags flags);
  297.     void ThrowError1(const char* file, int line,
  298.                      TFailFlags fail, const char* message);
  299.     void ThrowError1(const char* file, int line,
  300.                      TFailFlags fail, const string& message);
  301. #define ThrowError(flag, mess) ThrowError1(__FILE__, __LINE__,flag,mess)
  303.     class ByteBlock;
  304.     friend class ByteBlock;
  305.     class ByteBlock
  306.     {
  307.     public:
  308.         ByteBlock(CObjectOStream& out, size_t length);
  309.         ~ByteBlock(void);
  311.         CObjectOStream& GetStream(void) const;
  313.         size_t GetLength(void) const;
  315.         void Write(const void* bytes, size_t length);
  317.         void End(void);
  319.     private:
  320.         CObjectOStream& m_Stream;
  321.         size_t m_Length;
  322.         bool m_Ended;
  323.     };
  324.     class CharBlock;
  325.     friend class CharBlock;
  326.     class NCBI_XSERIAL_EXPORT CharBlock
  327.     {
  328.     public:
  329.         CharBlock(CObjectOStream& out, size_t length);
  330.         ~CharBlock(void);
  332.         CObjectOStream& GetStream(void) const;
  334.         size_t GetLength(void) const;
  336.         void Write(const char* chars, size_t length);
  338.         void End(void);
  340.     private:
  341.         CObjectOStream& m_Stream;
  342.         size_t m_Length;
  343.         bool m_Ended;
  344.     };
  346. #if HAVE_NCBI_C
  347.     class AsnIo
  348.     {
  349.     public:
  350.         AsnIo(CObjectOStream& out, const string& rootTypeName);
  351.         ~AsnIo(void);
  353.         CObjectOStream& GetStream(void) const;
  355.         void Write(const char* data, size_t length);
  357.         void End(void);
  359.         operator asnio*(void);
  360.         asnio* operator->(void);
  361.         const string& GetRootTypeName(void) const;
  363.     private:
  364.         CObjectOStream& m_Stream;
  365.         string m_RootTypeName;
  366.         asnio* m_AsnIo;
  367.         bool m_Ended;
  369.     public:
  370.         size_t m_Count;
  371.     };
  372.     friend class AsnIo;
  373. public:
  374. #endif
  376.     // mid level I/O
  377.     // named type (alias)
  378.     MLIOVIR void WriteNamedType(TTypeInfo namedTypeInfo,
  379.                                 TTypeInfo typeInfo, TConstObjectPtr object);
  380.     // container
  381.     MLIOVIR void WriteContainer(const CContainerTypeInfo* containerType,
  382.                                 TConstObjectPtr containerPtr);
  383.     void WriteContainerElement(const CConstObjectInfo& element);
  384.     // class
  385.     void WriteClassRandom(const CClassTypeInfo* classType,
  386.                           TConstObjectPtr classPtr);
  387.     void WriteClassSequential(const CClassTypeInfo* classType,
  388.                               TConstObjectPtr classPtr);
  389.     MLIOVIR void WriteClass(const CClassTypeInfo* objectType,
  390.                             TConstObjectPtr objectPtr);
  391.     MLIOVIR void WriteClassMember(const CMemberId& memberId,
  392.                                   TTypeInfo memberType,
  393.                                   TConstObjectPtr memberPtr);
  394.     MLIOVIR bool WriteClassMember(const CMemberId& memberId,
  395.                                   const CDelayBuffer& buffer);
  396.     // choice
  397.     MLIOVIR void WriteChoice(const CChoiceTypeInfo* choiceType,
  398.                              TConstObjectPtr choicePtr);
  399.     // alias
  400.     MLIOVIR void WriteAlias(const CAliasTypeInfo* aliasType,
  401.                             TConstObjectPtr aliasPtr);
  403.     // COPY
  404.     // named type (alias)
  405.     MLIOVIR void CopyNamedType(TTypeInfo namedTypeInfo,
  406.                                TTypeInfo typeInfo,
  407.                                CObjectStreamCopier& copier);
  408.     // container
  409.     MLIOVIR void CopyContainer(const CContainerTypeInfo* containerType,
  410.                                CObjectStreamCopier& copier);
  411.     // class
  412.     MLIOVIR void CopyClassRandom(const CClassTypeInfo* objectType,
  413.                                  CObjectStreamCopier& copier);
  414.     MLIOVIR void CopyClassSequential(const CClassTypeInfo* objectType,
  415.                                      CObjectStreamCopier& copier);
  416.     // choice
  417.     MLIOVIR void CopyChoice(const CChoiceTypeInfo* choiceType,
  418.                             CObjectStreamCopier& copier);
  419.     // alias
  420.     MLIOVIR void CopyAlias(const CAliasTypeInfo* AliasType,
  421.                             CObjectStreamCopier& copier);
  423.     // low level I/O
  424.     // named type
  425.     virtual void BeginNamedType(TTypeInfo namedTypeInfo);
  426.     virtual void EndNamedType(void);
  428.     // container
  429.     virtual void BeginContainer(const CContainerTypeInfo* containerType) = 0;
  430.     virtual void EndContainer(void);
  431.     virtual void BeginContainerElement(TTypeInfo elementType);
  432.     virtual void EndContainerElement(void);
  434.     // class
  435.     virtual void BeginClass(const CClassTypeInfo* classInfo) = 0;
  436.     virtual void EndClass(void);
  438.     virtual void BeginClassMember(const CMemberId& id) = 0;
  439.     virtual void EndClassMember(void);
  441.     // choice
  442.     virtual void BeginChoice(const CChoiceTypeInfo* choiceType);
  443.     virtual void EndChoice(void);
  444.     virtual void BeginChoiceVariant(const CChoiceTypeInfo* choiceType,
  445.                                     const CMemberId& id) = 0;
  446.     virtual void EndChoiceVariant(void);
  448.     // write byte blocks
  449.     virtual void BeginBytes(const ByteBlock& block);
  450.     virtual void WriteBytes(const ByteBlock& block,
  451.                             const char* bytes, size_t length) = 0;
  452.     virtual void EndBytes(const ByteBlock& block);
  454.     // write char blocks
  455.     virtual void BeginChars(const CharBlock& block);
  456.     virtual void WriteChars(const CharBlock& block,
  457.                             const char* chars, size_t length) = 0;
  458.     virtual void EndChars(const CharBlock& block);
  460.     void WritePointer(TConstObjectPtr object, TTypeInfo typeInfo);
  461. protected:
  462.     friend class CObjectStreamCopier;
  464.     // low level writers
  465.     virtual void WriteNullPointer(void) = 0;
  466.     virtual void WriteObjectReference(TObjectIndex index) = 0;
  467.     virtual void WriteThis(TConstObjectPtr object,
  468.                            TTypeInfo typeInfo);
  469.     virtual void WriteOtherBegin(TTypeInfo typeInfo) = 0;
  470.     virtual void WriteOtherEnd(TTypeInfo typeInfo);
  471.     virtual void WriteOther(TConstObjectPtr object, TTypeInfo typeInfo);
  473.     void RegisterObject(TTypeInfo typeInfo);
  474.     void RegisterObject(TConstObjectPtr object, TTypeInfo typeInfo);
  476.     // report error about unended block
  477.     void Unended(const string& msg);
  478.     // report error about unended object stack frame
  479.     virtual void UnendedFrame(void);
  481.     void SetPathWriteObjectHook( const string& path, CWriteObjectHook*        hook);
  482.     void SetPathWriteMemberHook( const string& path, CWriteClassMemberHook*   hook);
  483.     void SetPathWriteVariantHook(const string& path, CWriteChoiceVariantHook* hook);
  486.     static CObjectOStream* OpenObjectOStreamAsn(CNcbiOstream& out,
  487.                                                 bool deleteOut);
  488.     static CObjectOStream* OpenObjectOStreamAsnBinary(CNcbiOstream& out,
  489.                                                       bool deleteOut);
  490.     static CObjectOStream* OpenObjectOStreamXml(CNcbiOstream& out,
  491.                                                 bool deleteOut);
  493. protected:
  494.     void x_SetPathHooks(bool set);
  496.     COStreamBuffer m_Output;
  498.     TFailFlags m_Fail;
  499.     TFlags m_Flags;
  501.     AutoPtr<CWriteObjectList> m_Objects;
  503.     // Write current separator to the stream
  504.     virtual void WriteSeparator(void);
  505.     string m_Separator;
  506.     bool   m_AutoSeparator;
  507.     ESerialDataFormat   m_DataFormat;
  509. private:
  510.     ESerialVerifyData   m_VerifyData;
  511.     static ESerialVerifyData ms_VerifyDataDefault;
  512.     static ESerialVerifyData x_GetVerifyDataDefault(void);
  513.     CStreamObjectPathHook<CWriteObjectHook*>                m_PathWriteObjectHooks;
  514.     CStreamPathHook<CMemberInfo*, CWriteClassMemberHook*>   m_PathWriteMemberHooks;
  515.     CStreamPathHook<CVariantInfo*,CWriteChoiceVariantHook*> m_PathWriteVariantHooks;
  517. public:
  518.     // hook support
  519.     CLocalHookSet<CWriteObjectHook> m_ObjectHookKey;
  520.     CLocalHookSet<CWriteClassMemberHook> m_ClassMemberHookKey;
  521.     CLocalHookSet<CWriteChoiceVariantHook> m_ChoiceVariantHookKey;
  522. };
  525. /* @} */
  528. #include <serial/objostr.inl>
  530. END_NCBI_SCOPE
  532. #endif  /* OBJOSTR__HPP */
  536. /* ---------------------------------------------------------------------------
  537. * $Log: objostr.hpp,v $
  538. * Revision 1000.4  2004/06/01 19:39:02  gouriano
  539. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.86
  540. *
  541. * Revision 1.86  2004/05/24 18:12:24  gouriano
  542. * In text output files make indentation optional
  543. *
  544. * Revision 1.85  2004/04/30 13:28:40  gouriano
  545. * Remove obsolete function declarations
  546. *
  547. * Revision 1.84  2004/03/10 23:18:11  gorelenk
  548. * Added prefix NCBI_XSERIAL_EXPORT for class CObjectOStream::CharBlock .
  549. *
  550. * Revision 1.83  2004/02/09 18:21:53  gouriano
  551. * enforced checking environment vars when setting initialization
  552. * verification parameters
  553. *
  554. * Revision 1.82  2004/01/05 14:24:09  gouriano
  555. * Added possibility to set serialization hooks by stack path
  556. *
  557. * Revision 1.81  2003/11/26 19:59:38  vasilche
  558. * GetPosition() and GetDataFormat() methods now are implemented
  559. * in parent classes CObjectIStream and CObjectOStream to avoid
  560. * pure virtual method call in destructors.
  561. *
  562. * Revision 1.80  2003/11/13 14:06:45  gouriano
  563. * Elaborated data verification on read/write/get to enable skipping mandatory class data members
  564. *
  565. * Revision 1.79  2003/10/21 21:08:46  grichenk
  566. * Fixed aliases-related bug in XML stream
  567. *
  568. * Revision 1.78  2003/08/19 18:32:38  vasilche
  569. * Optimized reading and writing strings.
  570. * Avoid string reallocation when checking char values.
  571. * Try to reuse old string data when string reference counting is not working.
  572. *
  573. * Revision 1.77  2003/08/13 15:47:02  gouriano
  574. * implemented serialization of AnyContent objects
  575. *
  576. * Revision 1.76  2003/07/29 18:47:46  vasilche
  577. * Fixed thread safeness of object stream hooks.
  578. *
  579. * Revision 1.75  2003/05/22 20:08:41  gouriano
  580. * added UTF8 strings
  581. *
  582. * Revision 1.74  2003/05/15 17:45:25  gouriano
  583. * added GetStreamOffset method
  584. *
  585. * Revision 1.73  2003/04/29 18:29:06  gouriano
  586. * object data member initialization verification
  587. *
  588. * Revision 1.72  2003/04/15 16:18:28  siyan
  589. * Added doxygen support
  590. *
  591. * Revision 1.71  2003/04/10 20:13:37  vakatov
  592. * Rollback the "uninitialized member" verification -- it still needs to
  593. * be worked upon...
  594. *
  595. * Revision 1.69  2003/03/10 18:52:37  gouriano
  596. * use new structured exceptions (based on CException)
  597. *
  598. * Revision 1.68  2003/02/04 18:15:22  gouriano
  599. * added reference to corelib/ncbifloat.h
  600. *
  601. * Revision 1.67  2002/12/23 18:38:51  dicuccio
  602. * Added WIn32 export specifier: NCBI_XSERIAL_EXPORT.
  603. * Moved all CVS logs to the end.
  604. *
  605. * Revision 1.66  2002/11/14 20:52:01  gouriano
  606. * added BeginChoice/EndChoice methods
  607. *
  608. * Revision 1.65  2002/11/04 21:28:59  grichenk
  609. * Fixed usage of const CRef<> and CRef<> constructor
  610. *
  611. * Revision 1.64  2002/10/25 14:49:29  vasilche
  612. * NCBI C Toolkit compatibility code extracted to libxcser library.
  613. * Serial streams flags names were renamed to fXxx.
  614. *
  615. * Names of flags
  616. *
  617. * Revision 1.63  2002/09/19 14:00:37  grichenk
  618. * Implemented CObjectHookGuard for write and copy hooks
  619. * Added DefaultRead/Write/Copy methods to base hook classes
  620. *
  621. * Revision 1.62  2002/08/26 18:32:24  grichenk
  622. * Added Get/SetAutoSeparator() to CObjectOStream to control
  623. * output of separators.
  624. *
  625. * Revision 1.61  2002/03/07 22:01:59  grichenk
  626. * Added "Separator" modifier for CObjectOStream
  627. *
  628. * Revision 1.60  2002/02/13 22:39:14  ucko
  629. * Support AIX.
  630. *
  631. * Revision 1.59  2001/10/17 20:41:19  grichenk
  632. * Added CObjectOStream::CharBlock class
  633. *
  634. * Revision 1.58  2001/05/17 14:59:47  lavr
  635. * Typos corrected
  636. *
  637. * Revision 1.57  2001/01/05 20:10:36  vasilche
  638. * CByteSource, CIStrBuffer, COStrBuffer, CLightString, CChecksum, CWeakMap
  639. * were moved to util.
  640. *
  641. * Revision 1.56  2000/12/26 22:23:45  vasilche
  642. * Fixed errors of compilation on Mac.
  643. *
  644. * Revision 1.55  2000/12/15 21:28:47  vasilche
  645. * Moved some typedefs/enums from corelib/ncbistd.hpp.
  646. * Added flags to CObjectIStream/CObjectOStream: eFlagAllowNonAsciiChars.
  647. * TByte typedef replaced by Uint1.
  648. *
  649. * Revision 1.54  2000/12/15 15:38:00  vasilche
  650. * Added support of Int8 and long double.
  651. * Enum values now have type Int4 instead of long.
  652. *
  653. * Revision 1.53  2000/11/20 17:24:36  vasilche
  654. * Added prototypes of internal functions.
  655. *
  656. * Revision 1.52  2000/10/20 19:29:15  vasilche
  657. * Adapted for MSVC which doesn't like explicit operator templates.
  658. *
  659. * Revision 1.51  2000/10/20 15:51:27  vasilche
  660. * Fixed data error processing.
  661. * Added interface for constructing container objects directly into output stream.
  662. * object.hpp, object.inl and object.cpp were split to
  663. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  664. *
  665. * Revision 1.50  2000/10/17 18:45:25  vasilche
  666. * Added possibility to turn off object cross reference detection in
  667. * CObjectIStream and CObjectOStream.
  668. *
  669. * Revision 1.49  2000/10/13 16:28:31  vasilche
  670. * Reduced header dependency.
  671. * Avoid use of templates with virtual methods.
  672. * Reduced amount of different maps used.
  673. * All this lead to smaller compiled code size (libraries and programs).
  674. *
  675. * Revision 1.48  2000/10/04 19:18:54  vasilche
  676. * Fixed processing floating point data.
  677. *
  678. * Revision 1.47  2000/10/03 17:22:35  vasilche
  679. * Reduced header dependency.
  680. * Reduced size of debug libraries on WorkShop by 3 times.
  681. * Fixed tag allocation for parent classes.
  682. * Fixed CObject allocation/deallocation in streams.
  683. * Moved instantiation of several templates in separate source file.
  684. *
  685. * Revision 1.46  2000/09/29 16:18:14  vasilche
  686. * Fixed binary format encoding/decoding on 64 bit compulers.
  687. * Implemented CWeakMap<> for automatic cleaning map entries.
  688. * Added cleaning local hooks via CWeakMap<>.
  689. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  690. * Added some user interface methods to CObjectIStream, CObjectOStream and
  691. * CObjectStreamCopier.
  692. *
  693. * Revision 1.45  2000/09/18 20:00:06  vasilche
  694. * Separated CVariantInfo and CMemberInfo.
  695. * Implemented copy hooks.
  696. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  697. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  698. *
  699. * Revision 1.44  2000/09/01 13:16:01  vasilche
  700. * Implemented class/container/choice iterators.
  701. * Implemented CObjectStreamCopier for copying data without loading into memory.
  702. *
  703. * Revision 1.43  2000/08/15 19:44:41  vasilche
  704. * Added Read/Write hooks:
  705. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  706. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  707. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  708. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  709. *
  710. * Revision 1.42  2000/07/03 18:42:36  vasilche
  711. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  712. * Reduced header dependency.
  713. *
  714. * Revision 1.41  2000/06/16 16:31:07  vasilche
  715. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  716. *
  717. * Revision 1.40  2000/06/07 19:45:43  vasilche
  718. * Some code cleaning.
  719. * Macros renaming in more clear way.
  720. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  721. *
  722. * Revision 1.39  2000/06/01 19:06:57  vasilche
  723. * Added parsing of XML data.
  724. *
  725. * Revision 1.38  2000/05/24 20:08:13  vasilche
  726. * Implemented XML dump.
  727. *
  728. * Revision 1.37  2000/05/09 16:38:34  vasilche
  729. * CObject::GetTypeInfo now moved to CObjectGetTypeInfo::GetTypeInfo to reduce possible errors.
  730. * Added write context to CObjectOStream.
  731. * Inlined most of methods of helping class Member, Block, ByteBlock etc.
  732. *
  733. * Revision 1.36  2000/05/04 16:22:23  vasilche
  734. * Cleaned and optimized blocks and members.
  735. *
  736. * Revision 1.35  2000/04/28 16:58:02  vasilche
  737. * Added classes CByteSource and CByteSourceReader for generic reading.
  738. * Added delayed reading of choice variants.
  739. *
  740. * Revision 1.34  2000/04/13 14:50:17  vasilche
  741. * Added CObjectIStream::Open() and CObjectOStream::Open() for easier use.
  742. *
  743. * Revision 1.33  2000/04/06 16:10:51  vasilche
  744. * Fixed bug with iterators in choices.
  745. * Removed unneeded calls to ReadExternalObject/WriteExternalObject.
  746. * Added output buffering to text ASN.1 data.
  747. *
  748. * Revision 1.32  2000/03/29 15:55:21  vasilche
  749. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  750. * Added generic iterators by class -
  751. *  CTypeIterator<class>, CTypeConstIterator<class>,
  752. *  CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  753. *  CObjectsIterator and CObjectsConstIterator.
  754. *
  755. * Revision 1.31  2000/03/07 14:05:31  vasilche
  756. * Added stream buffering to ASN.1 binary input.
  757. * Optimized class loading/storing.
  758. * Fixed bugs in processing OPTIONAL fields.
  759. *
  760. * Revision 1.30  2000/01/10 20:12:37  vasilche
  761. * Fixed duplicate argument names.
  762. * Fixed conflict between template and variable name.
  763. *
  764. * Revision 1.29  2000/01/10 19:46:32  vasilche
  765. * Fixed encoding/decoding of REAL type.
  766. * Fixed encoding/decoding of StringStore.
  767. * Fixed encoding/decoding of NULL type.
  768. * Fixed error reporting.
  769. * Reduced object map (only classes).
  770. *
  771. * Revision 1.28  2000/01/05 19:43:46  vasilche
  772. * Fixed error messages when reading from ASN.1 binary file.
  773. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  774. * Added TAG support to key/value of map.
  775. * Added support of NULL variant in CHOICE.
  776. *
  777. * Revision 1.27  1999/12/20 15:29:31  vasilche
  778. * Fixed bug with old ASN structures.
  779. *
  780. * Revision 1.26  1999/12/17 19:04:53  vasilche
  781. * Simplified generation of GetTypeInfo methods.
  782. *
  783. * Revision 1.25  1999/10/04 16:22:09  vasilche
  784. * Fixed bug with old ASN.1 structures.
  785. *
  786. * Revision 1.24  1999/09/27 14:17:59  vasilche
  787. * Fixed bug with overloaded constructors of Block.
  788. *
  789. * Revision 1.23  1999/09/24 18:19:14  vasilche
  790. * Removed dependency on NCBI toolkit.
  791. *
  792. * Revision 1.22  1999/09/23 18:56:53  vasilche
  793. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  794. *
  795. * Revision 1.21  1999/09/22 20:11:49  vasilche
  796. * Modified for compilation on IRIX native c++ compiler.
  797. *
  798. * Revision 1.20  1999/09/14 18:54:04  vasilche
  799. * Fixed bugs detected by gcc & egcs.
  800. * Removed unneeded includes.
  801. *
  802. * Revision 1.19  1999/08/16 16:07:43  vasilche
  803. * Added ENUMERATED type.
  804. *
  805. * Revision 1.18  1999/08/13 15:53:44  vasilche
  806. * C++ analog of asntool: datatool
  807. *
  808. * Revision 1.17  1999/07/22 17:33:43  vasilche
  809. * Unified reading/writing of objects in all three formats.
  810. *
  811. * Revision 1.16  1999/07/21 14:19:58  vasilche
  812. * Added serialization of bool.
  813. *
  814. * Revision 1.15  1999/07/19 15:50:17  vasilche
  815. * Added interface to old ASN.1 routines.
  816. * Added naming of key/value in STL map.
  817. *
  818. * Revision 1.14  1999/07/14 18:58:03  vasilche
  819. * Fixed ASN.1 types/field naming.
  820. *
  821. * Revision 1.13  1999/07/09 16:32:53  vasilche
  822. * Added OCTET STRING write/read.
  823. *
  824. * Revision 1.12  1999/07/07 21:15:03  vasilche
  825. * Cleaned processing of string types (string, char*, const char*).
  826. *
  827. * Revision 1.11  1999/07/02 21:31:46  vasilche
  828. * Implemented reading from ASN.1 binary format.
  829. *
  830. * Revision 1.10  1999/07/01 17:55:20  vasilche
  831. * Implemented ASN.1 binary write.
  832. *
  833. * Revision 1.9  1999/06/30 16:04:30  vasilche
  834. * Added support for old ASN.1 structures.
  835. *
  836. * Revision 1.8  1999/06/24 14:44:40  vasilche
  837. * Added binary ASN.1 output.
  838. *
  839. * Revision 1.7  1999/06/17 20:42:02  vasilche
  840. * Fixed storing/loading of pointers.
  841. *
  842. * Revision 1.6  1999/06/16 20:35:23  vasilche
  843. * Cleaned processing of blocks of data.
  844. * Added input from ASN.1 text format.
  845. *
  846. * Revision 1.5  1999/06/15 16:20:03  vasilche
  847. * Added ASN.1 object output stream.
  848. *
  849. * Revision 1.4  1999/06/10 21:06:40  vasilche
  850. * Working binary output and almost working binary input.
  851. *
  852. * Revision 1.3  1999/06/07 19:30:17  vasilche
  853. * More bug fixes
  854. *
  855. * Revision 1.2  1999/06/04 20:51:35  vasilche
  856. * First compilable version of serialization.
  857. *
  858. * Revision 1.1  1999/05/19 19:56:26  vasilche
  859. * Commit just in case.
  860. *
  861. * ===========================================================================
  862. */