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

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

生物技术

开发平台：

C/C++

objostr.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objostr.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:41:09  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.95
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: objostr.cpp,v 1000.4 2004/06/01 19:41:09 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author: Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   !!! PUT YOUR DESCRIPTION HERE !!!
  39. *
  40. * ===========================================================================
  41. */
  43. #include <ncbi_pch.hpp>
  44. #include <corelib/ncbistd.hpp>
  45. #include <corelib/ncbi_safe_static.hpp>
  46. #include <corelib/ncbimtx.hpp>
  48. #include <util/bytesrc.hpp>
  50. #include <serial/objostr.hpp>
  51. #include <serial/objistr.hpp>
  52. #include <serial/objcopy.hpp>
  53. #include <serial/typeref.hpp>
  54. #include <serial/objlist.hpp>
  55. #include <serial/memberid.hpp>
  56. #include <serial/typeinfo.hpp>
  57. #include <serial/enumvalues.hpp>
  58. #include <serial/memberlist.hpp>
  59. #include <serial/delaybuf.hpp>
  60. #include <serial/classinfo.hpp>
  61. #include <serial/choice.hpp>
  62. #include <serial/aliasinfo.hpp>
  63. #include <serial/continfo.hpp>
  64. #include <serial/member.hpp>
  65. #include <serial/variant.hpp>
  66. #include <serial/objectinfo.hpp>
  67. #include <serial/objectiter.hpp>
  68. #include <serial/objlist.hpp>
  69. #include <serial/serialimpl.hpp>
  71. #undef _TRACE
  72. #define _TRACE(arg) ((void)0)
  74. BEGIN_NCBI_SCOPE
  77. CObjectOStream* CObjectOStream::Open(ESerialDataFormat format,
  78.                                      const string& fileName,
  79.                                      TSerialOpenFlags openFlags)
  80. {
  81.     CNcbiOstream* outStream = 0;
  82.     bool deleteStream;
  83.     if ( (openFlags & eSerial_StdWhenEmpty) && fileName.empty() ||
  84.          (openFlags & eSerial_StdWhenDash) && fileName == "-" ||
  85.          (openFlags & eSerial_StdWhenStd) && fileName == "stdout" ) {
  86.         outStream = &NcbiCout;
  87.         deleteStream = false;
  88.     }
  89.     else {
  90.         switch ( format ) {
  91.         case eSerial_AsnText:
  92.         case eSerial_Xml:
  93.             outStream = new CNcbiOfstream(fileName.c_str());
  94.             break;
  95.         case eSerial_AsnBinary:
  96.             outStream = new CNcbiOfstream(fileName.c_str(),
  97.                                           IOS_BASE::out | IOS_BASE::binary);
  98.             break;
  99.         default:
  100.             NCBI_THROW(CSerialException,eFail,
  101.                        "CObjectOStream::Open: unsupported format");
  102.         }
  103.         if ( !*outStream ) {
  104.             delete outStream;
  105.             NCBI_THROW(CSerialException,eFail, "cannot open file");
  106.         }
  107.         deleteStream = true;
  108.     }
  110.     return Open(format, *outStream, deleteStream);
  111. }
  113. CObjectOStream* CObjectOStream::Open(ESerialDataFormat format,
  114.                                      CNcbiOstream& outStream,
  115.                                      bool deleteStream)
  116. {
  117.     switch ( format ) {
  118.     case eSerial_AsnText:
  119.         return OpenObjectOStreamAsn(outStream, deleteStream);
  120.     case eSerial_AsnBinary:
  121.         return OpenObjectOStreamAsnBinary(outStream, deleteStream);
  122.     case eSerial_Xml:
  123.         return OpenObjectOStreamXml(outStream, deleteStream);
  124.     default:
  125.         break;
  126.     }
  127.     NCBI_THROW(CSerialException,eFail,
  128.                "CObjectOStream::Open: unsupported format");
  129. }
  131. /////////////////////////////////////////////////////////////////////////////
  132. // data verification setup
  134. ESerialVerifyData CObjectOStream::ms_VerifyDataDefault = eSerialVerifyData_Default;
  135. static CSafeStaticRef< CTls<int> > s_VerifyTLS;
  138. void CObjectOStream::SetVerifyDataThread(ESerialVerifyData verify)
  139. {
  140.     x_GetVerifyDataDefault();
  141.     ESerialVerifyData tls_verify = ESerialVerifyData(long(s_VerifyTLS->GetValue()));
  142.     if (tls_verify != eSerialVerifyData_Never &&
  143.         tls_verify != eSerialVerifyData_Always &&
  144.         tls_verify != eSerialVerifyData_DefValueAlways) {
  145.         s_VerifyTLS->SetValue(reinterpret_cast<int*>(verify));
  146.     }
  147. }
  149. void CObjectOStream::SetVerifyDataGlobal(ESerialVerifyData verify)
  150. {
  151.     x_GetVerifyDataDefault();
  152.     if (ms_VerifyDataDefault != eSerialVerifyData_Never &&
  153.         ms_VerifyDataDefault != eSerialVerifyData_Always &&
  154.         ms_VerifyDataDefault != eSerialVerifyData_DefValueAlways) {
  155.         ms_VerifyDataDefault = verify;
  156.     }
  157. }
  159. ESerialVerifyData CObjectOStream::x_GetVerifyDataDefault(void)
  160. {
  161.     ESerialVerifyData verify;
  162.     if (ms_VerifyDataDefault == eSerialVerifyData_Never ||
  163.         ms_VerifyDataDefault == eSerialVerifyData_Always ||
  164.         ms_VerifyDataDefault == eSerialVerifyData_DefValueAlways) {
  165.         verify = ms_VerifyDataDefault;
  166.     } else {
  167.         verify = ESerialVerifyData(long(s_VerifyTLS->GetValue()));
  168.         if (verify == eSerialVerifyData_Default) {
  169.             if (ms_VerifyDataDefault == eSerialVerifyData_Default) {
  171.                 // change the default here, if you wish
  172.                 ms_VerifyDataDefault = eSerialVerifyData_Yes;
  173.                 //ms_VerifyDataDefault = eSerialVerifyData_No;
  175.                 const char* str = getenv(SERIAL_VERIFY_DATA_WRITE);
  176.                 if (str) {
  177.                     if (NStr::CompareNocase(str,"YES") == 0) {
  178.                         ms_VerifyDataDefault = eSerialVerifyData_Yes;
  179.                     } else if (NStr::CompareNocase(str,"NO") == 0) {
  180.                         ms_VerifyDataDefault = eSerialVerifyData_No;
  181.                     } else if (NStr::CompareNocase(str,"NEVER") == 0) {
  182.                         ms_VerifyDataDefault = eSerialVerifyData_Never;
  183.                     } else  if (NStr::CompareNocase(str,"ALWAYS") == 0) {
  184.                         ms_VerifyDataDefault = eSerialVerifyData_Always;
  185.                     } else  if (NStr::CompareNocase(str,"DEFVALUE") == 0) {
  186.                         ms_VerifyDataDefault = eSerialVerifyData_DefValue;
  187.                     } else  if (NStr::CompareNocase(str,"DEFVALUE_ALWAYS") == 0) {
  188.                         ms_VerifyDataDefault = eSerialVerifyData_DefValueAlways;
  189.                     }
  190.                 }
  191.             }
  192.             verify = ms_VerifyDataDefault;
  193.         }
  194.     }
  195.     return verify;
  196. }
  199. /////////////////////////////////////////////////////////////////////////////
  201. CObjectOStream::CObjectOStream(ESerialDataFormat format,
  202.                                CNcbiOstream& out, bool deleteOut)
  203.     : m_Output(out, deleteOut), m_Fail(fNoError), m_Flags(fFlagNone),
  204.       m_Separator(""), m_AutoSeparator(false),
  205.       m_DataFormat(format),
  206.       m_VerifyData(x_GetVerifyDataDefault())
  207. {
  208. }
  210. CObjectOStream::~CObjectOStream(void)
  211. {
  212.     try {
  213.         Close();
  214.         ResetLocalHooks();
  215.     }
  216.     catch (...) {
  217.         ERR_POST("Can not close output stream");
  218.     }
  219. }
  221. void CObjectOStream::Close(void)
  222. {
  223.     if (m_Fail != fNotOpen) {
  224.         try {
  225.             m_Output.Flush();
  226.             if ( m_Objects )
  227.                 m_Objects->Clear();
  228.             ClearStack();
  229.             m_Fail = fNotOpen;
  230.         }
  231.         catch (...) {
  232.             if ( InGoodState() )
  233.                 ThrowError(fWriteError, "cannot close output stream");
  234.         }
  235.     }
  236. }
  238. void CObjectOStream::ResetLocalHooks(void)
  239. {
  240.     CMutexGuard guard(GetTypeInfoMutex());
  241.     m_ObjectHookKey.Clear();
  242.     m_ClassMemberHookKey.Clear();
  243.     m_ChoiceVariantHookKey.Clear();
  244. }
  246. CObjectOStream::TFailFlags CObjectOStream::SetFailFlagsNoError(TFailFlags flags)
  247. {
  248.     TFailFlags old = m_Fail;
  249.     m_Fail |= flags;
  250.     return old;
  251. }
  253. CObjectOStream::TFailFlags CObjectOStream::SetFailFlags(TFailFlags flags,
  254.                                                         const char* message)
  255. {
  256.     TFailFlags old = m_Fail;
  257.     m_Fail |= flags;
  258.     if ( !old && flags ) {
  259.         // first fail
  260.         ERR_POST("CObjectOStream: error at "<<
  261.                  GetPosition()<<": "<<GetStackTrace() << ": " << message);
  262.     }
  263.     return old;
  264. }
  266. bool CObjectOStream::InGoodState(void)
  267. {
  268.     if ( fail() ) {
  269.         // fail flag already set
  270.         return false;
  271.     }
  272.     else if ( m_Output.fail() ) {
  273.         // IO exception thrown without setting fail flag
  274.         SetFailFlags(fWriteError, m_Output.GetError());
  275.         m_Output.ResetFail();
  276.         return false;
  277.     }
  278.     else {
  279.         // ok
  280.         return true;
  281.     }
  282. }
  284. void CObjectOStream::Unended(const string& msg)
  285. {
  286.     if ( InGoodState() )
  287.         ThrowError(fFail, msg);
  288. }
  290. void CObjectOStream::UnendedFrame(void)
  291. {
  292.     Unended("internal error: unended object stack frame");
  293. }
  295. void CObjectOStream::x_SetPathHooks(bool set)
  296. {
  297.     if (!m_PathWriteObjectHooks.IsEmpty()) {
  298.         CWriteObjectHook* hook = m_PathWriteObjectHooks.GetHook(*this);
  299.         if (hook) {
  300.             CTypeInfo* item = m_PathWriteObjectHooks.FindType(*this);
  301.             if (item) {
  302.                 if (set) {
  303.                     item->SetLocalWriteHook(*this, hook);
  304.                 } else {
  305.                     item->ResetLocalWriteHook(*this);
  306.                 }
  307.             }
  308.         }
  309.     }
  310.     if (!m_PathWriteMemberHooks.IsEmpty()) {
  311.         CWriteClassMemberHook* hook = m_PathWriteMemberHooks.GetHook(*this);
  312.         if (hook) {
  313.             CMemberInfo* item = m_PathWriteMemberHooks.FindItem(*this);
  314.             if (item) {
  315.                 if (set) {
  316.                     item->SetLocalWriteHook(*this, hook);
  317.                 } else {
  318.                     item->ResetLocalWriteHook(*this);
  319.                 }
  320.             }
  321.         }
  322.     }
  323.     if (!m_PathWriteVariantHooks.IsEmpty()) {
  324.         CWriteChoiceVariantHook* hook = m_PathWriteVariantHooks.GetHook(*this);
  325.         if (hook) {
  326.             CVariantInfo* item = m_PathWriteVariantHooks.FindItem(*this);
  327.             if (item) {
  328.                 if (set) {
  329.                     item->SetLocalWriteHook(*this, hook);
  330.                 } else {
  331.                     item->ResetLocalWriteHook(*this);
  332.                 }
  333.             }
  334.         }
  335.     }
  336. }
  338. void CObjectOStream::SetPathWriteObjectHook(const string& path,
  339.                                             CWriteObjectHook*   hook)
  340. {
  341.     m_PathWriteObjectHooks.SetHook(path,hook);
  342.     WatchPathHooks();
  343. }
  344. void CObjectOStream::SetPathWriteMemberHook(const string& path,
  345.                                             CWriteClassMemberHook*   hook)
  346. {
  347.     m_PathWriteMemberHooks.SetHook(path,hook);
  348.     WatchPathHooks();
  349. }
  350. void CObjectOStream::SetPathWriteVariantHook(const string& path,
  351.                                              CWriteChoiceVariantHook* hook)
  352. {
  353.     m_PathWriteVariantHooks.SetHook(path,hook);
  354.     WatchPathHooks();
  355. }
  357. string CObjectOStream::GetStackTrace(void) const
  358. {
  359.     return GetStackTraceASN();
  360. }
  362. size_t CObjectOStream::GetStreamOffset(void) const
  363. {
  364.     return m_Output.GetStreamOffset();
  365. }
  367. string CObjectOStream::GetPosition(void) const
  368. {
  369.     return "byte "+NStr::UIntToString(GetStreamOffset());
  370. }
  372. void CObjectOStream::ThrowError1(const char* file, int line, 
  373.                                  TFailFlags fail, const char* message)
  374. {
  375.     ThrowError1(file,line,fail,string(message));
  376. }
  378. void CObjectOStream::ThrowError1(const char* file, int line, 
  379.                                  TFailFlags fail, const string& message)
  380. {
  381.     CSerialException::EErrCode err;
  382.     SetFailFlags(fail, message.c_str());
  383.     try {
  384.         Flush();
  385.     } catch(...) {
  386.     }
  387.     switch(fail)
  388.     {
  389.     case fNoError:
  390.         CNcbiDiag(file, line, eDiag_Trace) << message;
  391.         return;
  392.     case fEOF:         err = CSerialException::eEOF;         break;
  393.     default:
  394.     case fWriteError:  err = CSerialException::eIoError;     break;
  395.     case fFormatError: err = CSerialException::eFormatError; break;
  396.     case fOverflow:    err = CSerialException::eOverflow;    break;
  397.     case fInvalidData: err = CSerialException::eInvalidData; break;
  398.     case fIllegalCall: err = CSerialException::eIllegalCall; break;
  399.     case fFail:        err = CSerialException::eFail;        break;
  400.     case fNotOpen:     err = CSerialException::eNotOpen;     break;
  401.     case fUnassigned:
  402.         throw CUnassignedMember(file,line,0,CUnassignedMember::eWrite,
  403.                                 GetPosition()+": "+message);
  404.     }
  405.     throw CSerialException(file,line,0,err,GetPosition()+": "+message);
  406. }
  408. void CObjectOStream::EndOfWrite(void)
  409. {
  410.     FlushBuffer();
  411.     if ( m_Objects )
  412.         m_Objects->Clear();
  413. }    
  415. void CObjectOStream::WriteObject(const CConstObjectInfo& object)
  416. {
  417.     WriteObject(object.GetObjectPtr(), object.GetTypeInfo());
  418. }
  420. void CObjectOStream::WriteClassMember(const CConstObjectInfo::CMemberIterator& member)
  421. {
  422.     const CMemberInfo* memberInfo = member.GetMemberInfo();
  423.     TConstObjectPtr classPtr = member.GetClassObject().GetObjectPtr();
  424.     WriteClassMember(memberInfo->GetId(),
  425.                      memberInfo->GetTypeInfo(),
  426.                      memberInfo->GetMemberPtr(classPtr));
  427. }
  429. void CObjectOStream::WriteChoiceVariant(const CConstObjectInfoCV& object)
  430. {
  431.     const CVariantInfo* variantInfo = object.GetVariantInfo();
  432.     TConstObjectPtr choicePtr = object.GetChoiceObject().GetObjectPtr();
  433.     variantInfo->DefaultWriteVariant(*this, choicePtr);
  434. }
  436. void CObjectOStream::Write(const CConstObjectInfo& object)
  437. {
  438.     // root writer
  439.     BEGIN_OBJECT_FRAME2(eFrameNamed, object.GetTypeInfo());
  440.     
  441.     WriteFileHeader(object.GetTypeInfo());
  443.     WriteObject(object);
  445.     EndOfWrite();
  446.     
  447.     END_OBJECT_FRAME();
  449.     if ( GetAutoSeparator() )
  450.         Separator(*this);
  451. }
  453. void CObjectOStream::Write(TConstObjectPtr object, TTypeInfo typeInfo)
  454. {
  455.     // root writer
  456.     BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
  457.     
  458.     WriteFileHeader(typeInfo);
  460.     WriteObject(object, typeInfo);
  462.     EndOfWrite();
  463.     
  464.     END_OBJECT_FRAME();
  466.     if ( GetAutoSeparator() )
  467.         Separator(*this);
  468. }
  470. void CObjectOStream::Write(TConstObjectPtr object, const CTypeRef& type)
  471. {
  472.     Write(object, type.Get());
  473. }
  475. void CObjectOStream::RegisterObject(TTypeInfo typeInfo)
  476. {
  477.     if ( m_Objects )
  478.         m_Objects->RegisterObject(typeInfo);
  479. }
  481. void CObjectOStream::RegisterObject(TConstObjectPtr object,
  482.                                     TTypeInfo typeInfo)
  483. {
  484.     if ( m_Objects )
  485.         m_Objects->RegisterObject(object, typeInfo);
  486. }
  488. void CObjectOStream::WriteSeparateObject(const CConstObjectInfo& object)
  489. {
  490.     if ( m_Objects ) {
  491.         size_t firstObject = m_Objects->GetObjectCount();
  492.         WriteObject(object);
  493.         size_t lastObject = m_Objects->GetObjectCount();
  494.         m_Objects->ForgetObjects(firstObject, lastObject);
  495.     }
  496.     else {
  497.         WriteObject(object);
  498.     }
  499. }
  501. void CObjectOStream::WriteExternalObject(TConstObjectPtr objectPtr,
  502.                                          TTypeInfo typeInfo)
  503. {
  504.     _TRACE("CObjectOStream::WriteExternalObject(" <<
  505.            NStr::PtrToString(objectPtr) << ", "
  506.            << typeInfo->GetName() << ')');
  507.     RegisterObject(objectPtr, typeInfo);
  508.     WriteObject(objectPtr, typeInfo);
  509. }
  511. bool CObjectOStream::Write(CByteSource& source)
  512. {
  513.     m_Output.Write(*source.Open());
  514.     return true;
  515. }
  517. void CObjectOStream::WriteFileHeader(TTypeInfo /*type*/)
  518. {
  519.     // do nothing by default
  520. }
  522. void CObjectOStream::WritePointer(TConstObjectPtr objectPtr,
  523.                                   TTypeInfo declaredTypeInfo)
  524. {
  525.     _TRACE("WritePointer("<<NStr::PtrToString(objectPtr)<<", "
  526.            <<declaredTypeInfo->GetName()<<")");
  527.     if ( objectPtr == 0 ) {
  528.         _TRACE("WritePointer: "<<NStr::PtrToString(objectPtr)<<": null");
  529.         WriteNullPointer();
  530.         return;
  531.     }
  532.     TTypeInfo realTypeInfo = declaredTypeInfo->GetRealTypeInfo(objectPtr);
  533.     if ( m_Objects ) {
  534.         const CWriteObjectInfo* info =
  535.             m_Objects->RegisterObject(objectPtr, realTypeInfo);
  536.         if ( info ) {
  537.             // old object
  538.             WriteObjectReference(info->GetIndex());
  539.             return;
  540.         }
  541.     }
  542.     if ( declaredTypeInfo == realTypeInfo ) {
  543.         _TRACE("WritePointer: "<<NStr::PtrToString(objectPtr)<<": new");
  544.         WriteThis(objectPtr, realTypeInfo);
  545.     }
  546.     else {
  547.         _TRACE("WritePointer: "<<NStr::PtrToString(objectPtr)<<
  548.                ": new "<<realTypeInfo->GetName());
  549.         WriteOther(objectPtr, realTypeInfo);
  550.     }
  551. }
  553. void CObjectOStream::WriteThis(TConstObjectPtr object, TTypeInfo typeInfo)
  554. {
  555.     WriteObject(object, typeInfo);
  556. }
  558. void CObjectOStream::WriteFloat(float data)
  559. {
  560.     WriteDouble(data);
  561. }
  563. #if SIZEOF_LONG_DOUBLE != 0
  564. void CObjectOStream::WriteLDouble(long double data)
  565. {
  566.     WriteDouble(data);
  567. }
  568. #endif
  570. void CObjectOStream::BeginNamedType(TTypeInfo /*namedTypeInfo*/)
  571. {
  572. }
  574. void CObjectOStream::EndNamedType(void)
  575. {
  576. }
  578. void CObjectOStream::WriteNamedType(TTypeInfo
  579. #ifndef VIRTUAL_MID_LEVEL_IO
  580.                                     namedTypeInfo
  581. #endif
  582.                                     ,
  583.                                     TTypeInfo objectType,
  584.                                     TConstObjectPtr objectPtr)
  585. {
  586. #ifndef VIRTUAL_MID_LEVEL_IO
  587.     BEGIN_OBJECT_FRAME2(eFrameNamed, namedTypeInfo);
  588.     BeginNamedType(namedTypeInfo);
  589. #endif
  590.     WriteObject(objectPtr, objectType);
  591. #ifndef VIRTUAL_MID_LEVEL_IO
  592.     EndNamedType();
  593.     END_OBJECT_FRAME();
  594. #endif
  595. }
  597. void CObjectOStream::CopyNamedType(TTypeInfo namedTypeInfo,
  598.                                    TTypeInfo objectType,
  599.                                    CObjectStreamCopier& copier)
  600. {
  601. #ifndef VIRTUAL_MID_LEVEL_IO
  602.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameNamed, namedTypeInfo);
  603.     copier.In().BeginNamedType(namedTypeInfo);
  604.     BeginNamedType(namedTypeInfo);
  606.     CopyObject(objectType, copier);
  608.     EndNamedType();
  609.     copier.In().EndNamedType();
  610.     END_OBJECT_2FRAMES_OF(copier);
  611. #else
  612.     BEGIN_OBJECT_FRAME_OF2(copier.In(), eFrameNamed, namedTypeInfo);
  613.     copier.In().BeginNamedType(namedTypeInfo);
  615.     CopyObject(objectType, copier);
  617.     copier.In().EndNamedType();
  618.     END_OBJECT_FRAME_OF(copier.In());
  619. #endif
  620. }
  622. void CObjectOStream::WriteOther(TConstObjectPtr object,
  623.                                 TTypeInfo typeInfo)
  624. {
  625.     WriteOtherBegin(typeInfo);
  626.     WriteObject(object, typeInfo);
  627.     WriteOtherEnd(typeInfo);
  628. }
  630. void CObjectOStream::WriteOtherEnd(TTypeInfo /*typeInfo*/)
  631. {
  632. }
  634. void CObjectOStream::EndContainer(void)
  635. {
  636. }
  638. void CObjectOStream::BeginContainerElement(TTypeInfo /*elementType*/)
  639. {
  640. }
  642. void CObjectOStream::EndContainerElement(void)
  643. {
  644. }
  646. void CObjectOStream::WriteContainer(const CContainerTypeInfo* cType,
  647.                                     TConstObjectPtr containerPtr)
  648. {
  649.     BEGIN_OBJECT_FRAME2(eFrameArray, cType);
  650.     BeginContainer(cType);
  651.         
  652.     CContainerTypeInfo::CConstIterator i;
  653.     if ( cType->InitIterator(i, containerPtr) ) {
  654.         TTypeInfo elementType = cType->GetElementType();
  655.         BEGIN_OBJECT_FRAME2(eFrameArrayElement, elementType);
  657.         do {
  658.             BeginContainerElement(elementType);
  659.             
  660.             WriteObject(cType->GetElementPtr(i), elementType);
  661.             
  662.             EndContainerElement();
  663.         } while ( cType->NextElement(i) );
  665.         END_OBJECT_FRAME();
  666.     }
  668.     EndContainer();
  669.     END_OBJECT_FRAME();
  670. }
  672. void CObjectOStream::WriteContainerElement(const CConstObjectInfo& element)
  673. {
  674.     BeginContainerElement(element.GetTypeInfo());
  676.     WriteObject(element);
  678.     EndContainerElement();
  679. }
  681. void CObjectOStream::CopyContainer(const CContainerTypeInfo* cType,
  682.                                    CObjectStreamCopier& copier)
  683. {
  684.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameArray, cType);
  685.     copier.In().BeginContainer(cType);
  686.     BeginContainer(cType);
  688.     TTypeInfo elementType = cType->GetElementType();
  689.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameArrayElement, elementType);
  691.     while ( copier.In().BeginContainerElement(elementType) ) {
  692.         BeginContainerElement(elementType);
  694.         CopyObject(elementType, copier);
  696.         EndContainerElement();
  697.         copier.In().EndContainerElement();
  698.     }
  700.     END_OBJECT_2FRAMES_OF(copier);
  701.     
  702.     EndContainer();
  703.     copier.In().EndContainer();
  704.     END_OBJECT_2FRAMES_OF(copier);
  705. }
  707. void CObjectOStream::EndClass(void)
  708. {
  709. }
  711. void CObjectOStream::EndClassMember(void)
  712. {
  713. }
  715. void CObjectOStream::WriteClass(const CClassTypeInfo* classType,
  716.                                 TConstObjectPtr classPtr)
  717. {
  718.     BEGIN_OBJECT_FRAME2(eFrameClass, classType);
  719.     BeginClass(classType);
  720.     
  721.     for ( CClassTypeInfo::CIterator i(classType); i.Valid(); ++i ) {
  722.         classType->GetMemberInfo(*i)->WriteMember(*this, classPtr);
  723.     }
  724.     
  725.     EndClass();
  726.     END_OBJECT_FRAME();
  727. }
  729. void CObjectOStream::WriteClassMember(const CMemberId& memberId,
  730.                                       TTypeInfo memberType,
  731.                                       TConstObjectPtr memberPtr)
  732. {
  733.     BEGIN_OBJECT_FRAME2(eFrameClassMember, memberId);
  734.     BeginClassMember(memberId);
  736.     WriteObject(memberPtr, memberType);
  738.     EndClassMember();
  739.     END_OBJECT_FRAME();
  740. }
  742. bool CObjectOStream::WriteClassMember(const CMemberId& memberId,
  743.                                       const CDelayBuffer& buffer)
  744. {
  745.     if ( !buffer.HaveFormat(GetDataFormat()) )
  746.         return false;
  748.     BEGIN_OBJECT_FRAME2(eFrameClassMember, memberId);
  749.     BeginClassMember(memberId);
  751.     Write(buffer.GetSource());
  753.     EndClassMember();
  754.     END_OBJECT_FRAME();
  755.     return true;
  756. }
  758. void CObjectOStream::CopyClassRandom(const CClassTypeInfo* classType,
  759.                                      CObjectStreamCopier& copier)
  760. {
  761.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameClass, classType);
  762.     copier.In().BeginClass(classType);
  763.     BeginClass(classType);
  765.     vector<bool> read(classType->GetMembers().LastIndex() + 1);
  767.     BEGIN_OBJECT_2FRAMES_OF(copier, eFrameClassMember);
  769.     TMemberIndex index;
  770.     while ( (index = copier.In().BeginClassMember(classType)) !=
  771.             kInvalidMember ) {
  772.         const CMemberInfo* memberInfo = classType->GetMemberInfo(index);
  773.         copier.In().SetTopMemberId(memberInfo->GetId());
  774.         SetTopMemberId(memberInfo->GetId());
  775.         copier.SetPathHooks(*this, true);
  777.         if ( read[index] ) {
  778.             copier.In().DuplicatedMember(memberInfo);
  779.         }
  780.         else {
  781.             read[index] = true;
  782.             BeginClassMember(memberInfo->GetId());
  784.             memberInfo->CopyMember(copier);
  786.             EndClassMember();
  787.         }
  788.         
  789.         copier.SetPathHooks(*this, false);
  790.         copier.In().EndClassMember();
  791.     }
  793.     END_OBJECT_2FRAMES_OF(copier);
  795.     // init all absent members
  796.     for ( CClassTypeInfo::CIterator i(classType); i.Valid(); ++i ) {
  797.         if ( !read[*i] ) {
  798.             classType->GetMemberInfo(*i)->CopyMissingMember(copier);
  799.         }
  800.     }
  802.     EndClass();
  803.     copier.In().EndClass();
  804.     END_OBJECT_2FRAMES_OF(copier);
  805. }
  807. void CObjectOStream::CopyClassSequential(const CClassTypeInfo* classType,
  808.                                          CObjectStreamCopier& copier)
  809. {
  810.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameClass, classType);
  811.     copier.In().BeginClass(classType);
  812.     BeginClass(classType);
  814.     CClassTypeInfo::CIterator pos(classType);
  815.     BEGIN_OBJECT_2FRAMES_OF(copier, eFrameClassMember);
  817.     TMemberIndex index;
  818.     while ( (index = copier.In().BeginClassMember(classType, *pos)) !=
  819.             kInvalidMember ) {
  820.         const CMemberInfo* memberInfo = classType->GetMemberInfo(index);
  821.         copier.In().SetTopMemberId(memberInfo->GetId());
  822.         SetTopMemberId(memberInfo->GetId());
  823.         copier.SetPathHooks(*this, true);
  825.         for ( TMemberIndex i = *pos; i < index; ++i ) {
  826.             // init missing member
  827.             classType->GetMemberInfo(i)->CopyMissingMember(copier);
  828.         }
  829.         BeginClassMember(memberInfo->GetId());
  831.         memberInfo->CopyMember(copier);
  832.         
  833.         pos.SetIndex(index + 1);
  835.         EndClassMember();
  836.         copier.SetPathHooks(*this, false);
  837.         copier.In().EndClassMember();
  838.     }
  840.     END_OBJECT_2FRAMES_OF(copier);
  842.     // init all absent members
  843.     for ( ; pos.Valid(); ++pos ) {
  844.         classType->GetMemberInfo(*pos)->CopyMissingMember(copier);
  845.     }
  847.     EndClass();
  848.     copier.In().EndClass();
  849.     END_OBJECT_2FRAMES_OF(copier);
  850. }
  852. void CObjectOStream::BeginChoice(const CChoiceTypeInfo* /*choiceType*/)
  853. {
  854. }
  855. void CObjectOStream::EndChoice(void)
  856. {
  857. }
  858. void CObjectOStream::EndChoiceVariant(void)
  859. {
  860. }
  862. void CObjectOStream::WriteChoice(const CChoiceTypeInfo* choiceType,
  863.                                  TConstObjectPtr choicePtr)
  864. {
  865.     BEGIN_OBJECT_FRAME2(eFrameChoice, choiceType);
  866.     BeginChoice(choiceType);
  867.     TMemberIndex index = choiceType->GetIndex(choicePtr);
  868.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  869.     BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());
  870.     BeginChoiceVariant(choiceType, variantInfo->GetId());
  872.     variantInfo->WriteVariant(*this, choicePtr);
  874.     EndChoiceVariant();
  875.     END_OBJECT_FRAME();
  876.     EndChoice();
  877.     END_OBJECT_FRAME();
  878. }
  880. void CObjectOStream::CopyChoice(const CChoiceTypeInfo* choiceType,
  881.                                 CObjectStreamCopier& copier)
  882. {
  883.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameChoice, choiceType);
  885.     BeginChoice(choiceType);
  886.     copier.In().BeginChoice(choiceType);
  887.     BEGIN_OBJECT_2FRAMES_OF(copier, eFrameChoiceVariant);
  888.     TMemberIndex index = copier.In().BeginChoiceVariant(choiceType);
  889.     if ( index == kInvalidMember ) {
  890.         copier.ThrowError(CObjectIStream::fFormatError,
  891.                           "choice variant id expected");
  892.     }
  894.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  895.     if (variantInfo->GetId().IsAttlist()) {
  896.         const CMemberInfo* memberInfo =
  897.             dynamic_cast<const CMemberInfo*>(
  898.                 choiceType->GetVariants().GetItemInfo(index));
  899.         BeginClassMember(memberInfo->GetId());
  900.         memberInfo->CopyMember(copier);
  901.         EndClassMember();
  902.         index = copier.In().BeginChoiceVariant(choiceType);
  903.         if ( index == kInvalidMember )
  904.             copier.ThrowError(CObjectIStream::fFormatError,
  905.                           "choice variant id expected");
  906.         variantInfo = choiceType->GetVariantInfo(index);
  907.     }
  908.     copier.In().SetTopMemberId(variantInfo->GetId());
  909.     copier.Out().SetTopMemberId(variantInfo->GetId());
  910.     copier.SetPathHooks(copier.Out(), true);
  911.     BeginChoiceVariant(choiceType, variantInfo->GetId());
  913.     variantInfo->CopyVariant(copier);
  915.     EndChoiceVariant();
  916.     copier.SetPathHooks(copier.Out(), false);
  917.     copier.In().EndChoiceVariant();
  918.     END_OBJECT_2FRAMES_OF(copier);
  919.     copier.In().EndChoice();
  920.     EndChoice();
  921.     END_OBJECT_2FRAMES_OF(copier);
  922. }
  924. void CObjectOStream::WriteAlias(const CAliasTypeInfo* aliasType,
  925.                                 TConstObjectPtr aliasPtr)
  926. {
  927.     WriteNamedType(aliasType, aliasType->GetPointedType(),
  928.         aliasType->GetDataPtr(aliasPtr));
  929. }
  931. void CObjectOStream::CopyAlias(const CAliasTypeInfo* aliasType,
  932.                                 CObjectStreamCopier& copier)
  933. {
  934.     CopyNamedType(aliasType, aliasType->GetPointedType(),
  935.         copier);
  936. }
  938. void CObjectOStream::BeginBytes(const ByteBlock& )
  939. {
  940. }
  942. void CObjectOStream::EndBytes(const ByteBlock& )
  943. {
  944. }
  946. void CObjectOStream::ByteBlock::End(void)
  947. {
  948.     _ASSERT(!m_Ended);
  949.     _ASSERT(m_Length == 0);
  950.     if ( GetStream().InGoodState() ) {
  951.         GetStream().EndBytes(*this);
  952.         m_Ended = true;
  953.     }
  954. }
  956. CObjectOStream::ByteBlock::~ByteBlock(void)
  957. {
  958.     if ( !m_Ended ) {
  959.         try {
  960.             GetStream().Unended("byte block not fully written");
  961.         }
  962.         catch (...) {
  963.             ERR_POST("unended byte block");
  964.         }
  965.     }
  966. }
  968. void CObjectOStream::BeginChars(const CharBlock& )
  969. {
  970. }
  972. void CObjectOStream::EndChars(const CharBlock& )
  973. {
  974. }
  976. void CObjectOStream::CharBlock::End(void)
  977. {
  978.     _ASSERT(!m_Ended);
  979.     _ASSERT(m_Length == 0);
  980.     if ( GetStream().InGoodState() ) {
  981.         GetStream().EndChars(*this);
  982.         m_Ended = true;
  983.     }
  984. }
  986. CObjectOStream::CharBlock::~CharBlock(void)
  987. {
  988.     if ( !m_Ended ) {
  989.         try {
  990.             GetStream().Unended("char block not fully written");
  991.         }
  992.         catch (...) {
  993.             ERR_POST("unended char block");
  994.         }
  995.     }
  996. }
  999. void CObjectOStream::WriteSeparator(void)
  1000. {
  1001.     // do nothing by default
  1002.     return;
  1003. }
  1006. END_NCBI_SCOPE
  1008. /*
  1009. * ---------------------------------------------------------------------------
  1010. * $Log: objostr.cpp,v $
  1011. * Revision 1000.4  2004/06/01 19:41:09  gouriano
  1012. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.95
  1013. *
  1014. * Revision 1.95  2004/05/17 21:03:03  gorelenk
  1015. * Added include of PCH ncbi_pch.hpp
  1016. *
  1017. * Revision 1.94  2004/02/09 18:22:34  gouriano
  1018. * enforced checking environment vars when setting initialization
  1019. * verification parameters
  1020. *
  1021. * Revision 1.93  2004/01/05 14:25:21  gouriano
  1022. * Added possibility to set serialization hooks by stack path
  1023. *
  1024. * Revision 1.92  2003/11/26 20:04:47  vasilche
  1025. * Method put in wrong file.
  1026. *
  1027. * Revision 1.91  2003/11/26 19:59:40  vasilche
  1028. * GetPosition() and GetDataFormat() methods now are implemented
  1029. * in parent classes CObjectIStream and CObjectOStream to avoid
  1030. * pure virtual method call in destructors.
  1031. *
  1032. * Revision 1.90  2003/11/24 14:10:05  grichenk
  1033. * Changed base class for CAliasTypeInfo to CPointerTypeInfo
  1034. *
  1035. * Revision 1.89  2003/11/13 14:07:38  gouriano
  1036. * Elaborated data verification on read/write/get to enable skipping mandatory class data members
  1037. *
  1038. * Revision 1.88  2003/10/24 15:54:28  grichenk
  1039. * Removed or blocked exceptions in destructors
  1040. *
  1041. * Revision 1.87  2003/10/21 21:08:46  grichenk
  1042. * Fixed aliases-related bug in XML stream
  1043. *
  1044. * Revision 1.86  2003/07/29 18:47:48  vasilche
  1045. * Fixed thread safeness of object stream hooks.
  1046. *
  1047. * Revision 1.85  2003/07/17 18:48:01  gouriano
  1048. * re-enabled initialization verification
  1049. *
  1050. * Revision 1.84  2003/06/25 17:49:05  gouriano
  1051. * fixed verification flag initialization, disabled verification
  1052. *
  1053. * Revision 1.83  2003/05/16 18:02:18  gouriano
  1054. * revised exception error messages
  1055. *
  1056. * Revision 1.82  2003/05/15 17:44:38  gouriano
  1057. * added GetStreamOffset method
  1058. *
  1059. * Revision 1.81  2003/05/13 20:13:29  vasilche
  1060. * Catch errors while closing broken CObjectOStream.
  1061. *
  1062. * Revision 1.80  2003/04/30 15:45:38  gouriano
  1063. * added catching all exceptions when flashing stream in ThrowError
  1064. *
  1065. * Revision 1.79  2003/04/30 15:38:43  gouriano
  1066. * added Flush stream when throwing an exception
  1067. *
  1068. * Revision 1.78  2003/04/29 18:30:37  gouriano
  1069. * object data member initialization verification
  1070. *
  1071. * Revision 1.77  2003/04/10 20:13:39  vakatov
  1072. * Rollback the "uninitialized member" verification -- it still needs to
  1073. * be worked upon...
  1074. *
  1075. * Revision 1.75  2003/04/03 21:47:24  gouriano
  1076. * verify initialization of data members
  1077. *
  1078. * Revision 1.74  2003/03/10 18:54:26  gouriano
  1079. * use new structured exceptions (based on CException)
  1080. *
  1081. * Revision 1.73  2003/01/22 18:53:27  gouriano
  1082. * corrected stream destruction
  1083. *
  1084. * Revision 1.72  2002/12/26 21:35:49  gouriano
  1085. * corrected handling choice's XML attributes
  1086. *
  1087. * Revision 1.71  2002/12/26 19:32:34  gouriano
  1088. * changed XML I/O streams to properly handle object copying
  1089. *
  1090. * Revision 1.70  2002/12/13 21:50:42  gouriano
  1091. * corrected reading of choices
  1092. *
  1093. * Revision 1.69  2002/11/14 20:59:48  gouriano
  1094. * added BeginChoice/EndChoice methods
  1095. *
  1096. * Revision 1.68  2002/11/04 21:29:20  grichenk
  1097. * Fixed usage of const CRef<> and CRef<> constructor
  1098. *
  1099. * Revision 1.67  2002/10/25 14:49:27  vasilche
  1100. * NCBI C Toolkit compatibility code extracted to libxcser library.
  1101. * Serial streams flags names were renamed to fXxx.
  1102. *
  1103. * Names of flags
  1104. *
  1105. * Revision 1.66  2002/09/19 14:00:38  grichenk
  1106. * Implemented CObjectHookGuard for write and copy hooks
  1107. * Added DefaultRead/Write/Copy methods to base hook classes
  1108. *
  1109. * Revision 1.65  2002/08/30 16:22:22  vasilche
  1110. * Removed excessive _TRACEs
  1111. *
  1112. * Revision 1.64  2002/08/26 18:32:29  grichenk
  1113. * Added Get/SetAutoSeparator() to CObjectOStream to control
  1114. * output of separators.
  1115. *
  1116. * Revision 1.63  2002/03/07 22:02:01  grichenk
  1117. * Added "Separator" modifier for CObjectOStream
  1118. *
  1119. * Revision 1.62  2001/10/17 20:41:25  grichenk
  1120. * Added CObjectOStream::CharBlock class
  1121. *
  1122. * Revision 1.61  2001/07/30 14:42:46  lavr
  1123. * eDiag_Trace and eDiag_Fatal always print as much as possible
  1124. *
  1125. * Revision 1.60  2001/05/17 15:07:08  lavr
  1126. * Typos corrected
  1127. *
  1128. * Revision 1.59  2001/01/05 20:10:51  vasilche
  1129. * CByteSource, CIStrBuffer, COStrBuffer, CLightString, CChecksum, CWeakMap
  1130. * were moved to util.
  1131. *
  1132. * Revision 1.58  2000/12/26 22:24:13  vasilche
  1133. * Fixed errors of compilation on Mac.
  1134. *
  1135. * Revision 1.57  2000/12/15 22:07:02  vasilche
  1136. * Fixed typo eNotOpen -> eNoError.
  1137. *
  1138. * Revision 1.56  2000/12/15 21:29:02  vasilche
  1139. * Moved some typedefs/enums from corelib/ncbistd.hpp.
  1140. * Added flags to CObjectIStream/CObjectOStream: eFlagAllowNonAsciiChars.
  1141. * TByte typedef replaced by Uint1.
  1142. *
  1143. * Revision 1.55  2000/12/15 15:38:44  vasilche
  1144. * Added support of Int8 and long double.
  1145. * Enum values now have type Int4 instead of long.
  1146. *
  1147. * Revision 1.54  2000/10/20 19:29:36  vasilche
  1148. * Adapted for MSVC which doesn't like explicit operator templates.
  1149. *
  1150. * Revision 1.53  2000/10/20 15:51:42  vasilche
  1151. * Fixed data error processing.
  1152. * Added interface for constructing container objects directly into output stream.
  1153. * object.hpp, object.inl and object.cpp were split to
  1154. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  1155. *
  1156. * Revision 1.52  2000/10/17 18:45:35  vasilche
  1157. * Added possibility to turn off object cross reference detection in
  1158. * CObjectIStream and CObjectOStream.
  1159. *
  1160. * Revision 1.51  2000/10/13 16:28:39  vasilche
  1161. * Reduced header dependency.
  1162. * Avoid use of templates with virtual methods.
  1163. * Reduced amount of different maps used.
  1164. * All this lead to smaller compiled code size (libraries and programs).
  1165. *
  1166. * Revision 1.50  2000/10/03 17:22:44  vasilche
  1167. * Reduced header dependency.
  1168. * Reduced size of debug libraries on WorkShop by 3 times.
  1169. * Fixed tag allocation for parent classes.
  1170. * Fixed CObject allocation/deallocation in streams.
  1171. * Moved instantiation of several templates in separate source file.
  1172. *
  1173. * Revision 1.49  2000/09/29 16:18:24  vasilche
  1174. * Fixed binary format encoding/decoding on 64 bit compulers.
  1175. * Implemented CWeakMap<> for automatic cleaning map entries.
  1176. * Added cleaning local hooks via CWeakMap<>.
  1177. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  1178. * Added some user interface methods to CObjectIStream, CObjectOStream and
  1179. * CObjectStreamCopier.
  1180. *
  1181. * Revision 1.48  2000/09/26 19:24:57  vasilche
  1182. * Added user interface for setting read/write/copy hooks.
  1183. *
  1184. * Revision 1.47  2000/09/26 17:38:22  vasilche
  1185. * Fixed incomplete choiceptr implementation.
  1186. * Removed temporary comments.
  1187. *
  1188. * Revision 1.46  2000/09/18 20:00:24  vasilche
  1189. * Separated CVariantInfo and CMemberInfo.
  1190. * Implemented copy hooks.
  1191. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  1192. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  1193. *
  1194. * Revision 1.45  2000/09/01 13:16:18  vasilche
  1195. * Implemented class/container/choice iterators.
  1196. * Implemented CObjectStreamCopier for copying data without loading into memory.
  1197. *
  1198. * Revision 1.44  2000/08/15 19:44:50  vasilche
  1199. * Added Read/Write hooks:
  1200. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  1201. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  1202. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  1203. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  1204. *
  1205. * Revision 1.43  2000/07/03 18:42:45  vasilche
  1206. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  1207. * Reduced header dependency.
  1208. *
  1209. * Revision 1.42  2000/06/16 16:31:21  vasilche
  1210. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  1211. *
  1212. * Revision 1.41  2000/06/07 19:46:00  vasilche
  1213. * Some code cleaning.
  1214. * Macros renaming in more clear way.
  1215. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  1216. *
  1217. * Revision 1.40  2000/06/01 19:07:04  vasilche
  1218. * Added parsing of XML data.
  1219. *
  1220. * Revision 1.39  2000/05/24 20:08:48  vasilche
  1221. * Implemented XML dump.
  1222. *
  1223. * Revision 1.38  2000/05/09 16:38:39  vasilche
  1224. * CObject::GetTypeInfo now moved to CObjectGetTypeInfo::GetTypeInfo to reduce possible errors.
  1225. * Added write context to CObjectOStream.
  1226. * Inlined most of methods of helping class Member, Block, ByteBlock etc.
  1227. *
  1228. * Revision 1.37  2000/05/04 16:22:20  vasilche
  1229. * Cleaned and optimized blocks and members.
  1230. *
  1231. * Revision 1.36  2000/04/28 16:58:13  vasilche
  1232. * Added classes CByteSource and CByteSourceReader for generic reading.
  1233. * Added delayed reading of choice variants.
  1234. *
  1235. * Revision 1.35  2000/04/13 14:50:27  vasilche
  1236. * Added CObjectIStream::Open() and CObjectOStream::Open() for easier use.
  1237. *
  1238. * Revision 1.34  2000/04/06 16:11:00  vasilche
  1239. * Fixed bug with iterators in choices.
  1240. * Removed unneeded calls to ReadExternalObject/WriteExternalObject.
  1241. * Added output buffering to text ASN.1 data.
  1242. *
  1243. * Revision 1.33  2000/03/29 15:55:29  vasilche
  1244. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  1245. * Added generic iterators by class -
  1246. *  CTypeIterator<class>, CTypeConstIterator<class>,
  1247. *  CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  1248. *  CObjectsIterator and CObjectsConstIterator.
  1249. *
  1250. * Revision 1.32  2000/02/17 20:02:44  vasilche
  1251. * Added some standard serialization exceptions.
  1252. * Optimized text/binary ASN.1 reading.
  1253. * Fixed wrong encoding of StringStore in ASN.1 binary format.
  1254. * Optimized logic of object collection.
  1255. *
  1256. * Revision 1.31  2000/02/11 17:10:25  vasilche
  1257. * Optimized text parsing.
  1258. *
  1259. * Revision 1.30  2000/01/10 19:46:41  vasilche
  1260. * Fixed encoding/decoding of REAL type.
  1261. * Fixed encoding/decoding of StringStore.
  1262. * Fixed encoding/decoding of NULL type.
  1263. * Fixed error reporting.
  1264. * Reduced object map (only classes).
  1265. *
  1266. * Revision 1.29  2000/01/05 19:43:56  vasilche
  1267. * Fixed error messages when reading from ASN.1 binary file.
  1268. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  1269. * Added TAG support to key/value of map.
  1270. * Added support of NULL variant in CHOICE.
  1271. *
  1272. * Revision 1.28  1999/12/28 18:55:51  vasilche
  1273. * Reduced size of compiled object files:
  1274. * 1. avoid inline or implicit virtual methods (especially destructors).
  1275. * 2. avoid std::string's methods usage in inline methods.
  1276. * 3. avoid string literals ("xxx") in inline methods.
  1277. *
  1278. * Revision 1.27  1999/12/20 15:29:35  vasilche
  1279. * Fixed bug with old ASN structures.
  1280. *
  1281. * Revision 1.26  1999/12/17 19:05:03  vasilche
  1282. * Simplified generation of GetTypeInfo methods.
  1283. *
  1284. * Revision 1.25  1999/10/04 16:22:18  vasilche
  1285. * Fixed bug with old ASN.1 structures.
  1286. *
  1287. * Revision 1.24  1999/09/27 14:18:02  vasilche
  1288. * Fixed bug with overloaded constructors of Block.
  1289. *
  1290. * Revision 1.23  1999/09/24 18:19:19  vasilche
  1291. * Removed dependency on NCBI toolkit.
  1292. *
  1293. * Revision 1.22  1999/09/23 21:16:08  vasilche
  1294. * Removed dependence on asn.h
  1295. *
  1296. * Revision 1.21  1999/09/23 20:25:04  vasilche
  1297. * Added support HAVE_NCBI_C
  1298. *
  1299. * Revision 1.20  1999/09/23 18:57:00  vasilche
  1300. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  1301. *
  1302. * Revision 1.19  1999/09/14 18:54:19  vasilche
  1303. * Fixed bugs detected by gcc & egcs.
  1304. * Removed unneeded includes.
  1305. *
  1306. * Revision 1.18  1999/08/16 16:08:31  vasilche
  1307. * Added ENUMERATED type.
  1308. *
  1309. * Revision 1.17  1999/08/13 20:22:58  vasilche
  1310. * Fixed lot of bugs in datatool
  1311. *
  1312. * Revision 1.16  1999/08/13 15:53:51  vasilche
  1313. * C++ analog of asntool: datatool
  1314. *
  1315. * Revision 1.15  1999/07/22 17:33:55  vasilche
  1316. * Unified reading/writing of objects in all three formats.
  1317. *
  1318. * Revision 1.14  1999/07/19 15:50:35  vasilche
  1319. * Added interface to old ASN.1 routines.
  1320. * Added naming of key/value in STL map.
  1321. *
  1322. * Revision 1.13  1999/07/09 16:32:54  vasilche
  1323. * Added OCTET STRING write/read.
  1324. *
  1325. * Revision 1.12  1999/07/07 21:15:03  vasilche
  1326. * Cleaned processing of string types (string, char*, const char*).
  1327. *
  1328. * Revision 1.11  1999/07/02 21:31:58  vasilche
  1329. * Implemented reading from ASN.1 binary format.
  1330. *
  1331. * Revision 1.10  1999/07/01 17:55:33  vasilche
  1332. * Implemented ASN.1 binary write.
  1333. *
  1334. * Revision 1.9  1999/06/30 16:04:59  vasilche
  1335. * Added support for old ASN.1 structures.
  1336. *
  1337. * Revision 1.8  1999/06/24 14:44:57  vasilche
  1338. * Added binary ASN.1 output.
  1339. *
  1340. * Revision 1.7  1999/06/17 20:42:06  vasilche
  1341. * Fixed storing/loading of pointers.
  1342. *
  1343. * Revision 1.6  1999/06/16 20:35:33  vasilche
  1344. * Cleaned processing of blocks of data.
  1345. * Added input from ASN.1 text format.
  1346. *
  1347. * Revision 1.5  1999/06/15 16:19:50  vasilche
  1348. * Added ASN.1 object output stream.
  1349. *
  1350. * Revision 1.4  1999/06/10 21:06:48  vasilche
  1351. * Working binary output and almost working binary input.
  1352. *
  1353. * Revision 1.3  1999/06/07 19:30:27  vasilche
  1354. * More bug fixes
  1355. *
  1356. * Revision 1.2  1999/06/04 20:51:47  vasilche
  1357. * First compilable version of serialization.
  1358. *
  1359. * Revision 1.1  1999/05/19 19:56:54  vasilche
  1360. * Commit just in case.
  1361. *
  1362. * ===========================================================================
  1363. */