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

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

生物技术

开发平台：

C/C++

objistr.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objistr.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:40:54  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.129
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: objistr.cpp,v 1000.4 2004/06/01 19:40:54 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/ncbiutil.hpp>
  47. #include <corelib/ncbimtx.hpp>
  49. #include <exception>
  51. #include <util/bytesrc.hpp>
  53. #include <serial/objistr.hpp>
  54. #include <serial/typeref.hpp>
  55. #include <serial/member.hpp>
  56. #include <serial/variant.hpp>
  57. #include <serial/classinfo.hpp>
  58. #include <serial/choice.hpp>
  59. #include <serial/aliasinfo.hpp>
  60. #include <serial/continfo.hpp>
  61. #include <serial/enumvalues.hpp>
  62. #include <serial/memberlist.hpp>
  63. #include <serial/delaybuf.hpp>
  64. #include <serial/objistrimpl.hpp>
  65. #include <serial/objectinfo.hpp>
  66. #include <serial/objectiter.hpp>
  67. #include <serial/objlist.hpp>
  68. #include <serial/choiceptr.hpp>
  69. #include <serial/serialimpl.hpp>
  70. #include <serial/pack_string.hpp>
  72. #include <limits.h>
  73. #if HAVE_WINDOWS_H
  74. // In MSVC limits.h doesn't define FLT_MIN & FLT_MAX
  75. # include <float.h>
  76. #endif
  78. #undef _TRACE
  79. #define _TRACE(arg) ((void)0)
  81. BEGIN_NCBI_SCOPE
  83. CRef<CByteSource> CObjectIStream::GetSource(ESerialDataFormat format,
  84.                                             const string& fileName,
  85.                                             TSerialOpenFlags openFlags)
  86. {
  87.     if ( (openFlags & eSerial_StdWhenEmpty) && fileName.empty() ||
  88.          (openFlags & eSerial_StdWhenDash) && fileName == "-" ||
  89.          (openFlags & eSerial_StdWhenStd) && fileName == "stdin" ) {
  90.         return CRef<CByteSource>(new CStreamByteSource(NcbiCin));
  91.     }
  92.     else {
  93.         bool binary;
  94.         switch ( format ) {
  95.         case eSerial_AsnText:
  96.         case eSerial_Xml:
  97.             binary = false;
  98.             break;
  99.         case eSerial_AsnBinary:
  100.             binary = true;
  101.             break;
  102.         default:
  103.             NCBI_THROW(CSerialException,eFail,
  104.                        "CObjectIStream::Open: unsupported format");
  105.         }
  106.         
  107.         if ( (openFlags & eSerial_UseFileForReread) )  {
  108.             // use file as permanent file
  109.             return CRef<CByteSource>(new CFileByteSource(fileName, binary));
  110.         }
  111.         else {
  112.             // open file as stream
  113.             return CRef<CByteSource>(new CFStreamByteSource(fileName, binary));
  114.         }
  115.     }
  116. }
  118. CRef<CByteSource> CObjectIStream::GetSource(CNcbiIstream& inStream,
  119.                                             bool deleteInStream)
  120. {
  121.     if ( deleteInStream ) {
  122.         return CRef<CByteSource>(new CFStreamByteSource(inStream));
  123.     }
  124.     else {
  125.         return CRef<CByteSource>(new CStreamByteSource(inStream));
  126.     }
  127. }
  129. CObjectIStream* CObjectIStream::Create(ESerialDataFormat format)
  130. {
  131.     switch ( format ) {
  132.     case eSerial_AsnText:
  133.         return CreateObjectIStreamAsn();
  134.     case eSerial_AsnBinary:
  135.         return CreateObjectIStreamAsnBinary();
  136.     case eSerial_Xml:
  137.         return CreateObjectIStreamXml();
  138.     default:
  139.         break;
  140.     }
  141.     NCBI_THROW(CSerialException,eFail,
  142.                "CObjectIStream::Open: unsupported format");
  143. }
  145. CObjectIStream* CObjectIStream::Create(ESerialDataFormat format,
  146.                                        CByteSource& source)
  147. {
  148.     AutoPtr<CObjectIStream> stream(Create(format));
  149.     stream->Open(source);
  150.     return stream.release();
  151. }
  153. CObjectIStream* CObjectIStream::Create(ESerialDataFormat format,
  154.                                        CByteSourceReader& reader)
  155. {
  156.     AutoPtr<CObjectIStream> stream(Create(format));
  157.     stream->Open(reader);
  158.     return stream.release();
  159. }
  161. CObjectIStream* CObjectIStream::Open(ESerialDataFormat format,
  162.                                      CNcbiIstream& inStream,
  163.                                      bool deleteInStream)
  164. {
  165.     CRef<CByteSource> src = GetSource(inStream, deleteInStream);
  166.     return Create(format, *src);
  167. }
  169. CObjectIStream* CObjectIStream::Open(ESerialDataFormat format,
  170.                                      const string& fileName,
  171.                                      TSerialOpenFlags openFlags)
  172. {
  173.     CRef<CByteSource> src = GetSource(format, fileName, openFlags);
  174.     return Create(format, *src);
  175. }
  177. /////////////////////////////////////////////////////////////////////////////
  178. // data verification setup
  180. ESerialVerifyData CObjectIStream::ms_VerifyDataDefault = eSerialVerifyData_Default;
  181. static CSafeStaticRef< CTls<int> > s_VerifyTLS;
  184. void CObjectIStream::SetVerifyDataThread(ESerialVerifyData verify)
  185. {
  186.     x_GetVerifyDataDefault();
  187.     ESerialVerifyData tls_verify = ESerialVerifyData(long(s_VerifyTLS->GetValue()));
  188.     if (tls_verify != eSerialVerifyData_Never &&
  189.         tls_verify != eSerialVerifyData_Always &&
  190.         tls_verify != eSerialVerifyData_DefValueAlways) {
  191.         s_VerifyTLS->SetValue(reinterpret_cast<int*>(verify));
  192.     }
  193. }
  195. void CObjectIStream::SetVerifyDataGlobal(ESerialVerifyData verify)
  196. {
  197.     x_GetVerifyDataDefault();
  198.     if (ms_VerifyDataDefault != eSerialVerifyData_Never &&
  199.         ms_VerifyDataDefault != eSerialVerifyData_Always &&
  200.         ms_VerifyDataDefault != eSerialVerifyData_DefValueAlways) {
  201.         ms_VerifyDataDefault = verify;
  202.     }
  203. }
  205. ESerialVerifyData CObjectIStream::x_GetVerifyDataDefault(void)
  206. {
  207.     ESerialVerifyData verify;
  208.     if (ms_VerifyDataDefault == eSerialVerifyData_Never ||
  209.         ms_VerifyDataDefault == eSerialVerifyData_Always ||
  210.         ms_VerifyDataDefault == eSerialVerifyData_DefValueAlways) {
  211.         verify = ms_VerifyDataDefault;
  212.     } else {
  213.         verify = ESerialVerifyData(long(s_VerifyTLS->GetValue()));
  214.         if (verify == eSerialVerifyData_Default) {
  215.             if (ms_VerifyDataDefault == eSerialVerifyData_Default) {
  217.                 // change the default here, if you wish
  218.                 ms_VerifyDataDefault = eSerialVerifyData_Yes;
  219.                 //ms_VerifyDataDefault = eSerialVerifyData_No;
  221.                 const char* str = getenv(SERIAL_VERIFY_DATA_READ);
  222.                 if (str) {
  223.                     if (NStr::CompareNocase(str,"YES") == 0) {
  224.                         ms_VerifyDataDefault = eSerialVerifyData_Yes;
  225.                     } else if (NStr::CompareNocase(str,"NO") == 0) {
  226.                         ms_VerifyDataDefault = eSerialVerifyData_No;
  227.                     } else if (NStr::CompareNocase(str,"NEVER") == 0) {
  228.                         ms_VerifyDataDefault = eSerialVerifyData_Never;
  229.                     } else  if (NStr::CompareNocase(str,"ALWAYS") == 0) {
  230.                         ms_VerifyDataDefault = eSerialVerifyData_Always;
  231.                     } else  if (NStr::CompareNocase(str,"DEFVALUE") == 0) {
  232.                         ms_VerifyDataDefault = eSerialVerifyData_DefValue;
  233.                     } else  if (NStr::CompareNocase(str,"DEFVALUE_ALWAYS") == 0) {
  234.                         ms_VerifyDataDefault = eSerialVerifyData_DefValueAlways;
  235.                     }
  236.                 }
  237.             }
  238.             verify = ms_VerifyDataDefault;
  239.         }
  240.     }
  241.     return verify;
  242. }
  244. /////////////////////////////////////////////////////////////////////////////
  245. // skip unknown members setup
  247. ESerialSkipUnknown CObjectIStream::ms_SkipUnknownDefault = eSerialSkipUnknown_Default;
  248. static CSafeStaticRef< CTls<int> > s_SkipTLS;
  251. void CObjectIStream::SetSkipUnknownThread(ESerialSkipUnknown skip)
  252. {
  253.     x_GetSkipUnknownDefault();
  254.     ESerialSkipUnknown tls_skip = ESerialSkipUnknown(long(s_SkipTLS->GetValue()));
  255.     if (tls_skip != eSerialSkipUnknown_Never &&
  256.         tls_skip != eSerialSkipUnknown_Always) {
  257.         s_SkipTLS->SetValue(reinterpret_cast<int*>(skip));
  258.     }
  259. }
  261. void CObjectIStream::SetSkipUnknownGlobal(ESerialSkipUnknown skip)
  262. {
  263.     x_GetSkipUnknownDefault();
  264.     if (ms_SkipUnknownDefault != eSerialSkipUnknown_Never &&
  265.         ms_SkipUnknownDefault != eSerialSkipUnknown_Always) {
  266.         ms_SkipUnknownDefault = skip;
  267.     }
  268. }
  270. ESerialSkipUnknown CObjectIStream::x_GetSkipUnknownDefault(void)
  271. {
  272.     ESerialSkipUnknown skip;
  273.     if (ms_SkipUnknownDefault == eSerialSkipUnknown_Never ||
  274.         ms_SkipUnknownDefault == eSerialSkipUnknown_Always) {
  275.         skip = ms_SkipUnknownDefault;
  276.     } else {
  277.         skip = ESerialSkipUnknown(long(s_SkipTLS->GetValue()));
  278.         if (skip == eSerialSkipUnknown_Default) {
  279.             if (ms_SkipUnknownDefault == eSerialSkipUnknown_Default) {
  281.                 // change the default here, if you wish
  282.                 ms_SkipUnknownDefault = eSerialSkipUnknown_No;
  283.                 //ms_SkipUnknownDefault = eSerialSkipUnknown_Yes;
  285.                 const char* str = getenv(SERIAL_SKIP_UNKNOWN_MEMBERS);
  286.                 if (str) {
  287.                     if (NStr::CompareNocase(str,"YES") == 0) {
  288.                         ms_SkipUnknownDefault = eSerialSkipUnknown_Yes;
  289.                     } else if (NStr::CompareNocase(str,"NO") == 0) {
  290.                         ms_SkipUnknownDefault = eSerialSkipUnknown_No;
  291.                     } else if (NStr::CompareNocase(str,"NEVER") == 0) {
  292.                         ms_SkipUnknownDefault = eSerialSkipUnknown_Never;
  293.                     } else  if (NStr::CompareNocase(str,"ALWAYS") == 0) {
  294.                         ms_SkipUnknownDefault = eSerialSkipUnknown_Always;
  295.                     }
  296.                 }
  297.             }
  298.             skip = ms_SkipUnknownDefault;
  299.         }
  300.     }
  301.     return skip;
  302. }
  304. /////////////////////////////////////////////////////////////////////////////
  306. CObjectIStream::CObjectIStream(ESerialDataFormat format)
  307.     : m_DiscardCurrObject(false),
  308.       m_DataFormat(format),
  309.       m_VerifyData(x_GetVerifyDataDefault()),
  310.       m_SkipUnknown(x_GetSkipUnknownDefault()),
  311.       m_Fail(fNotOpen),
  312.       m_Flags(fFlagNone)
  313. {
  314. }
  316. CObjectIStream::~CObjectIStream(void)
  317. {
  318.     try {
  319.         Close();
  320.         ResetLocalHooks();
  321.     }
  322.     catch (...) {
  323.         ERR_POST("Can not close input stream");
  324.     }
  325. }
  327. void CObjectIStream::Open(CByteSourceReader& reader)
  328. {
  329.     Close();
  330.     _ASSERT(m_Fail == fNotOpen);
  331.     m_Input.Open(reader);
  332.     m_Fail = 0;
  333. }
  335. void CObjectIStream::Open(CByteSource& source)
  336. {
  337.     CRef<CByteSourceReader> reader = source.Open();
  338.     Open(*reader);
  339. }
  341. void CObjectIStream::Open(CNcbiIstream& inStream, bool deleteInStream)
  342. {
  343.     CRef<CByteSource> src = GetSource(inStream, deleteInStream);
  344.     Open(*src);
  345. }
  347. void CObjectIStream::ResetLocalHooks(void)
  348. {
  349.     CMutexGuard guard(GetTypeInfoMutex());
  350.     m_ObjectHookKey.Clear();
  351.     m_ClassMemberHookKey.Clear();
  352.     m_ChoiceVariantHookKey.Clear();
  353.     m_ObjectSkipHookKey.Clear();
  354.     m_ClassMemberSkipHookKey.Clear();
  355.     m_ChoiceVariantSkipHookKey.Clear();
  356. }
  358. void CObjectIStream::Close(void)
  359. {
  360.     if (m_Fail != fNotOpen) {
  361.         m_Input.Close();
  362.         if ( m_Objects )
  363.             m_Objects->Clear();
  364.         ClearStack();
  365.         m_Fail = fNotOpen;
  366.     }
  367. }
  369. CObjectIStream::TFailFlags CObjectIStream::SetFailFlags(TFailFlags flags,
  370.                                                         const char* message)
  371. {
  372.     TFailFlags old = m_Fail;
  373.     if (flags == fNoError) {
  374.         m_Fail = flags;
  375.     } else {
  376.         m_Fail |= flags;
  377.         if ( !old && flags ) {
  378.             // first fail
  379. // redundant
  380. //            ERR_POST(Error << "CObjectIStream: error at "<<
  381. //                     GetPosition()<<": "<<GetStackTrace() << ": " << message);
  382.         }
  383.     }
  384.     return old;
  385. }
  387. bool CObjectIStream::InGoodState(void)
  388. {
  389.     if ( fail() ) {
  390.         // fail flag already set
  391.         return false;
  392.     }
  393.     else if ( m_Input.fail() ) {
  394.         // IO exception thrown without setting fail flag
  395.         SetFailFlags(fReadError, m_Input.GetError());
  396.         m_Input.ResetFail();
  397.         return false;
  398.     }
  399.     else {
  400.         // ok
  401.         return true;
  402.     }
  403. }
  405. void CObjectIStream::Unended(const string& msg)
  406. {
  407.     if ( InGoodState() )
  408.         ThrowError(fFail, msg);
  409. }
  411. void CObjectIStream::UnendedFrame(void)
  412. {
  413.     Unended("internal error: unended object stack frame");
  414. }
  416. void CObjectIStream::x_SetPathHooks(bool set)
  417. {
  418.     if (!m_PathReadObjectHooks.IsEmpty()) {
  419.         CReadObjectHook* hook = m_PathReadObjectHooks.GetHook(*this);
  420.         if (hook) {
  421.             CTypeInfo* item = m_PathReadObjectHooks.FindType(*this);
  422.             if (item) {
  423.                 if (set) {
  424.                     item->SetLocalReadHook(*this, hook);
  425.                 } else {
  426.                     item->ResetLocalReadHook(*this);
  427.                 }
  428.             }
  429.         }
  430.     }
  431.     if (!m_PathSkipObjectHooks.IsEmpty()) {
  432.         CSkipObjectHook* hook = m_PathSkipObjectHooks.GetHook(*this);
  433.         if (hook) {
  434.             CTypeInfo* item = m_PathSkipObjectHooks.FindType(*this);
  435.             if (item) {
  436.                 if (set) {
  437.                     item->SetLocalSkipHook(*this, hook);
  438.                 } else {
  439.                     item->ResetLocalSkipHook(*this);
  440.                 }
  441.             }
  442.         }
  443.     }
  444.     if (!m_PathReadMemberHooks.IsEmpty()) {
  445.         CReadClassMemberHook* hook = m_PathReadMemberHooks.GetHook(*this);
  446.         if (hook) {
  447.             CMemberInfo* item = m_PathReadMemberHooks.FindItem(*this);
  448.             if (item) {
  449.                 if (set) {
  450.                     item->SetLocalReadHook(*this, hook);
  451.                 } else {
  452.                     item->ResetLocalReadHook(*this);
  453.                 }
  454.             }
  455.         }
  456.     }
  457.     if (!m_PathSkipMemberHooks.IsEmpty()) {
  458.         CSkipClassMemberHook* hook = m_PathSkipMemberHooks.GetHook(*this);
  459.         if (hook) {
  460.             CMemberInfo* item = m_PathSkipMemberHooks.FindItem(*this);
  461.             if (item) {
  462.                 if (set) {
  463.                     item->SetLocalSkipHook(*this, hook);
  464.                 } else {
  465.                     item->ResetLocalSkipHook(*this);
  466.                 }
  467.             }
  468.         }
  469.     }
  470.     if (!m_PathReadVariantHooks.IsEmpty()) {
  471.         CReadChoiceVariantHook* hook = m_PathReadVariantHooks.GetHook(*this);
  472.         if (hook) {
  473.             CVariantInfo* item = m_PathReadVariantHooks.FindItem(*this);
  474.             if (item) {
  475.                 if (set) {
  476.                     item->SetLocalReadHook(*this, hook);
  477.                 } else {
  478.                     item->ResetLocalReadHook(*this);
  479.                 }
  480.             }
  481.         }
  482.     }
  483.     if (!m_PathSkipVariantHooks.IsEmpty()) {
  484.         CSkipChoiceVariantHook* hook = m_PathSkipVariantHooks.GetHook(*this);
  485.         if (hook) {
  486.             CVariantInfo* item = m_PathSkipVariantHooks.FindItem(*this);
  487.             if (item) {
  488.                 if (set) {
  489.                     item->SetLocalSkipHook(*this, hook);
  490.                 } else {
  491.                     item->ResetLocalSkipHook(*this);
  492.                 }
  493.             }
  494.         }
  495.     }
  496. }
  498. void CObjectIStream::SetPathReadObjectHook(const string& path,
  499.                                            CReadObjectHook* hook)
  500. {
  501.     m_PathReadObjectHooks.SetHook(path,hook);
  502.     WatchPathHooks();
  503. }
  504. void CObjectIStream::SetPathSkipObjectHook(const string& path,
  505.                                            CSkipObjectHook* hook)
  506. {
  507.     m_PathSkipObjectHooks.SetHook(path,hook);
  508.     WatchPathHooks();
  509. }
  510. void CObjectIStream::SetPathReadMemberHook(const string& path,
  511.                                             CReadClassMemberHook* hook)
  512. {
  513.     m_PathReadMemberHooks.SetHook(path,hook);
  514.     WatchPathHooks();
  515. }
  516. void CObjectIStream::SetPathSkipMemberHook(const string& path,
  517.                                             CSkipClassMemberHook* hook)
  518. {
  519.     m_PathSkipMemberHooks.SetHook(path,hook);
  520.     WatchPathHooks();
  521. }
  522. void CObjectIStream::SetPathReadVariantHook(const string& path,
  523.                                             CReadChoiceVariantHook* hook)
  524. {
  525.     m_PathReadVariantHooks.SetHook(path,hook);
  526.     WatchPathHooks();
  527. }
  528. void CObjectIStream::SetPathSkipVariantHook(const string& path,
  529.                                             CSkipChoiceVariantHook* hook)
  530. {
  531.     m_PathSkipVariantHooks.SetHook(path,hook);
  532.     WatchPathHooks();
  533. }
  535. string CObjectIStream::GetStackTrace(void) const
  536. {
  537.     return GetStackTraceASN();
  538. }
  540. size_t CObjectIStream::GetStreamOffset(void) const
  541. {
  542.     return m_Input.GetStreamOffset();
  543. }
  545. void CObjectIStream::SetStreamOffset(size_t pos)
  546. {
  547.     m_Input.SetStreamOffset(pos);
  548. }
  550. string CObjectIStream::GetPosition(void) const
  551. {
  552.     return "byte "+NStr::UIntToString(GetStreamOffset());
  553. }
  555. void CObjectIStream::ThrowError1(const char* file, int line, 
  556.                                  TFailFlags fail, const char* message)
  557. {
  558.     ThrowError1(file,line,fail,string(message));
  559. }
  561. void CObjectIStream::ThrowError1(const char* file, int line, 
  562.                                  TFailFlags fail, const string& message)
  563. {
  564.     CSerialException::EErrCode err;
  565.     SetFailFlags(fail, message.c_str());
  566.     switch(fail)
  567.     {
  568.     case fNoError:
  569.         CNcbiDiag(file, line, eDiag_Trace) << message;
  570.         return;
  571.     case fEOF:          err = CSerialException::eEOF;          break;
  572.     default:
  573.     case fReadError:    err = CSerialException::eIoError;      break;
  574.     case fFormatError:  err = CSerialException::eFormatError;  break;
  575.     case fOverflow:     err = CSerialException::eOverflow;     break;
  576.     case fInvalidData:  err = CSerialException::eInvalidData;  break;
  577.     case fIllegalCall:  err = CSerialException::eIllegalCall;  break;
  578.     case fFail:         err = CSerialException::eFail;         break;
  579.     case fNotOpen:      err = CSerialException::eNotOpen;      break;
  580.     case fMissingValue: err = CSerialException::eMissingValue; break;
  581.     }
  582.     throw CSerialException(file,line,0,err,GetPosition()+": "+message);
  583. }
  585. static inline
  586. TTypeInfo MapType(const string& name)
  587. {
  588.     return CClassTypeInfoBase::GetClassInfoByName(name);
  589. }
  591. void CObjectIStream::RegisterObject(TTypeInfo typeInfo)
  592. {
  593.     if ( m_Objects )
  594.         m_Objects->RegisterObject(typeInfo);
  595. }
  597. void CObjectIStream::RegisterObject(TObjectPtr objectPtr, TTypeInfo typeInfo)
  598. {
  599.     if ( m_Objects )
  600.         m_Objects->RegisterObject(objectPtr, typeInfo);
  601. }
  603. const CReadObjectInfo&
  604. CObjectIStream::GetRegisteredObject(CReadObjectInfo::TObjectIndex index)
  605. {
  606.     if ( !m_Objects ) {
  607.         ThrowError(fFormatError,"invalid object index: NO_COLLECT defined");
  608.     }
  609.     return m_Objects->GetRegisteredObject(index);
  610. }
  612. // root reader
  613. void CObjectIStream::SkipFileHeader(TTypeInfo typeInfo)
  614. {
  615.     BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
  616.     
  617.     string name = ReadFileHeader();
  618.     if ( !name.empty() && name != typeInfo->GetName() ) {
  619.         ThrowError(fFormatError,
  620.                    "incompatible type "+name+"<>"+typeInfo->GetName());
  621.     }
  623.     END_OBJECT_FRAME();
  624. }
  626. void CObjectIStream::EndOfRead(void)
  627. {
  628.     if ( m_Objects )
  629.         m_Objects->Clear();
  630. }
  632. void CObjectIStream::Read(const CObjectInfo& object, ENoFileHeader)
  633. {
  634.     // root object
  635.     BEGIN_OBJECT_FRAME2(eFrameNamed, object.GetTypeInfo());
  636.     
  637.     ReadObject(object);
  639.     EndOfRead();
  640.     
  641.     END_OBJECT_FRAME();
  642. }
  644. void CObjectIStream::Read(const CObjectInfo& object)
  645. {
  646.     // root object
  647.     SkipFileHeader(object.GetTypeInfo());
  648.     Read(object, eNoFileHeader);
  649. }
  651. void CObjectIStream::Read(TObjectPtr object, TTypeInfo typeInfo, ENoFileHeader)
  652. {
  653.     // root object
  654.     BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
  656.     ReadObject(object, typeInfo);
  657.     
  658.     EndOfRead();
  660.     END_OBJECT_FRAME();
  661. }
  663. void CObjectIStream::Read(TObjectPtr object, TTypeInfo typeInfo)
  664. {
  665.     // root object
  666.     SkipFileHeader(typeInfo);
  667.     Read(object, typeInfo, eNoFileHeader);
  668. }
  670. CObjectInfo CObjectIStream::Read(TTypeInfo typeInfo)
  671. {
  672.     // root object
  673.     SkipFileHeader(typeInfo);
  674.     CObjectInfo info(typeInfo->Create(), typeInfo);
  675.     Read(info, eNoFileHeader);
  676.     return info;
  677. }
  679. CObjectInfo CObjectIStream::Read(const CObjectTypeInfo& type)
  680. {
  681.     return Read(type.GetTypeInfo());
  682. }
  684. void CObjectIStream::Skip(TTypeInfo typeInfo, ENoFileHeader)
  685. {
  686.     BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
  688.     SkipObject(typeInfo);
  689.     
  690.     EndOfRead();
  692.     END_OBJECT_FRAME();
  693. }
  695. void CObjectIStream::Skip(TTypeInfo typeInfo)
  696. {
  697.     SkipFileHeader(typeInfo);
  698.     Skip(typeInfo, eNoFileHeader);
  699. }
  701. void CObjectIStream::Skip(const CObjectTypeInfo& type)
  702. {
  703.     Skip(type.GetTypeInfo());
  704. }
  706. void CObjectIStream::StartDelayBuffer(void)
  707. {
  708.     m_Input.StartSubSource();
  709. }
  711. CRef<CByteSource> CObjectIStream::EndDelayBuffer(void)
  712. {
  713.     return m_Input.EndSubSource();
  714. }
  716. void CObjectIStream::EndDelayBuffer(CDelayBuffer& buffer,
  717.                                     const CItemInfo* itemInfo,
  718.                                     TObjectPtr objectPtr)
  719. {
  720.     CRef<CByteSource> src = EndDelayBuffer();
  721.     buffer.SetData(itemInfo, objectPtr, GetDataFormat(), *src);
  722. }
  724. void CObjectIStream::ExpectedMember(const CMemberInfo* memberInfo)
  725. {
  726.     if (GetVerifyData() == eSerialVerifyData_Yes) {
  727.         ThrowError(fFormatError,
  728.                    "member "+memberInfo->GetId().ToString()+" expected");
  729.     } else {
  730.         ERR_POST("member "+memberInfo->GetId().ToString()+" is missing");
  731.     }
  732. }
  734. void CObjectIStream::DuplicatedMember(const CMemberInfo* memberInfo)
  735. {
  736.     ThrowError(fFormatError,
  737.                "duplicated member: "+memberInfo->GetId().ToString());
  738. }
  740. void CObjectIStream::ReadSeparateObject(const CObjectInfo& object)
  741. {
  742.     if ( m_Objects ) {
  743.         size_t firstObject = m_Objects->GetObjectCount();
  744.         ReadObject(object);
  745.         size_t lastObject = m_Objects->GetObjectCount();
  746.         m_Objects->ForgetObjects(firstObject, lastObject);
  747.     }
  748.     else {
  749.         ReadObject(object);
  750.     }
  751. }
  753. void CObjectIStream::ReadExternalObject(TObjectPtr objectPtr,
  754.                                         TTypeInfo typeInfo)
  755. {
  756.     _TRACE("CObjectIStream::Read("<<NStr::PtrToString(objectPtr)<<", "<<
  757.            typeInfo->GetName()<<")");
  758.     RegisterObject(objectPtr, typeInfo);
  759.     ReadObject(objectPtr, typeInfo);
  760. }
  762. CObjectInfo CObjectIStream::ReadObject(void)
  763. {
  764.     TTypeInfo typeInfo = MapType(ReadFileHeader());
  765.     TObjectPtr objectPtr;
  766.     BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
  768.     objectPtr = typeInfo->Create();
  769.     CRef<CObject> ref;
  770.     if ( typeInfo->IsCObject() )
  771.         ref.Reset(static_cast<CObject*>(objectPtr));
  772.     RegisterObject(objectPtr, typeInfo);
  773.     ReadObject(objectPtr, typeInfo);
  774.     if ( typeInfo->IsCObject() )
  775.         ref.Release();
  776.     END_OBJECT_FRAME();
  777.     return make_pair(objectPtr, typeInfo);
  778. }
  780. void CObjectIStream::ReadObject(const CObjectInfo& object)
  781. {
  782.     ReadObject(object.GetObjectPtr(), object.GetTypeInfo());
  783. }
  785. void CObjectIStream::SkipObject(const CObjectTypeInfo& objectType)
  786. {
  787.     SkipObject(objectType.GetTypeInfo());
  788. }
  790. void CObjectIStream::ReadClassMember(const CObjectInfo::CMemberIterator& member)
  791. {
  792.     const CMemberInfo* memberInfo = member.GetMemberInfo();
  793.     TObjectPtr classPtr = member.GetClassObject().GetObjectPtr();
  794.     ReadObject(memberInfo->GetMemberPtr(classPtr),
  795.                memberInfo->GetTypeInfo());
  796. }
  798. void CObjectIStream::ReadChoiceVariant(const CObjectInfoCV& object)
  799. {
  800.     const CVariantInfo* variantInfo = object.GetVariantInfo();
  801.     TObjectPtr choicePtr = object.GetChoiceObject().GetObjectPtr();
  802.     variantInfo->DefaultReadVariant(*this, choicePtr);
  803. }
  805. string CObjectIStream::ReadFileHeader(void)
  806. {
  807.     return NcbiEmptyString;
  808. }
  810. string CObjectIStream::PeekNextTypeName(void)
  811. {
  812.     return NcbiEmptyString;
  813. }
  815. pair<TObjectPtr, TTypeInfo> CObjectIStream::ReadPointer(TTypeInfo declaredType)
  816. {
  817.     _TRACE("CObjectIStream::ReadPointer("<<declaredType->GetName()<<")");
  818.     TObjectPtr objectPtr;
  819.     TTypeInfo objectType;
  820.     switch ( ReadPointerType() ) {
  821.     case eNullPointer:
  822.         _TRACE("CObjectIStream::ReadPointer: null");
  823.         return pair<TObjectPtr, TTypeInfo>(0, declaredType);
  824.     case eObjectPointer:
  825.         {
  826.             _TRACE("CObjectIStream::ReadPointer: @...");
  827.             TObjectIndex index = ReadObjectPointer();
  828.             _TRACE("CObjectIStream::ReadPointer: @" << index);
  829.             const CReadObjectInfo& info = GetRegisteredObject(index);
  830.             objectType = info.GetTypeInfo();
  831.             objectPtr = info.GetObjectPtr();
  832.             if ( !objectPtr ) {
  833.                 ThrowError(fFormatError,
  834.                     "invalid reference to skipped object: object ptr is NULL");
  835.             }
  836.             break;
  837.         }
  838.     case eThisPointer:
  839.         {
  840.             _TRACE("CObjectIStream::ReadPointer: new");
  841.             objectPtr = declaredType->Create();
  842.             CRef<CObject> ref;
  843.             if ( declaredType->IsCObject() )
  844.                 ref.Reset(static_cast<CObject*>(objectPtr));
  845.             RegisterObject(objectPtr, declaredType);
  846.             ReadObject(objectPtr, declaredType);
  847.             if ( declaredType->IsCObject() )
  848.                 ref.Release();
  849.             return make_pair(objectPtr, declaredType);
  850.         }
  851.     case eOtherPointer:
  852.         {
  853.             _TRACE("CObjectIStream::ReadPointer: new...");
  854.             string className = ReadOtherPointer();
  855.             _TRACE("CObjectIStream::ReadPointer: new " << className);
  856.             objectType = MapType(className);
  858.             BEGIN_OBJECT_FRAME2(eFrameNamed, objectType);
  859.                 
  860.             objectPtr = objectType->Create();
  861.             CRef<CObject> ref;
  862.             if ( declaredType->IsCObject() )
  863.                 ref.Reset(static_cast<CObject*>(objectPtr));
  864.             RegisterObject(objectPtr, objectType);
  865.             ReadObject(objectPtr, objectType);
  866.             if ( declaredType->IsCObject() )
  867.                 ref.Release();
  868.                 
  869.             END_OBJECT_FRAME();
  871.             ReadOtherPointerEnd();
  872.             break;
  873.         }
  874.     default:
  875.         ThrowError(fFormatError,"illegal pointer type");
  876.         objectPtr = 0;
  877.         objectType = 0;
  878.         break;
  879.     }
  880.     while ( objectType != declaredType ) {
  881.         // try to check parent class pointer
  882.         if ( objectType->GetTypeFamily() != eTypeFamilyClass ) {
  883.             ThrowError(fFormatError,"incompatible member type");
  884.         }
  885.         const CClassTypeInfo* parentClass =
  886.             CTypeConverter<CClassTypeInfo>::SafeCast(objectType)->GetParentClassInfo();
  887.         if ( parentClass ) {
  888.             objectType = parentClass;
  889.         }
  890.         else {
  891.             ThrowError(fFormatError,"incompatible member type");
  892.         }
  893.     }
  894.     return make_pair(objectPtr, objectType);
  895. }
  897. void CObjectIStream::ReadOtherPointerEnd(void)
  898. {
  899. }
  901. void CObjectIStream::SkipExternalObject(TTypeInfo typeInfo)
  902. {
  903.     _TRACE("CObjectIStream::SkipExternalObject("<<typeInfo->GetName()<<")");
  904.     RegisterObject(typeInfo);
  905.     SkipObject(typeInfo);
  906. }
  908. void CObjectIStream::SkipPointer(TTypeInfo declaredType)
  909. {
  910.     _TRACE("CObjectIStream::SkipPointer("<<declaredType->GetName()<<")");
  911.     switch ( ReadPointerType() ) {
  912.     case eNullPointer:
  913.         _TRACE("CObjectIStream::SkipPointer: null");
  914.         return;
  915.     case eObjectPointer:
  916.         {
  917.             _TRACE("CObjectIStream::SkipPointer: @...");
  918.             TObjectIndex index = ReadObjectPointer();
  919.             _TRACE("CObjectIStream::SkipPointer: @" << index);
  920.             GetRegisteredObject(index);
  921.             break;
  922.         }
  923.     case eThisPointer:
  924.         {
  925.             _TRACE("CObjectIStream::ReadPointer: new");
  926.             RegisterObject(declaredType);
  927.             SkipObject(declaredType);
  928.             break;
  929.         }
  930.     case eOtherPointer:
  931.         {
  932.             _TRACE("CObjectIStream::ReadPointer: new...");
  933.             string className = ReadOtherPointer();
  934.             _TRACE("CObjectIStream::ReadPointer: new " << className);
  935.             TTypeInfo typeInfo = MapType(className);
  936.             BEGIN_OBJECT_FRAME2(eFrameNamed, typeInfo);
  937.                 
  938.             RegisterObject(typeInfo);
  939.             SkipObject(typeInfo);
  941.             END_OBJECT_FRAME();
  942.             ReadOtherPointerEnd();
  943.             break;
  944.         }
  945.     default:
  946.         ThrowError(fFormatError,"illegal pointer type");
  947.     }
  948. }
  950. void CObjectIStream::BeginNamedType(TTypeInfo /*namedTypeInfo*/)
  951. {
  952. }
  954. void CObjectIStream::EndNamedType(void)
  955. {
  956. }
  958. void CObjectIStream::ReadNamedType(TTypeInfo
  959. #ifndef VIRTUAL_MID_LEVEL_IO
  960.                                    namedTypeInfo
  961. #endif
  962.                                    ,
  963.                                    TTypeInfo typeInfo, TObjectPtr object)
  964. {
  965. #ifndef VIRTUAL_MID_LEVEL_IO
  966.     BEGIN_OBJECT_FRAME2(eFrameNamed, namedTypeInfo);
  967.     BeginNamedType(namedTypeInfo);
  968. #endif
  969.     ReadObject(object, typeInfo);
  970. #ifndef VIRTUAL_MID_LEVEL_IO
  971.     EndNamedType();
  972.     END_OBJECT_FRAME();
  973. #endif
  974. }
  976. void CObjectIStream::SkipNamedType(TTypeInfo namedTypeInfo,
  977.                                    TTypeInfo typeInfo)
  978. {
  979.     BEGIN_OBJECT_FRAME2(eFrameNamed, namedTypeInfo);
  980.     BeginNamedType(namedTypeInfo);
  982.     SkipObject(typeInfo);
  984.     EndNamedType();
  985.     END_OBJECT_FRAME();
  986. }
  988. void CObjectIStream::EndContainerElement(void)
  989. {
  990. }
  992. void CObjectIStream::ReadContainer(const CContainerTypeInfo* containerType,
  993.                                    TObjectPtr containerPtr)
  994. {
  995.     BEGIN_OBJECT_FRAME2(eFrameArray, containerType);
  996.     BeginContainer(containerType);
  998.     TTypeInfo elementType = containerType->GetElementType();
  999.     BEGIN_OBJECT_FRAME2(eFrameArrayElement, elementType);
  1001.     CContainerTypeInfo::CIterator iter;
  1002.     bool old_element = containerType->InitIterator(iter, containerPtr);
  1003.     while ( BeginContainerElement(elementType) ) {
  1004.         if ( old_element ) {
  1005.             elementType->ReadData(*this, containerType->GetElementPtr(iter));
  1006.             old_element = containerType->NextElement(iter);
  1007.         }
  1008.         else {
  1009.             containerType->AddElement(containerPtr, *this);
  1010.         }
  1011.         EndContainerElement();
  1012.     }
  1013.     if ( old_element ) {
  1014.         containerType->EraseAllElements(iter);
  1015.     }
  1017.     END_OBJECT_FRAME();
  1019.     EndContainer();
  1020.     END_OBJECT_FRAME();
  1021. }
  1023. void CObjectIStream::SkipContainer(const CContainerTypeInfo* containerType)
  1024. {
  1025.     BEGIN_OBJECT_FRAME2(eFrameArray, containerType);
  1026.     BeginContainer(containerType);
  1028.     TTypeInfo elementType = containerType->GetElementType();
  1029.     BEGIN_OBJECT_FRAME2(eFrameArrayElement, elementType);
  1031.     while ( BeginContainerElement(elementType) ) {
  1032.         SkipObject(elementType);
  1033.         EndContainerElement();
  1034.     }
  1036.     END_OBJECT_FRAME();
  1038.     EndContainer();
  1039.     END_OBJECT_FRAME();
  1040. }
  1042. void CObjectIStream::EndClass(void)
  1043. {
  1044. }
  1046. void CObjectIStream::EndClassMember(void)
  1047. {
  1048. }
  1050. void CObjectIStream::ReadClassRandom(const CClassTypeInfo* classType,
  1051.                                      TObjectPtr classPtr)
  1052. {
  1053.     BEGIN_OBJECT_FRAME2(eFrameClass, classType);
  1054.     BeginClass(classType);
  1056.     ReadClassRandomContentsBegin(classType);
  1058.     TMemberIndex index;
  1059.     while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
  1061.         ReadClassRandomContentsMember(classPtr);
  1062.         
  1063.         EndClassMember();
  1064.     }
  1066.     ReadClassRandomContentsEnd();
  1067.     
  1068.     EndClass();
  1069.     END_OBJECT_FRAME();
  1070. }
  1072. void CObjectIStream::ReadClassSequential(const CClassTypeInfo* classType,
  1073.                                          TObjectPtr classPtr)
  1074. {
  1075.     TMemberIndex prevIndex = kInvalidMember;
  1076.     BEGIN_OBJECT_FRAME2(eFrameClass, classType);
  1077.     BeginClass(classType);
  1078.     
  1079.     ReadClassSequentialContentsBegin(classType);
  1081.     TMemberIndex index;
  1082.     while ( (index = BeginClassMember(classType, *pos)) != kInvalidMember ) {
  1084.         if ((prevIndex != kInvalidMember) && (prevIndex > index)) {
  1085.             const CMemberInfo *mem_info = classType->GetMemberInfo(index);
  1086.             if (mem_info->GetId().HaveNoPrefix()) {
  1087.                 UndoClassMember();
  1088.                 break;
  1089.             }
  1090.         }
  1091.         prevIndex = index;
  1093.         ReadClassSequentialContentsMember(classPtr);
  1095.         EndClassMember();
  1096.     }
  1098.     ReadClassSequentialContentsEnd(classPtr);
  1099.     
  1100.     EndClass();
  1101.     END_OBJECT_FRAME();
  1102. }
  1104. void CObjectIStream::SkipClassRandom(const CClassTypeInfo* classType)
  1105. {
  1106.     BEGIN_OBJECT_FRAME2(eFrameClass, classType);
  1107.     BeginClass(classType);
  1108.     
  1109.     SkipClassRandomContentsBegin(classType);
  1111.     TMemberIndex index;
  1112.     while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
  1114.         SkipClassRandomContentsMember();
  1116.         EndClassMember();
  1117.     }
  1119.     SkipClassRandomContentsEnd();
  1120.     
  1121.     EndClass();
  1122.     END_OBJECT_FRAME();
  1123. }
  1125. void CObjectIStream::SkipClassSequential(const CClassTypeInfo* classType)
  1126. {
  1127.     BEGIN_OBJECT_FRAME2(eFrameClass, classType);
  1128.     BeginClass(classType);
  1129.     
  1130.     SkipClassSequentialContentsBegin(classType);
  1132.     TMemberIndex index;
  1133.     while ( (index = BeginClassMember(classType, *pos)) != kInvalidMember ) {
  1135.         SkipClassSequentialContentsMember();
  1137.         EndClassMember();
  1138.     }
  1140.     SkipClassSequentialContentsEnd();
  1141.     
  1142.     EndClass();
  1143.     END_OBJECT_FRAME();
  1144. }
  1146. void CObjectIStream::BeginChoice(const CChoiceTypeInfo* /*choiceType*/)
  1147. {
  1148. }
  1149. void CObjectIStream::EndChoice(void)
  1150. {
  1151. }
  1152. void CObjectIStream::EndChoiceVariant(void)
  1153. {
  1154. }
  1156. void CObjectIStream::ReadChoice(const CChoiceTypeInfo* choiceType,
  1157.                                 TObjectPtr choicePtr)
  1158. {
  1159.     BEGIN_OBJECT_FRAME2(eFrameChoice, choiceType);
  1160.     BeginChoice(choiceType);
  1161.     BEGIN_OBJECT_FRAME(eFrameChoiceVariant);
  1162.     TMemberIndex index = BeginChoiceVariant(choiceType);
  1163.     _ASSERT(index != kInvalidMember);
  1165.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1166.     SetTopMemberId(variantInfo->GetId());
  1168.     variantInfo->ReadVariant(*this, choicePtr);
  1170.     EndChoiceVariant();
  1171.     END_OBJECT_FRAME();
  1172.     EndChoice();
  1173.     END_OBJECT_FRAME();
  1174. }
  1176. void CObjectIStream::SkipChoice(const CChoiceTypeInfo* choiceType)
  1177. {
  1178.     BEGIN_OBJECT_FRAME2(eFrameChoice, choiceType);
  1179.     BeginChoice(choiceType);
  1180.     BEGIN_OBJECT_FRAME(eFrameChoiceVariant);
  1181.     TMemberIndex index = BeginChoiceVariant(choiceType);
  1182.     if ( index == kInvalidMember )
  1183.         ThrowError(fFormatError,"choice variant id expected");
  1185.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1186.     SetTopMemberId(variantInfo->GetId());
  1188.     variantInfo->SkipVariant(*this);
  1190.     EndChoiceVariant();
  1191.     END_OBJECT_FRAME();
  1192.     EndChoice();
  1193.     END_OBJECT_FRAME();
  1194. }
  1196. void CObjectIStream::ReadAlias(const CAliasTypeInfo* aliasType,
  1197.                                TObjectPtr aliasPtr)
  1198. {
  1199.     ReadNamedType(aliasType, aliasType->GetPointedType(),
  1200.         aliasType->GetDataPtr(aliasPtr));
  1201. }
  1203. void CObjectIStream::SkipAlias(const CAliasTypeInfo* aliasType)
  1204. {
  1205.     SkipNamedType(aliasType, aliasType->GetPointedType());
  1206. }
  1208. ///////////////////////////////////////////////////////////////////////
  1209. //
  1210. // CObjectIStream::ByteBlock
  1211. //
  1213. CObjectIStream::ByteBlock::ByteBlock(CObjectIStream& in)
  1214.     : m_Stream(in), m_KnownLength(false), m_Ended(false), m_Length(1)
  1215. {
  1216.     in.BeginBytes(*this);
  1217. }
  1219. CObjectIStream::ByteBlock::~ByteBlock(void)
  1220. {
  1221.     if ( !m_Ended ) {
  1222.         try {
  1223.             GetStream().Unended("byte block not fully read");
  1224.         }
  1225.         catch (...) {
  1226.             ERR_POST("unended byte block");
  1227.         }
  1228.     }
  1229. }
  1231. void CObjectIStream::ByteBlock::End(void)
  1232. {
  1233.     _ASSERT(!m_Ended);
  1234.     if ( m_Length == 0 ) {
  1235.         GetStream().EndBytes(*this);
  1236.         m_Ended = true;
  1237.     }
  1238. }
  1240. size_t CObjectIStream::ByteBlock::Read(void* dst, size_t needLength,
  1241.                                        bool forceLength)
  1242. {
  1243.     size_t length;
  1244.     if ( KnownLength() ) {
  1245.         if ( m_Length < needLength )
  1246.             length = m_Length;
  1247.         else
  1248.             length = needLength;
  1249.     }
  1250.     else {
  1251.         if ( m_Length == 0 )
  1252.             length = 0;
  1253.         else
  1254.             length = needLength;
  1255.     }
  1256.     
  1257.     if ( length == 0 ) {
  1258.         if ( forceLength && needLength != 0 )
  1259.             GetStream().ThrowError(fReadError, "read fault");
  1260.         return 0;
  1261.     }
  1263.     length = GetStream().ReadBytes(*this, static_cast<char*>(dst), length);
  1264.     if ( KnownLength() )
  1265.         m_Length -= length;
  1266.     if ( forceLength && needLength != length )
  1267.         GetStream().ThrowError(fReadError, "read fault");
  1268.     return length;
  1269. }
  1271. ///////////////////////////////////////////////////////////////////////
  1272. //
  1273. // CObjectIStream::CharBlock
  1274. //
  1276. CObjectIStream::CharBlock::CharBlock(CObjectIStream& in)
  1277.     : m_Stream(in), m_KnownLength(false), m_Ended(false), m_Length(1)
  1278. {
  1279.     in.BeginChars(*this);
  1280. }
  1282. CObjectIStream::CharBlock::~CharBlock(void)
  1283. {
  1284.     if ( !m_Ended ) {
  1285.         try {
  1286.             GetStream().Unended("char block not fully read");
  1287.         }
  1288.         catch (...) {
  1289.             ERR_POST("unended char block");
  1290.         }
  1291.     }
  1292. }
  1294. void CObjectIStream::CharBlock::End(void)
  1295. {
  1296.     _ASSERT(!m_Ended);
  1297.     if ( m_Length == 0 ) {
  1298.         GetStream().EndChars(*this);
  1299.         m_Ended = true;
  1300.     }
  1301. }
  1303. size_t CObjectIStream::CharBlock::Read(char* dst, size_t needLength,
  1304.                                        bool forceLength)
  1305. {
  1306.     size_t length;
  1307.     if ( KnownLength() ) {
  1308.         if ( m_Length < needLength )
  1309.             length = m_Length;
  1310.         else
  1311.             length = needLength;
  1312.     }
  1313.     else {
  1314.         if ( m_Length == 0 )
  1315.             length = 0;
  1316.         else
  1317.             length = needLength;
  1318.     }
  1319.     
  1320.     if ( length == 0 ) {
  1321.         if ( forceLength && needLength != 0 )
  1322.             GetStream().ThrowError(fReadError, "read fault");
  1323.         return 0;
  1324.     }
  1326.     length = GetStream().ReadChars(*this, dst, length);
  1327.     if ( KnownLength() )
  1328.         m_Length -= length;
  1329.     if ( forceLength && needLength != length )
  1330.         GetStream().ThrowError(fReadError, "read fault");
  1331.     return length;
  1332. }
  1335. void CObjectIStream::EndBytes(const ByteBlock& /*b*/)
  1336. {
  1337. }
  1339. void CObjectIStream::EndChars(const CharBlock& /*b*/)
  1340. {
  1341. }
  1343. Int1 CObjectIStream::ReadInt1(void)
  1344. {
  1345.     Int4 data = ReadInt4();
  1346.     Int1 ret = Int1(data);
  1347.     if ( ret != data )
  1348.         ThrowError(fOverflow, "integer overflow");
  1349.     return ret;
  1350. }
  1352. Uint1 CObjectIStream::ReadUint1(void)
  1353. {
  1354.     Uint4 data = ReadUint4();
  1355.     Uint1 ret = Uint1(data);
  1356.     if ( ret != data )
  1357.         ThrowError(fOverflow, "integer overflow");
  1358.     return ret;
  1359. }
  1361. Int2 CObjectIStream::ReadInt2(void)
  1362. {
  1363.     Int4 data = ReadInt4();
  1364.     Int2 ret = Int2(data);
  1365.     if ( ret != data )
  1366.         ThrowError(fOverflow, "integer overflow");
  1367.     return ret;
  1368. }
  1370. Uint2 CObjectIStream::ReadUint2(void)
  1371. {
  1372.     Uint4 data = ReadUint4();
  1373.     Uint2 ret = Uint2(data);
  1374.     if ( ret != data )
  1375.         ThrowError(fOverflow, "integer overflow");
  1376.     return ret;
  1377. }
  1379. Int4 CObjectIStream::ReadInt4(void)
  1380. {
  1381.     Int8 data = ReadInt8();
  1382.     Int4 ret = Int4(data);
  1383.     if ( ret != data )
  1384.         ThrowError(fOverflow, "integer overflow");
  1385.     return ret;
  1386. }
  1388. Uint4 CObjectIStream::ReadUint4(void)
  1389. {
  1390.     Uint8 data = ReadUint8();
  1391.     Uint4 ret = Uint4(data);
  1392.     if ( ret != data )
  1393.         ThrowError(fOverflow, "integer overflow");
  1394.     return ret;
  1395. }
  1397. float CObjectIStream::ReadFloat(void)
  1398. {
  1399.     double data = ReadDouble();
  1400. #if defined(FLT_MIN) && defined(FLT_MAX)
  1401.     if ( data < FLT_MIN || data > FLT_MAX )
  1402.         ThrowError(fOverflow, "float overflow");
  1403. #endif
  1404.     return float(data);
  1405. }
  1407. #if SIZEOF_LONG_DOUBLE != 0
  1408. long double CObjectIStream::ReadLDouble(void)
  1409. {
  1410.     return ReadDouble();
  1411. }
  1412. #endif
  1414. char* CObjectIStream::ReadCString(void)
  1415. {
  1416.     string s;
  1417.     ReadString(s);
  1418.     return strdup(s.c_str());
  1419. }
  1421. void CObjectIStream::ReadStringStore(string& s)
  1422. {
  1423.     ReadString(s);
  1424. }
  1426. void CObjectIStream::ReadString(string& s,
  1427.                                 CPackString& pack_string,
  1428.                                 EStringType type)
  1429. {
  1430.     ReadString(s);
  1431.     pack_string.Pack(s);
  1432. }
  1434. void CObjectIStream::SkipInt1(void)
  1435. {
  1436.     SkipSNumber();
  1437. }
  1439. void CObjectIStream::SkipUint1(void)
  1440. {
  1441.     SkipUNumber();
  1442. }
  1444. void CObjectIStream::SkipInt2(void)
  1445. {
  1446.     SkipSNumber();
  1447. }
  1449. void CObjectIStream::SkipUint2(void)
  1450. {
  1451.     SkipUNumber();
  1452. }
  1454. void CObjectIStream::SkipInt4(void)
  1455. {
  1456.     SkipSNumber();
  1457. }
  1459. void CObjectIStream::SkipUint4(void)
  1460. {
  1461.     SkipUNumber();
  1462. }
  1464. void CObjectIStream::SkipInt8(void)
  1465. {
  1466.     SkipSNumber();
  1467. }
  1469. void CObjectIStream::SkipUint8(void)
  1470. {
  1471.     SkipUNumber();
  1472. }
  1474. void CObjectIStream::SkipFloat(void)
  1475. {
  1476.     SkipFNumber();
  1477. }
  1479. void CObjectIStream::SkipDouble(void)
  1480. {
  1481.     SkipFNumber();
  1482. }
  1484. #if SIZEOF_LONG_DOUBLE != 0
  1485. void CObjectIStream::SkipLDouble(void)
  1486. {
  1487.     SkipFNumber();
  1488. }
  1489. #endif
  1491. void CObjectIStream::SkipCString(void)
  1492. {
  1493.     SkipString();
  1494. }
  1496. void CObjectIStream::SkipStringStore(void)
  1497. {
  1498.     SkipString();
  1499. }
  1502. char ReplaceVisibleChar(char c, EFixNonPrint fix_method, size_t at_line)
  1503. {
  1504.     _ASSERT(fix_method != eFNP_Allow);
  1505.     if ( fix_method != eFNP_Replace ) {
  1506.         string message = "Bad char in VisibleString" +
  1507.             ((at_line > 0) ?
  1508.              " starting at line " + NStr::UIntToString(at_line) :
  1509.              string("")) + ": " + NStr::IntToString(int(c) & 0xff);
  1510.         switch (fix_method) {
  1511.         case eFNP_ReplaceAndWarn:
  1512.             CNcbiDiag(eDiag_Error, eDPF_Default) << message << Endm;
  1513.             break;
  1514.         case eFNP_Throw:
  1515.             NCBI_THROW(CSerialException,eFormatError,message);
  1516.         case eFNP_Abort:
  1517.             CNcbiDiag(eDiag_Fatal, eDPF_Default) << message << Endm;
  1518.             break;
  1519.         default:
  1520.             break;
  1521.         }
  1522.     }
  1523.     return '#';
  1524. }
  1527. END_NCBI_SCOPE
  1529. /*
  1530. * $Log: objistr.cpp,v $
  1531. * Revision 1000.4  2004/06/01 19:40:54  gouriano
  1532. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.129
  1533. *
  1534. * Revision 1.129  2004/05/17 21:03:03  gorelenk
  1535. * Added include of PCH ncbi_pch.hpp
  1536. *
  1537. * Revision 1.128  2004/03/23 15:39:23  gouriano
  1538. * Added setup options for skipping unknown data members
  1539. *
  1540. * Revision 1.127  2004/03/18 20:18:05  gouriano
  1541. * remove redundant diagnostic message
  1542. *
  1543. * Revision 1.126  2004/03/05 20:29:38  gouriano
  1544. * make it possible to skip unknown data fields
  1545. *
  1546. * Revision 1.125  2004/02/09 18:22:34  gouriano
  1547. * enforced checking environment vars when setting initialization
  1548. * verification parameters
  1549. *
  1550. * Revision 1.124  2004/01/22 20:46:41  gouriano
  1551. * Added new exception error code (eMissingValue)
  1552. *
  1553. * Revision 1.123  2004/01/05 14:25:20  gouriano
  1554. * Added possibility to set serialization hooks by stack path
  1555. *
  1556. * Revision 1.122  2003/12/31 21:02:58  gouriano
  1557. * added possibility to seek (when possible) in CObjectIStream
  1558. *
  1559. * Revision 1.121  2003/11/26 20:04:46  vasilche
  1560. * Method put in wrong file.
  1561. *
  1562. * Revision 1.120  2003/11/26 19:59:39  vasilche
  1563. * GetPosition() and GetDataFormat() methods now are implemented
  1564. * in parent classes CObjectIStream and CObjectOStream to avoid
  1565. * pure virtual method call in destructors.
  1566. *
  1567. * Revision 1.119  2003/11/24 14:10:05  grichenk
  1568. * Changed base class for CAliasTypeInfo to CPointerTypeInfo
  1569. *
  1570. * Revision 1.118  2003/11/13 14:07:38  gouriano
  1571. * Elaborated data verification on read/write/get to enable skipping mandatory class data members
  1572. *
  1573. * Revision 1.117  2003/10/24 15:54:28  grichenk
  1574. * Removed or blocked exceptions in destructors
  1575. *
  1576. * Revision 1.116  2003/10/21 21:08:46  grichenk
  1577. * Fixed aliases-related bug in XML stream
  1578. *
  1579. * Revision 1.115  2003/09/30 16:10:37  vasilche
  1580. * Added one more variant of object streams creation.
  1581. *
  1582. * Revision 1.114  2003/09/16 14:48:36  gouriano
  1583. * Enhanced AnyContent objects to support XML namespaces and attribute info items.
  1584. *
  1585. * Revision 1.113  2003/09/10 20:56:45  gouriano
  1586. * added possibility to ignore missing mandatory members on reading
  1587. *
  1588. * Revision 1.112  2003/08/26 19:25:58  gouriano
  1589. * added possibility to discard a member of an STL container
  1590. * (from a read hook)
  1591. *
  1592. * Revision 1.111  2003/08/25 15:59:09  gouriano
  1593. * added possibility to use namespaces in XML i/o streams
  1594. *
  1595. * Revision 1.110  2003/08/19 18:32:38  vasilche
  1596. * Optimized reading and writing strings.
  1597. * Avoid string reallocation when checking char values.
  1598. * Try to reuse old string data when string reference counting is not working.
  1599. *
  1600. * Revision 1.109  2003/08/14 20:03:58  vasilche
  1601. * Avoid memory reallocation when reading over preallocated object.
  1602. * Simplified CContainerTypeInfo iterators interface.
  1603. *
  1604. * Revision 1.108  2003/07/29 18:47:47  vasilche
  1605. * Fixed thread safeness of object stream hooks.
  1606. *
  1607. * Revision 1.107  2003/05/20 14:25:22  vasilche
  1608. * Removed warnings on WorkShop.
  1609. *
  1610. * Revision 1.106  2003/05/16 18:02:18  gouriano
  1611. * revised exception error messages
  1612. *
  1613. * Revision 1.105  2003/05/15 17:44:38  gouriano
  1614. * added GetStreamOffset method
  1615. *
  1616. * Revision 1.104  2003/05/05 20:09:10  gouriano
  1617. * fixed "skipping" an object
  1618. *
  1619. * Revision 1.103  2003/03/26 16:14:22  vasilche
  1620. * Removed TAB symbols. Some formatting.
  1621. *
  1622. * Revision 1.102  2003/03/10 18:54:26  gouriano
  1623. * use new structured exceptions (based on CException)
  1624. *
  1625. * Revision 1.101  2003/02/10 20:09:43  vasilche
  1626. * Restored _TRACE in CObjectIStream.
  1627. *
  1628. * Revision 1.100  2003/01/28 15:26:14  vasilche
  1629. * Added low level CObjectIStream::EndDelayBuffer(void);
  1630. *
  1631. * Revision 1.99  2003/01/22 18:53:28  gouriano
  1632. * corrected stream destruction
  1633. *
  1634. * Revision 1.98  2002/12/13 21:50:42  gouriano
  1635. * corrected reading of choices
  1636. *
  1637. * Revision 1.97  2002/11/26 22:12:02  gouriano
  1638. * corrected ReadClassSequential
  1639. *
  1640. * Revision 1.96  2002/11/14 20:58:19  gouriano
  1641. * added BeginChoice/EndChoice methods
  1642. *
  1643. * Revision 1.95  2002/11/04 21:29:20  grichenk
  1644. * Fixed usage of const CRef<> and CRef<> constructor
  1645. *
  1646. * Revision 1.94  2002/10/25 14:49:27  vasilche
  1647. * NCBI C Toolkit compatibility code extracted to libxcser library.
  1648. * Serial streams flags names were renamed to fXxx.
  1649. *
  1650. * Names of flags
  1651. *
  1652. * Revision 1.93  2002/10/22 20:22:13  gouriano
  1653. * undo the prev change, but reduce severity of the ERR_POST to Info
  1654. *
  1655. * Revision 1.92  2002/10/22 19:02:59  gouriano
  1656. * commented out ERR_POST in CObjectIStream::SetFailFlags
  1657. *
  1658. * Revision 1.91  2002/10/15 13:48:00  gouriano
  1659. * modified to handle "standard" (generated from DTD) XML i/o
  1660. *
  1661. * Revision 1.90  2002/09/19 20:05:44  vasilche
  1662. * Safe initialization of static mutexes
  1663. *
  1664. * Revision 1.89  2002/09/19 14:00:38  grichenk
  1665. * Implemented CObjectHookGuard for write and copy hooks
  1666. * Added DefaultRead/Write/Copy methods to base hook classes
  1667. *
  1668. * Revision 1.88  2002/09/09 18:14:02  grichenk
  1669. * Added CObjectHookGuard class.
  1670. * Added methods to be used by hooks for data
  1671. * reading and skipping.
  1672. *
  1673. * Revision 1.87  2002/08/30 16:22:21  vasilche
  1674. * Removed excessive _TRACEs
  1675. *
  1676. * Revision 1.86  2001/10/22 15:17:41  grichenk
  1677. * Protected objects being read from destruction by temporary CRef<>-s
  1678. *
  1679. * Revision 1.85  2001/10/17 20:41:23  grichenk
  1680. * Added CObjectOStream::CharBlock class
  1681. *
  1682. * Revision 1.84  2001/10/15 23:30:10  vakatov
  1683. * Get rid of extraneous "break;" after "throw"
  1684. *
  1685. * Revision 1.83  2001/07/30 14:42:46  lavr
  1686. * eDiag_Trace and eDiag_Fatal always print as much as possible
  1687. *
  1688. * Revision 1.82  2001/07/25 19:14:25  grichenk
  1689. * Implemented functions for reading/writing parent classes
  1690. *
  1691. * Revision 1.81  2001/07/17 14:52:48  kholodov
  1692. * Fixed: replaced int argument by size_t in CheckVisibleChar() and
  1693. * ReplaceVisibleChar to avoid truncation in 64 bit mode.
  1694. *
  1695. * Revision 1.80  2001/07/16 16:24:08  grichenk
  1696. * Added "case eFNP_Allow:" to ReplaceVisibleChar()
  1697. *
  1698. * Revision 1.79  2001/06/07 17:12:50  grichenk
  1699. * Redesigned checking and substitution of non-printable characters
  1700. * in VisibleString
  1701. *
  1702. * Revision 1.78  2001/05/17 15:07:08  lavr
  1703. * Typos corrected
  1704. *
  1705. * Revision 1.77  2001/05/16 17:55:39  grichenk
  1706. * Redesigned support for non-blocking stream read operations
  1707. *
  1708. * Revision 1.76  2001/05/11 20:41:17  grichenk
  1709. * Added support for non-blocking stream reading
  1710. *
  1711. * Revision 1.75  2001/01/22 23:11:22  vakatov
  1712. * CObjectIStream::{Read,Skip}ClassSequential() -- use curr.member "pos"
  1713. *
  1714. * Revision 1.74  2001/01/05 20:10:50  vasilche
  1715. * CByteSource, CIStrBuffer, COStrBuffer, CLightString, CChecksum, CWeakMap
  1716. * were moved to util.
  1717. *
  1718. * Revision 1.73  2001/01/05 13:57:31  vasilche
  1719. * Fixed overloaded method ambiguity on Mac.
  1720. *
  1721. * Revision 1.72  2000/12/26 22:24:10  vasilche
  1722. * Fixed errors of compilation on Mac.
  1723. *
  1724. * Revision 1.71  2000/12/26 17:26:16  vasilche
  1725. * Added one more Read() interface method.
  1726. *
  1727. * Revision 1.70  2000/12/15 21:29:01  vasilche
  1728. * Moved some typedefs/enums from corelib/ncbistd.hpp.
  1729. * Added flags to CObjectIStream/CObjectOStream: eFlagAllowNonAsciiChars.
  1730. * TByte typedef replaced by Uint1.
  1731. *
  1732. * Revision 1.69  2000/12/15 15:38:43  vasilche
  1733. * Added support of Int8 and long double.
  1734. * Enum values now have type Int4 instead of long.
  1735. *
  1736. * Revision 1.68  2000/11/01 20:38:37  vasilche
  1737. * Removed ECanDelete enum and related constructors.
  1738. *
  1739. * Revision 1.67  2000/10/20 19:29:36  vasilche
  1740. * Adapted for MSVC which doesn't like explicit operator templates.
  1741. *
  1742. * Revision 1.66  2000/10/20 15:51:40  vasilche
  1743. * Fixed data error processing.
  1744. * Added interface for constructing container objects directly into output stream.
  1745. * object.hpp, object.inl and object.cpp were split to
  1746. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  1747. *
  1748. * Revision 1.65  2000/10/17 18:45:34  vasilche
  1749. * Added possibility to turn off object cross reference detection in
  1750. * CObjectIStream and CObjectOStream.
  1751. *
  1752. * Revision 1.64  2000/10/04 19:18:58  vasilche
  1753. * Fixed processing floating point data.
  1754. *
  1755. * Revision 1.63  2000/10/03 17:22:43  vasilche
  1756. * Reduced header dependency.
  1757. * Reduced size of debug libraries on WorkShop by 3 times.
  1758. * Fixed tag allocation for parent classes.
  1759. * Fixed CObject allocation/deallocation in streams.
  1760. * Moved instantiation of several templates in separate source file.
  1761. *
  1762. * Revision 1.62  2000/09/29 16:18:22  vasilche
  1763. * Fixed binary format encoding/decoding on 64 bit compulers.
  1764. * Implemented CWeakMap<> for automatic cleaning map entries.
  1765. * Added cleaning local hooks via CWeakMap<>.
  1766. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  1767. * Added some user interface methods to CObjectIStream, CObjectOStream and
  1768. * CObjectStreamCopier.
  1769. *
  1770. * Revision 1.61  2000/09/26 17:38:22  vasilche
  1771. * Fixed incomplete choiceptr implementation.
  1772. * Removed temporary comments.
  1773. *
  1774. * Revision 1.60  2000/09/18 20:00:23  vasilche
  1775. * Separated CVariantInfo and CMemberInfo.
  1776. * Implemented copy hooks.
  1777. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  1778. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  1779. *
  1780. * Revision 1.59  2000/09/01 13:16:17  vasilche
  1781. * Implemented class/container/choice iterators.
  1782. * Implemented CObjectStreamCopier for copying data without loading into memory.
  1783. *
  1784. * Revision 1.58  2000/08/15 19:44:48  vasilche
  1785. * Added Read/Write hooks:
  1786. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  1787. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  1788. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  1789. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  1790. *
  1791. * Revision 1.57  2000/07/03 18:42:44  vasilche
  1792. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  1793. * Reduced header dependency.
  1794. *
  1795. * Revision 1.56  2000/06/16 20:01:26  vasilche
  1796. * Avoid use of unexpected_exception() which is unimplemented on Mac.
  1797. *
  1798. * Revision 1.55  2000/06/16 18:04:11  thiessen
  1799. * avoid uncaught_exception() unimplemented on Mac/CodeWarrior
  1800. *
  1801. * Revision 1.54  2000/06/16 16:31:19  vasilche
  1802. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  1803. *
  1804. * Revision 1.53  2000/06/07 19:45:58  vasilche
  1805. * Some code cleaning.
  1806. * Macros renaming in more clear way.
  1807. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  1808. *
  1809. * Revision 1.52  2000/06/01 19:07:03  vasilche
  1810. * Added parsing of XML data.
  1811. *
  1812. * Revision 1.51  2000/05/24 20:08:47  vasilche
  1813. * Implemented XML dump.
  1814. *
  1815. * Revision 1.50  2000/05/09 16:38:38  vasilche
  1816. * CObject::GetTypeInfo now moved to CObjectGetTypeInfo::GetTypeInfo to reduce possible errors.
  1817. * Added write context to CObjectOStream.
  1818. * Inlined most of methods of helping class Member, Block, ByteBlock etc.
  1819. *
  1820. * Revision 1.49  2000/05/04 16:22:19  vasilche
  1821. * Cleaned and optimized blocks and members.
  1822. *
  1823. * Revision 1.48  2000/05/03 14:38:14  vasilche
  1824. * SERIAL: added support for delayed reading to generated classes.
  1825. * DATATOOL: added code generation for delayed reading.
  1826. *
  1827. * Revision 1.47  2000/04/28 16:58:12  vasilche
  1828. * Added classes CByteSource and CByteSourceReader for generic reading.
  1829. * Added delayed reading of choice variants.
  1830. *
  1831. * Revision 1.46  2000/04/13 14:50:26  vasilche
  1832. * Added CObjectIStream::Open() and CObjectOStream::Open() for easier use.
  1833. *
  1834. * Revision 1.45  2000/04/06 16:10:59  vasilche
  1835. * Fixed bug with iterators in choices.
  1836. * Removed unneeded calls to ReadExternalObject/WriteExternalObject.
  1837. * Added output buffering to text ASN.1 data.
  1838. *
  1839. * Revision 1.44  2000/03/29 15:55:27  vasilche
  1840. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  1841. * Added generic iterators by class -
  1842. *  CTypeIterator<class>, CTypeConstIterator<class>,
  1843. *  CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  1844. *  CObjectsIterator and CObjectsConstIterator.
  1845. *
  1846. * Revision 1.43  2000/03/14 14:42:30  vasilche
  1847. * Fixed error reporting.
  1848. *
  1849. * Revision 1.42  2000/03/10 17:59:20  vasilche
  1850. * Fixed error reporting.
  1851. * Added EOF bug workaround on MIPSpro compiler (not finished).
  1852. *
  1853. * Revision 1.41  2000/03/07 14:06:22  vasilche
  1854. * Added stream buffering to ASN.1 binary input.
  1855. * Optimized class loading/storing.
  1856. * Fixed bugs in processing OPTIONAL fields.
  1857. * Added generation of reference counted objects.
  1858. *
  1859. * Revision 1.40  2000/02/17 20:02:43  vasilche
  1860. * Added some standard serialization exceptions.
  1861. * Optimized text/binary ASN.1 reading.
  1862. * Fixed wrong encoding of StringStore in ASN.1 binary format.
  1863. * Optimized logic of object collection.
  1864. *
  1865. * Revision 1.39  2000/02/11 17:10:24  vasilche
  1866. * Optimized text parsing.
  1867. *
  1868. * Revision 1.38  2000/01/10 19:46:40  vasilche
  1869. * Fixed encoding/decoding of REAL type.
  1870. * Fixed encoding/decoding of StringStore.
  1871. * Fixed encoding/decoding of NULL type.
  1872. * Fixed error reporting.
  1873. * Reduced object map (only classes).
  1874. *
  1875. * Revision 1.37  2000/01/05 19:43:53  vasilche
  1876. * Fixed error messages when reading from ASN.1 binary file.
  1877. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  1878. * Added TAG support to key/value of map.
  1879. * Added support of NULL variant in CHOICE.
  1880. *
  1881. * Revision 1.36  1999/12/28 18:55:49  vasilche
  1882. * Reduced size of compiled object files:
  1883. * 1. avoid inline or implicit virtual methods (especially destructors).
  1884. * 2. avoid std::string's methods usage in inline methods.
  1885. * 3. avoid string literals ("xxx") in inline methods.
  1886. *
  1887. * Revision 1.35  1999/12/20 15:29:35  vasilche
  1888. * Fixed bug with old ASN structures.
  1889. *
  1890. * Revision 1.34  1999/12/17 19:05:02  vasilche
  1891. * Simplified generation of GetTypeInfo methods.
  1892. *
  1893. * Revision 1.33  1999/11/18 20:18:08  vakatov
  1894. * ReadObjectInfo() -- get rid of the CodeWarrior(MAC) C++ compiler warning
  1895. *
  1896. * Revision 1.32  1999/10/18 20:21:41  vasilche
  1897. * Enum values now have long type.
  1898. * Fixed template generation for enums.
  1899. *
  1900. * Revision 1.31  1999/10/04 16:22:16  vasilche
  1901. * Fixed bug with old ASN.1 structures.
  1902. *
  1903. * Revision 1.30  1999/09/27 16:17:19  vasilche
  1904. * Fixed several incompatibilities with Windows
  1905. *
  1906. * Revision 1.29  1999/09/27 14:18:02  vasilche
  1907. * Fixed bug with overloaded constructors of Block.
  1908. *
  1909. * Revision 1.28  1999/09/26 05:19:02  vakatov
  1910. * FLT_MIN/MAX are not #define'd on some platforms
  1911. *
  1912. * Revision 1.27  1999/09/24 18:19:17  vasilche
  1913. * Removed dependency on NCBI toolkit.
  1914. *
  1915. * Revision 1.26  1999/09/23 21:16:07  vasilche
  1916. * Removed dependence on asn.h
  1917. *
  1918. * Revision 1.25  1999/09/23 20:25:04  vasilche
  1919. * Added support HAVE_NCBI_C
  1920. *
  1921. * Revision 1.24  1999/09/23 18:56:58  vasilche
  1922. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  1923. *
  1924. * Revision 1.23  1999/09/22 20:11:54  vasilche
  1925. * Modified for compilation on IRIX native c++ compiler.
  1926. *
  1927. * Revision 1.22  1999/09/16 19:22:15  vasilche
  1928. * Removed some warnings under GCC.
  1929. *
  1930. * Revision 1.21  1999/09/14 18:54:17  vasilche
  1931. * Fixed bugs detected by gcc & egcs.
  1932. * Removed unneeded includes.
  1933. *
  1934. * Revision 1.20  1999/08/16 16:08:30  vasilche
  1935. * Added ENUMERATED type.
  1936. *
  1937. * Revision 1.19  1999/08/13 20:22:57  vasilche
  1938. * Fixed lot of bugs in datatool
  1939. *
  1940. * Revision 1.18  1999/08/13 15:53:50  vasilche
  1941. * C++ analog of asntool: datatool
  1942. *
  1943. * Revision 1.17  1999/07/26 18:31:34  vasilche
  1944. * Implemented skipping of unused values.
  1945. * Added more useful error report.
  1946. *
  1947. * Revision 1.16  1999/07/22 17:33:49  vasilche
  1948. * Unified reading/writing of objects in all three formats.
  1949. *
  1950. * Revision 1.15  1999/07/19 15:50:32  vasilche
  1951. * Added interface to old ASN.1 routines.
  1952. * Added naming of key/value in STL map.
  1953. *
  1954. * Revision 1.14  1999/07/09 16:32:54  vasilche
  1955. * Added OCTET STRING write/read.
  1956. *
  1957. * Revision 1.13  1999/07/07 21:15:02  vasilche
  1958. * Cleaned processing of string types (string, char*, const char*).
  1959. *
  1960. * Revision 1.12  1999/07/07 18:18:32  vasilche
  1961. * Fixed some bugs found by MS VC++
  1962. *
  1963. * Revision 1.11  1999/07/02 21:31:54  vasilche
  1964. * Implemented reading from ASN.1 binary format.
  1965. *
  1966. * Revision 1.10  1999/07/01 17:55:29  vasilche
  1967. * Implemented ASN.1 binary write.
  1968. *
  1969. * Revision 1.9  1999/06/30 16:04:53  vasilche
  1970. * Added support for old ASN.1 structures.
  1971. *
  1972. * Revision 1.8  1999/06/24 14:44:54  vasilche
  1973. * Added binary ASN.1 output.
  1974. *
  1975. * Revision 1.7  1999/06/16 20:35:30  vasilche
  1976. * Cleaned processing of blocks of data.
  1977. * Added input from ASN.1 text format.
  1978. *
  1979. * Revision 1.6  1999/06/15 16:19:48  vasilche
  1980. * Added ASN.1 object output stream.
  1981. *
  1982. * Revision 1.5  1999/06/11 19:14:57  vasilche
  1983. * Working binary serialization and deserialization of first test object.
  1984. *
  1985. * Revision 1.4  1999/06/10 21:06:46  vasilche
  1986. * Working binary output and almost working binary input.
  1987. *
  1988. * Revision 1.3  1999/06/07 19:30:25  vasilche
  1989. * More bug fixes
  1990. *
  1991. * Revision 1.2  1999/06/04 20:51:45  vasilche
  1992. * First compilable version of serialization.
  1993. *
  1994. * Revision 1.1  1999/05/19 19:56:52  vasilche
  1995. * Commit just in case.
  1996. *
  1997. * ===========================================================================
  1998. */