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

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

生物技术

开发平台：

C/C++

objistrasnb.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objistrasnb.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:40:59  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.70
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: objistrasnb.cpp,v 1000.3 2004/06/01 19:40:59 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. * $Log: objistrasnb.cpp,v $
  42. * Revision 1000.3  2004/06/01 19:40:59  gouriano
  43. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.70
  44. *
  45. * Revision 1.70  2004/05/17 21:03:03  gorelenk
  46. * Added include of PCH ncbi_pch.hpp
  47. *
  48. * Revision 1.69  2004/03/23 15:39:23  gouriano
  49. * Added setup options for skipping unknown data members
  50. *
  51. * Revision 1.68  2004/03/16 17:48:21  gouriano
  52. * make it possible to skip unknown data members
  53. *
  54. * Revision 1.67  2003/11/26 19:59:40  vasilche
  55. * GetPosition() and GetDataFormat() methods now are implemented
  56. * in parent classes CObjectIStream and CObjectOStream to avoid
  57. * pure virtual method call in destructors.
  58. *
  59. * Revision 1.66  2003/10/15 18:00:32  vasilche
  60. * Fixed integer overflow in asn binary input stream after 2GB.
  61. * Added constructor of CObjectIStreamAsnBinary() from CByteSourceReader.
  62. *
  63. * Revision 1.65  2003/08/25 15:59:09  gouriano
  64. * added possibility to use namespaces in XML i/o streams
  65. *
  66. * Revision 1.64  2003/08/19 18:32:38  vasilche
  67. * Optimized reading and writing strings.
  68. * Avoid string reallocation when checking char values.
  69. * Try to reuse old string data when string reference counting is not working.
  70. *
  71. * Revision 1.63  2003/08/14 20:03:58  vasilche
  72. * Avoid memory reallocation when reading over preallocated object.
  73. * Simplified CContainerTypeInfo iterators interface.
  74. *
  75. * Revision 1.62  2003/08/13 15:47:45  gouriano
  76. * implemented serialization of AnyContent objects
  77. *
  78. * Revision 1.61  2003/05/22 20:10:02  gouriano
  79. * added UTF8 strings
  80. *
  81. * Revision 1.60  2003/05/16 18:02:18  gouriano
  82. * revised exception error messages
  83. *
  84. * Revision 1.59  2003/03/26 16:14:23  vasilche
  85. * Removed TAB symbols. Some formatting.
  86. *
  87. * Revision 1.58  2002/10/25 14:49:27  vasilche
  88. * NCBI C Toolkit compatibility code extracted to libxcser library.
  89. * Serial streams flags names were renamed to fXxx.
  90. *
  91. * Names of flags
  92. *
  93. * Revision 1.57  2002/01/23 21:58:31  grichenk
  94. * Fixed minor bug in log tags reader
  95. *
  96. * Revision 1.56  2002/01/17 20:52:35  grichenk
  97. * Fixed another bug in long binary tags processing
  98. *
  99. * Revision 1.55  2002/01/14 17:58:11  grichenk
  100. * Fixed long tags processing
  101. *
  102. * Revision 1.54  2001/10/17 20:41:24  grichenk
  103. * Added CObjectOStream::CharBlock class
  104. *
  105. * Revision 1.53  2001/06/07 17:12:51  grichenk
  106. * Redesigned checking and substitution of non-printable characters
  107. * in VisibleString
  108. *
  109. * Revision 1.52  2001/05/17 15:07:08  lavr
  110. * Typos corrected
  111. *
  112. * Revision 1.51  2001/01/22 23:12:57  vakatov
  113. * CObjectIStreamAsnBinary::{Read,Skip}ClassSequential() - use cur.member "pos"
  114. *
  115. * Revision 1.50  2001/01/03 15:22:26  vasilche
  116. * Fixed limited buffer size for REAL data in ASN.1 binary format.
  117. * Fixed processing non ASCII symbols in ASN.1 text format.
  118. *
  119. * Revision 1.49  2000/12/26 22:24:11  vasilche
  120. * Fixed errors of compilation on Mac.
  121. *
  122. * Revision 1.48  2000/12/15 21:29:02  vasilche
  123. * Moved some typedefs/enums from corelib/ncbistd.hpp.
  124. * Added flags to CObjectIStream/CObjectOStream: eFlagAllowNonAsciiChars.
  125. * TByte typedef replaced by Uint1.
  126. *
  127. * Revision 1.47  2000/12/15 15:38:44  vasilche
  128. * Added support of Int8 and long double.
  129. * Enum values now have type Int4 instead of long.
  130. *
  131. * Revision 1.46  2000/10/20 15:51:41  vasilche
  132. * Fixed data error processing.
  133. * Added interface for constructing container objects directly into output stream.
  134. * object.hpp, object.inl and object.cpp were split to
  135. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  136. *
  137. * Revision 1.45  2000/10/17 18:45:34  vasilche
  138. * Added possibility to turn off object cross reference detection in
  139. * CObjectIStream and CObjectOStream.
  140. *
  141. * Revision 1.44  2000/09/29 16:18:23  vasilche
  142. * Fixed binary format encoding/decoding on 64 bit compulers.
  143. * Implemented CWeakMap<> for automatic cleaning map entries.
  144. * Added cleaning local hooks via CWeakMap<>.
  145. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  146. * Added some user interface methods to CObjectIStream, CObjectOStream and
  147. * CObjectStreamCopier.
  148. *
  149. * Revision 1.43  2000/09/18 20:00:23  vasilche
  150. * Separated CVariantInfo and CMemberInfo.
  151. * Implemented copy hooks.
  152. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  153. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  154. *
  155. * Revision 1.42  2000/09/01 13:16:18  vasilche
  156. * Implemented class/container/choice iterators.
  157. * Implemented CObjectStreamCopier for copying data without loading into memory.
  158. *
  159. * Revision 1.41  2000/08/15 19:44:49  vasilche
  160. * Added Read/Write hooks:
  161. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  162. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  163. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  164. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  165. *
  166. * Revision 1.40  2000/07/03 20:47:22  vasilche
  167. * Removed unused variables/functions.
  168. *
  169. * Revision 1.39  2000/07/03 20:39:56  vasilche
  170. * Fixed comments.
  171. *
  172. * Revision 1.38  2000/07/03 18:42:45  vasilche
  173. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  174. * Reduced header dependency.
  175. *
  176. * Revision 1.37  2000/06/16 16:31:20  vasilche
  177. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  178. *
  179. * Revision 1.36  2000/06/07 19:45:59  vasilche
  180. * Some code cleaning.
  181. * Macros renaming in more clear way.
  182. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  183. *
  184. * Revision 1.35  2000/06/01 19:07:04  vasilche
  185. * Added parsing of XML data.
  186. *
  187. * Revision 1.34  2000/05/24 20:08:47  vasilche
  188. * Implemented XML dump.
  189. *
  190. * Revision 1.33  2000/05/09 16:38:39  vasilche
  191. * CObject::GetTypeInfo now moved to CObjectGetTypeInfo::GetTypeInfo to reduce possible errors.
  192. * Added write context to CObjectOStream.
  193. * Inlined most of methods of helping class Member, Block, ByteBlock etc.
  194. *
  195. * Revision 1.32  2000/04/28 16:58:13  vasilche
  196. * Added classes CByteSource and CByteSourceReader for generic reading.
  197. * Added delayed reading of choice variants.
  198. *
  199. * Revision 1.31  2000/04/13 14:50:27  vasilche
  200. * Added CObjectIStream::Open() and CObjectOStream::Open() for easier use.
  201. *
  202. * Revision 1.30  2000/03/29 15:55:28  vasilche
  203. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  204. * Added generic iterators by class -
  205. *  CTypeIterator<class>, CTypeConstIterator<class>,
  206. *  CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  207. *  CObjectsIterator and CObjectsConstIterator.
  208. *
  209. * Revision 1.29  2000/03/14 14:42:31  vasilche
  210. * Fixed error reporting.
  211. *
  212. * Revision 1.28  2000/03/10 17:59:20  vasilche
  213. * Fixed error reporting.
  214. * Added EOF bug workaround on MIPSpro compiler (not finished).
  215. *
  216. * Revision 1.27  2000/03/07 14:41:34  vasilche
  217. * Removed default argument.
  218. *
  219. * Revision 1.26  2000/03/07 14:06:23  vasilche
  220. * Added stream buffering to ASN.1 binary input.
  221. * Optimized class loading/storing.
  222. * Fixed bugs in processing OPTIONAL fields.
  223. * Added generation of reference counted objects.
  224. *
  225. * Revision 1.25  2000/02/17 20:02:44  vasilche
  226. * Added some standard serialization exceptions.
  227. * Optimized text/binary ASN.1 reading.
  228. * Fixed wrong encoding of StringStore in ASN.1 binary format.
  229. * Optimized logic of object collection.
  230. *
  231. * Revision 1.24  2000/01/10 19:46:40  vasilche
  232. * Fixed encoding/decoding of REAL type.
  233. * Fixed encoding/decoding of StringStore.
  234. * Fixed encoding/decoding of NULL type.
  235. * Fixed error reporting.
  236. * Reduced object map (only classes).
  237. *
  238. * Revision 1.23  2000/01/05 19:43:54  vasilche
  239. * Fixed error messages when reading from ASN.1 binary file.
  240. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  241. * Added TAG support to key/value of map.
  242. * Added support of NULL variant in CHOICE.
  243. *
  244. * Revision 1.22  1999/12/17 19:05:03  vasilche
  245. * Simplified generation of GetTypeInfo methods.
  246. *
  247. * Revision 1.21  1999/10/19 15:41:03  vasilche
  248. * Fixed reference to IOS_BASE
  249. *
  250. * Revision 1.20  1999/10/18 20:21:41  vasilche
  251. * Enum values now have long type.
  252. * Fixed template generation for enums.
  253. *
  254. * Revision 1.19  1999/10/08 21:00:43  vasilche
  255. * Implemented automatic generation of unnamed ASN.1 types.
  256. *
  257. * Revision 1.18  1999/10/04 16:22:17  vasilche
  258. * Fixed bug with old ASN.1 structures.
  259. *
  260. * Revision 1.17  1999/09/24 18:19:18  vasilche
  261. * Removed dependency on NCBI toolkit.
  262. *
  263. * Revision 1.16  1999/09/23 21:16:08  vasilche
  264. * Removed dependence on asn.h
  265. *
  266. * Revision 1.15  1999/09/23 18:56:59  vasilche
  267. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  268. *
  269. * Revision 1.14  1999/09/22 20:11:55  vasilche
  270. * Modified for compilation on IRIX native c++ compiler.
  271. *
  272. * Revision 1.13  1999/09/14 18:54:18  vasilche
  273. * Fixed bugs detected by gcc & egcs.
  274. * Removed unneeded includes.
  275. *
  276. * Revision 1.12  1999/08/16 16:08:31  vasilche
  277. * Added ENUMERATED type.
  278. *
  279. * Revision 1.11  1999/08/13 20:22:57  vasilche
  280. * Fixed lot of bugs in datatool
  281. *
  282. * Revision 1.10  1999/08/13 15:53:51  vasilche
  283. * C++ analog of asntool: datatool
  284. *
  285. * Revision 1.9  1999/07/26 18:31:37  vasilche
  286. * Implemented skipping of unused values.
  287. * Added more useful error report.
  288. *
  289. * Revision 1.8  1999/07/22 20:36:38  vasilche
  290. * Fixed 'using namespace' declaration for MSVC.
  291. *
  292. * Revision 1.7  1999/07/22 19:40:56  vasilche
  293. * Fixed bug with complex object graphs (pointers to members of other objects).
  294. *
  295. * Revision 1.6  1999/07/22 17:33:52  vasilche
  296. * Unified reading/writing of objects in all three formats.
  297. *
  298. * Revision 1.5  1999/07/21 20:02:54  vasilche
  299. * Added embedding of ASN.1 binary output from ToolKit to our binary format.
  300. * Fixed bugs with storing pointers into binary ASN.1
  301. *
  302. * Revision 1.4  1999/07/21 14:20:05  vasilche
  303. * Added serialization of bool.
  304. *
  305. * Revision 1.3  1999/07/09 16:32:54  vasilche
  306. * Added OCTET STRING write/read.
  307. *
  308. * Revision 1.2  1999/07/07 21:15:02  vasilche
  309. * Cleaned processing of string types (string, char*, const char*).
  310. *
  311. * Revision 1.1  1999/07/02 21:31:56  vasilche
  312. * Implemented reading from ASN.1 binary format.
  313. *
  314. * ===========================================================================
  315. */
  317. #include <ncbi_pch.hpp>
  318. #include <corelib/ncbistd.hpp>
  319. #include <corelib/ncbi_limits.hpp>
  321. #include <serial/objistrasnb.hpp>
  322. #include <serial/member.hpp>
  323. #include <serial/memberid.hpp>
  324. #include <serial/enumvalues.hpp>
  325. #include <serial/memberlist.hpp>
  326. #include <serial/objhook.hpp>
  327. #include <serial/classinfo.hpp>
  328. #include <serial/choice.hpp>
  329. #include <serial/continfo.hpp>
  330. #include <serial/objistrimpl.hpp>
  331. #include <serial/pack_string.hpp>
  333. using namespace NCBI_NS_NCBI::CObjectStreamAsnBinaryDefs;
  335. BEGIN_NCBI_SCOPE
  338. CObjectIStream* CObjectIStream::CreateObjectIStreamAsnBinary(void)
  339. {
  340.     return new CObjectIStreamAsnBinary();
  341. }
  344. CObjectIStreamAsnBinary::CObjectIStreamAsnBinary(EFixNonPrint how)
  345.     : CObjectIStream(eSerial_AsnBinary), m_FixMethod(how)
  346. {
  347. #if CHECK_STREAM_INTEGRITY
  348.     m_CurrentTagState = eTagStart;
  349.     m_CurrentTagLimit = numeric_limits<size_t>::max();
  350. #endif
  351.     m_CurrentTagLength = 0;
  352. }
  354. CObjectIStreamAsnBinary::CObjectIStreamAsnBinary(CNcbiIstream& in,
  355.                                                  EFixNonPrint how)
  356.     : CObjectIStream(eSerial_AsnBinary), m_FixMethod(how)
  357. {
  358. #if CHECK_STREAM_INTEGRITY
  359.     m_CurrentTagState = eTagStart;
  360.     m_CurrentTagLimit = numeric_limits<size_t>::max();
  361. #endif
  362.     m_CurrentTagLength = 0;
  363.     Open(in);
  364. }
  366. CObjectIStreamAsnBinary::CObjectIStreamAsnBinary(CNcbiIstream& in,
  367.                                                  bool deleteIn,
  368.                                                  EFixNonPrint how)
  369.     : CObjectIStream(eSerial_AsnBinary), m_FixMethod(how)
  370. {
  371. #if CHECK_STREAM_INTEGRITY
  372.     m_CurrentTagState = eTagStart;
  373.     m_CurrentTagLimit = numeric_limits<size_t>::max();
  374. #endif
  375.     m_CurrentTagLength = 0;
  376.     Open(in, deleteIn);
  377. }
  379. CObjectIStreamAsnBinary::CObjectIStreamAsnBinary(CByteSourceReader& reader,
  380.                                                  EFixNonPrint how)
  381.     : CObjectIStream(eSerial_AsnBinary), m_FixMethod(how)
  382. {
  383. #if CHECK_STREAM_INTEGRITY
  384.     m_CurrentTagState = eTagStart;
  385.     m_CurrentTagLimit = numeric_limits<size_t>::max();
  386. #endif
  387.     m_CurrentTagLength = 0;
  388.     Open(reader);
  389. }
  391. #if CHECK_STREAM_INTEGRITY
  392. Uint1 CObjectIStreamAsnBinary::PeekTagByte(size_t index)
  393. {
  394.     if ( m_CurrentTagState != eTagStart )
  395.         ThrowError(fIllegalCall,
  396.             "illegal PeekTagByte call: only allowed at tag start");
  397.     return m_Input.PeekChar(index);
  398. }
  400. Uint1 CObjectIStreamAsnBinary::StartTag(void)
  401. {
  402.     if ( m_CurrentTagLength != 0 )
  403.         ThrowError(fIllegalCall,
  404.             "illegal StartTag call: current tag length != 0");
  405.     return PeekTagByte();
  406. }
  407. #endif
  409. TTag CObjectIStreamAsnBinary::PeekTag(void)
  410. {
  411.     Uint1 byte = StartTag();
  412.     ETag sysTag = ExtractTag(byte);
  413.     if ( sysTag != eLongTag ) {
  414.         m_CurrentTagLength = 1;
  415. #if CHECK_STREAM_INTEGRITY
  416.         m_CurrentTagState = eTagParsed;
  417. #endif
  418.         return sysTag;
  419.     }
  420.     TTag tag = 0;
  421.     size_t i = 1;
  422.     const size_t KBitsInByte = 8; // ?
  423.     const size_t KTagBits = sizeof(tag) * KBitsInByte - 1;
  424.     do {
  425.         if ( tag >= (1 << (KTagBits - 7)) ) {
  426.             ThrowError(fOverflow, "tag number is too big: "+NStr::UIntToString(tag));
  427.         }
  428.         byte = PeekTagByte(i++);
  429.         tag = (tag << 7) | (byte & 0x7f);
  430.     } while ( (byte & 0x80) != 0 );
  431.     m_CurrentTagLength = i;
  432. #if CHECK_STREAM_INTEGRITY
  433.     m_CurrentTagState = eTagParsed;
  434. #endif
  435.     return tag;
  436. }
  438. TTag CObjectIStreamAsnBinary::PeekTag(EClass cls, bool constructed)
  439. {
  440.     if ( ExtractClassAndConstructed(PeekTagByte()) !=
  441.          MakeTagByte(cls, constructed) ) {
  442.         ThrowError(fFormatError, "unexpected tag class/constructed: #"
  443.             + NStr::UIntToString(PeekTagByte()) + ", should be #"
  444.             + NStr::UIntToString(MakeTagByte(cls, constructed)));
  445.     }
  446.     return PeekTag();
  447. }
  449. string CObjectIStreamAsnBinary::PeekClassTag(void)
  450. {
  451.     Uint1 byte = StartTag();
  452.     if ( ExtractTag(byte) != eLongTag ) {
  453.         ThrowError(fFormatError, "long tag expected");
  454.     }
  455.     string name;
  456.     size_t i = 1;
  457.     Uint1 c;
  458.     while ( ((c = PeekTagByte(i++)) & 0x80) != 0 ) {
  459.         name += char(c & 0x7f);
  460.         if ( i > 1024 ) {
  461.             ThrowError(fOverflow, "tag number is too big (greater than 1024)");
  462.         }
  463.     }
  464.     m_CurrentTagLength = i;
  465. #if CHECK_STREAM_INTEGRITY
  466.     m_CurrentTagState = eTagParsed;
  467. #endif
  468.     name += char(c & 0x7f);
  469.     return name;
  470. }
  472. Uint1 CObjectIStreamAsnBinary::PeekAnyTag(void)
  473. {
  474.     Uint1 fByte = StartTag();
  475.     if ( ExtractTag(fByte) != eLongTag ) {
  476.         m_CurrentTagLength = 1;
  477. #if CHECK_STREAM_INTEGRITY
  478.         m_CurrentTagState = eTagParsed;
  479. #endif
  480.         return fByte;
  481.     }
  482.     size_t i = 1;
  483.     Uint1 byte;
  484.     do {
  485.         if ( i > 1024 ) {
  486.             ThrowError(fOverflow, "tag number is too big (greater than 1024)");
  487.         }
  488.         byte = PeekTagByte(i++);
  489.     } while ( (byte & 0x80) != 0 );
  490.     m_CurrentTagLength = i;
  491. #if CHECK_STREAM_INTEGRITY
  492.     m_CurrentTagState = eTagParsed;
  493. #endif
  494.     return fByte;
  495. }
  497. void CObjectIStreamAsnBinary::UnexpectedTag(TTag tag)
  498. {
  499.     ThrowError(fFormatError,
  500.                "unexpected tag: " + NStr::IntToString(m_Input.PeekChar()) +
  501.                ", should be: " + NStr::IntToString(tag));
  502. }
  504. void CObjectIStreamAsnBinary::UnexpectedByte(Uint1 byte)
  505. {
  506.     ThrowError(fFormatError,
  507.                "byte " + NStr::IntToString(byte) + " expected");
  508. }
  510. #if CHECK_STREAM_INTEGRITY
  511. Uint1 CObjectIStreamAsnBinary::FlushTag(void)
  512. {
  513.     if ( m_CurrentTagState != eTagParsed || m_CurrentTagLength == 0 )
  514.         ThrowError(fIllegalCall, "illegal FlushTag call");
  515.     m_Input.SkipChars(m_CurrentTagLength);
  516.     m_CurrentTagState = eLengthValue;
  517.     return m_Input.GetChar();
  518. }
  520. bool CObjectIStreamAsnBinary::PeekIndefiniteLength(void)
  521. {
  522.     if ( m_CurrentTagState != eTagParsed )
  523.         ThrowError(fIllegalCall, "illegal PeekIndefiniteLength call");
  524.     return Uint1(m_Input.PeekChar(m_CurrentTagLength)) == 0x80;
  525. }
  527. void CObjectIStreamAsnBinary::ExpectIndefiniteLength(void)
  528. {
  529.     // indefinite length allowed only for constructed tags
  530.     if ( !ExtractConstructed(m_Input.PeekChar()) )
  531.         ThrowError(fFormatError, "illegal ExpectIndefiniteLength call");
  532.     if ( FlushTag() != 0x80 ) {
  533.         ThrowError(fFormatError, "indefinite length is expected");
  534.     }
  535.     _ASSERT(m_CurrentTagLimit == numeric_limits<size_t>::max());
  536.     // save tag limit
  537.     // tag limit is not changed
  538.     m_Limits.push(m_CurrentTagLimit);
  539.     m_CurrentTagState = eTagStart;
  540.     m_CurrentTagLength = 0;
  541. }
  543. size_t CObjectIStreamAsnBinary::StartTagData(size_t length)
  544. {
  545.     size_t cur_pos = m_Input.GetStreamOffset();
  546.     size_t newLimit = cur_pos + length;
  547.     _ASSERT(newLimit >= cur_pos);
  548.     size_t currentLimit = m_CurrentTagLimit;
  549.     _ASSERT(newLimit <= currentLimit);
  550.     m_Limits.push(currentLimit);
  551.     m_CurrentTagLimit = newLimit;
  552.     m_CurrentTagState = eData;
  553.     return length;
  554. }
  555. #endif
  557. size_t CObjectIStreamAsnBinary::ReadShortLength(void)
  558. {
  559.     Uint1 byte = FlushTag();
  560.     if ( byte >= 0x80 ) {
  561.         ThrowError(fFormatError, "short length expected");
  562.     }
  563.     return StartTagData(byte);
  564. }
  566. size_t CObjectIStreamAsnBinary::ReadLength(void)
  567. {
  568.     Uint1 byte = FlushTag();
  569.     if ( byte < 0x80 ) {
  570.         return StartTagData(byte);
  571.     }
  572.     size_t lengthLength = byte - 0x80;
  573.     if ( lengthLength == 0 ) {
  574.         ThrowError(fFormatError, "unexpected indefinite length");
  575.     }
  576.     if ( lengthLength > sizeof(size_t) ) {
  577.         ThrowError(fOverflow, "length overflow");
  578.     }
  579.     byte = m_Input.GetChar();
  580.     if ( byte == 0 ) {
  581.         ThrowError(fFormatError, "illegal length start");
  582.     }
  583.     if ( size_t(-1) < size_t(0) ) {        // size_t is signed
  584.         // check for sign overflow
  585.         if ( lengthLength == sizeof(size_t) && (byte & 0x80) != 0 ) {
  586.             ThrowError(fOverflow, "length overflow");
  587.         }
  588.     }
  589.     lengthLength--;
  590.     size_t length = byte;
  591.     while ( lengthLength-- > 0 )
  592.         length = (length << 8) | Uint1(m_Input.GetChar());
  593.     return StartTagData(length);
  594. }
  596. void CObjectIStreamAsnBinary::ExpectShortLength(size_t length)
  597. {
  598.     if ( ReadShortLength() != length ) {
  599.         ThrowError(fFormatError, "length expected: "+NStr::UIntToString(length));
  600.     }
  601. }
  603. #if CHECK_STREAM_INTEGRITY
  604. void CObjectIStreamAsnBinary::EndOfTag(void)
  605. {
  606.     if ( m_CurrentTagState != eData )
  607.         ThrowError(fIllegalCall, "illegal EndOfTag call");
  608.     // check for all bytes read
  609.     if ( m_CurrentTagLimit != numeric_limits<size_t>::max() ) {
  610.         if ( m_Input.GetStreamOffset() != m_CurrentTagLimit )
  611.             ThrowError(fIllegalCall,
  612.                        "illegal EndOfTag call: not all data bytes read");
  613.     }
  614.     m_CurrentTagState = eTagStart;
  615.     m_CurrentTagLength = 0;
  616.     // restore tag limit from stack
  617.     m_CurrentTagLimit = m_Limits.top();
  618.     m_Limits.pop();
  619.     _ASSERT(m_CurrentTagLimit == numeric_limits<size_t>::max());
  620. }
  622. void CObjectIStreamAsnBinary::ExpectEndOfContent(void)
  623. {
  624.     if ( m_CurrentTagState != eTagStart )
  625.         ThrowError(fFormatError, "illegal ExpectEndOfContent call");
  626.     ExpectSysTag(eNone);
  627.     if ( FlushTag() != 0 ) {
  628.         ThrowError(fFormatError, "zero length expected");
  629.     }
  630.     _ASSERT(m_CurrentTagLimit == numeric_limits<size_t>::max());
  631.     // restore tag limit from stack
  632.     m_CurrentTagLimit = m_Limits.top();
  633.     m_Limits.pop();
  634.     _ASSERT(m_CurrentTagLimit == numeric_limits<size_t>::max());
  635.     m_CurrentTagState = eTagStart;
  636.     m_CurrentTagLength = 0;
  637. }
  639. Uint1 CObjectIStreamAsnBinary::ReadByte(void)
  640. {
  641.     if ( m_CurrentTagState != eData )
  642.         ThrowError(fIllegalCall, "illegal ReadByte call");
  643.     if ( m_Input.GetStreamOffset() >= m_CurrentTagLimit )
  644.         ThrowError(fOverflow, "tag size overflow");
  645.     return m_Input.GetChar();
  646. }
  647. #endif
  649. void CObjectIStreamAsnBinary::ReadBytes(char* buffer, size_t count)
  650. {
  651. #if CHECK_STREAM_INTEGRITY
  652.     if ( m_CurrentTagState != eData ) {
  653.         ThrowError(fIllegalCall, "illegal ReadBytes call");
  654.     }
  655. #endif
  656.     if ( count == 0 )
  657.         return;
  658. #if CHECK_STREAM_INTEGRITY
  659.     size_t cur_pos = m_Input.GetStreamOffset();
  660.     size_t end_pos = cur_pos + count;
  661.     if ( end_pos < cur_pos || end_pos > m_CurrentTagLimit )
  662.         ThrowError(fOverflow, "tag size overflow");
  663. #endif
  664.     m_Input.GetChars(buffer, count);
  665. }
  667. void CObjectIStreamAsnBinary::SkipBytes(size_t count)
  668. {
  669. #if CHECK_STREAM_INTEGRITY
  670.     if ( m_CurrentTagState != eData ) {
  671.         ThrowError(fIllegalCall, "illegal ReadBytes call");
  672.     }
  673. #endif
  674.     if ( count == 0 )
  675.         return;
  676. #if CHECK_STREAM_INTEGRITY
  677.     size_t cur_pos = m_Input.GetStreamOffset();
  678.     size_t end_pos = cur_pos + count;
  679.     if ( end_pos < cur_pos || end_pos > m_CurrentTagLimit )
  680.         ThrowError(fOverflow, "tag size overflow");
  681. #endif
  682.     m_Input.GetChars(count);
  683. }
  685. template<typename T>
  686. void ReadStdSigned(CObjectIStreamAsnBinary& in, T& data)
  687. {
  688.     size_t length = in.ReadShortLength();
  689.     if ( length == 0 ) {
  690.         in.ThrowError(in.fFormatError, "zero length of number");
  691.     }
  692.     T n;
  693.     if ( length > sizeof(data) ) {
  694.         // skip
  695.         --length;
  696.         Int1 c = in.ReadSByte();
  697.         if ( c != 0 && c != -1 ) {
  698.             in.ThrowError(in.fOverflow, "overflow error");
  699.         }
  700.         while ( length > sizeof(data) ) {
  701.             --length;
  702.             if ( in.ReadSByte() != c ) {
  703.                 in.ThrowError(in.fOverflow, "overflow error");
  704.             }
  705.         }
  706.         --length;
  707.         n = in.ReadSByte();
  708.         if ( ((n ^ c) & 0x80) != 0 ) {
  709.             in.ThrowError(in.fOverflow, "overflow error");
  710.         }
  711.     }
  712.     else {
  713.         --length;
  714.         n = in.ReadSByte();
  715.     }
  716.     while ( length > 0 ) {
  717.         --length;
  718.         n = (n << 8) | in.ReadByte();
  719.     }
  720.     data = n;
  721.     in.EndOfTag();
  722. }
  724. template<typename T>
  725. void ReadStdUnsigned(CObjectIStreamAsnBinary& in, T& data)
  726. {
  727.     size_t length = in.ReadShortLength();
  728.     if ( length == 0 ) {
  729.         in.ThrowError(in.fFormatError, "zero length of number");
  730.     }
  731.     T n;
  732.     if ( length > sizeof(data) ) {
  733.         // skip
  734.         while ( length > sizeof(data) ) {
  735.             --length;
  736.             if ( in.ReadSByte() != 0 ) {
  737.                 in.ThrowError(in.fOverflow, "overflow error");
  738.             }
  739.         }
  740.         --length;
  741.         n = in.ReadByte();
  742.         if ( (n & 0x80) != 0 ) {
  743.             in.ThrowError(in.fOverflow, "overflow error");
  744.         }
  745.     }
  746.     else if ( length == sizeof(data) ) {
  747.         --length;
  748.         n = in.ReadByte();
  749.         if ( (n & 0x80) != 0 ) {
  750.             in.ThrowError(in.fOverflow, "overflow error");
  751.         }
  752.     }
  753.     else {
  754.         n = 0;
  755.     }
  756.     while ( length > 0 ) {
  757.         --length;
  758.         n = (n << 8) | in.ReadByte();
  759.     }
  760.     data = n;
  761.     in.EndOfTag();
  762. }
  764. bool CObjectIStreamAsnBinary::ReadBool(void)
  765. {
  766.     ExpectSysTag(eBoolean);
  767.     ExpectShortLength(1);
  768.     bool ret = ReadByte() != 0;
  769.     EndOfTag();
  770.     return ret;
  771. }
  773. char CObjectIStreamAsnBinary::ReadChar(void)
  774. {
  775.     ExpectSysTag(eGeneralString);
  776.     ExpectShortLength(1);
  777.     char ret = ReadByte();
  778.     EndOfTag();
  779.     return ret;
  780. }
  782. Int4 CObjectIStreamAsnBinary::ReadInt4(void)
  783. {
  784.     ExpectSysTag(eInteger);
  785.     Int4 data;
  786.     ReadStdSigned(*this, data);
  787.     return data;
  788. }
  790. Uint4 CObjectIStreamAsnBinary::ReadUint4(void)
  791. {
  792.     ExpectSysTag(eInteger);
  793.     Uint4 data;
  794.     ReadStdUnsigned(*this, data);
  795.     return data;
  796. }
  798. Int8 CObjectIStreamAsnBinary::ReadInt8(void)
  799. {
  800.     ExpectSysTag(eInteger);
  801.     Uint8 data;
  802.     ReadStdSigned(*this, data);
  803.     return data;
  804. }
  806. Uint8 CObjectIStreamAsnBinary::ReadUint8(void)
  807. {
  808.     ExpectSysTag(eInteger);
  809.     Uint8 data;
  810.     ReadStdUnsigned(*this, data);
  811.     return data;
  812. }
  814. static const size_t kMaxDoubleLength = 256;
  816. double CObjectIStreamAsnBinary::ReadDouble(void)
  817. {
  818.     ExpectSysTag(eReal);
  819.     size_t length = ReadLength();
  820.     if ( length < 2 ) {
  821.         ThrowError(fFormatError, "too short REAL data: length < 2");
  822.     }
  823.     if ( length > kMaxDoubleLength ) {
  824.         ThrowError(fFormatError, "too long REAL data: length > "
  825.             + NStr::UIntToString(kMaxDoubleLength));
  826.     }
  828.     ExpectByte(eDecimal);
  829.     length--;
  830.     char buffer[kMaxDoubleLength + 2];
  831.     ReadBytes(buffer, length);
  832.     EndOfTag();
  833.     buffer[length] = 0;
  834.     char* endptr;
  835.     double data = strtod(buffer, &endptr);
  836.     if ( *endptr != 0 ) {
  837.         ThrowError(fFormatError, "bad REAL data string");
  838.     }
  839.     return data;
  840. }
  842. void CObjectIStreamAsnBinary::ReadString(string& s, EStringType type)
  843. {
  844.     ExpectSysTag(eVisibleString);
  845.     ReadStringValue(ReadLength(), s,
  846.                     type == eStringTypeUTF8? eFNP_Allow: m_FixMethod);
  847. }
  849. void CObjectIStreamAsnBinary::ReadString(string& s,
  850.                                          CPackString& pack_string,
  851.                                          EStringType type)
  852. {
  853.     ExpectSysTag(eVisibleString);
  854.     size_t length = ReadLength();
  855.     char buffer[1024];
  856.     if ( length > sizeof(buffer) || length > pack_string.GetLengthLimit() ) {
  857.         pack_string.Skipped();
  858.         ReadStringValue(length, s,
  859.                         type == eStringTypeUTF8? eFNP_Allow: m_FixMethod);
  860.     }
  861.     else {
  862.         ReadBytes(buffer, length);
  863.         EndOfTag();
  864.         pair<CPackString::iterator, bool> found =
  865.             pack_string.Locate(buffer, length);
  866.         if ( found.second ) {
  867.             pack_string.AddOld(s, found.first);
  868.         }
  869.         else {
  870.             if ( type == eStringTypeVisible && m_FixMethod != eFNP_Allow ) {
  871.                 // check contents of string
  872.                 for ( size_t i = 0; i < length; ++i ) {
  873.                     if ( !GoodVisibleChar(buffer[i]) ) {
  874.                         for ( ; i < length; ++i ) {
  875.                             FixVisibleChar(buffer[i], m_FixMethod);
  876.                         }
  877.                         pack_string.Pack(s, buffer, length);
  878.                         return;
  879.                     }
  880.                 }
  881.             }
  882.             pack_string.AddNew(s, buffer, length, found.first);
  883.         }
  884.     }
  885. }
  887. void CObjectIStreamAsnBinary::ReadStringStore(string& s)
  888. {
  889.     ExpectSysTag(eApplication, false, eStringStore);
  890.     ReadStringValue(ReadLength(), s, m_FixMethod);
  891. }
  893. void CObjectIStreamAsnBinary::ReadStringValue(size_t length,
  894.                                               string& s,
  895.                                               EFixNonPrint fix_method)
  896. {
  897.     s.reserve(length);
  898.     char buffer[1024];
  899.     if ( length < sizeof(buffer) ) {
  900.         // try to reuse old value
  901.         ReadBytes(buffer, length);
  902.         if ( fix_method != eFNP_Allow ) {
  903.             for ( size_t i = 0; i < length; ++i ) {
  904.                 FixVisibleChar(buffer[i], fix_method);
  905.             }
  906.         }
  907.         if ( s.size() != length || memcmp(s.data(), buffer, length) != 0 ) {
  908.             s.assign(buffer, length);
  909.         }
  910.     }
  911.     else {
  912.         s.erase();
  913.         while ( length ) {
  914.             size_t count = min(length, sizeof(buffer));
  915.             ReadBytes(buffer, count);
  916.             if ( fix_method != eFNP_Allow ) {
  917.                 for ( size_t i = 0; i < count; ++i ) {
  918.                     FixVisibleChar(buffer[i], fix_method);
  919.                 }
  920.             }
  921.             s.append(buffer, count);
  922.             length -= count;
  923.         }
  924.     }
  925.     EndOfTag();
  926. }
  928. char* CObjectIStreamAsnBinary::ReadCString(void)
  929. {
  930.     ExpectSysTag(eVisibleString);
  931.     size_t length = ReadLength();
  932.     char* s = static_cast<char*>(malloc(length + 1));
  933.     ReadBytes(s, length);
  934.     s[length] = 0;
  935.     if ( m_FixMethod != eFNP_Allow ) {
  936.         // Check the string for non-printable characters
  937.         for ( char* ptr = s; length; ++ptr, --length ) {
  938.             FixVisibleChar(*ptr, m_FixMethod);
  939.         }
  940.     }
  941.     EndOfTag();
  942.     return s;
  943. }
  945. void CObjectIStreamAsnBinary::BeginContainer(const CContainerTypeInfo* containerType)
  946. {
  947.     if ( containerType->RandomElementsOrder() )
  948.         ExpectSysTag(eUniversal, true, eSet);
  949.     else
  950.         ExpectSysTag(eUniversal, true, eSequence);
  951.     ExpectIndefiniteLength();
  952. }
  954. void CObjectIStreamAsnBinary::EndContainer(void)
  955. {
  956.     ExpectEndOfContent();
  957. }
  959. bool CObjectIStreamAsnBinary::BeginContainerElement(TTypeInfo /*elementType*/)
  960. {
  961.     return HaveMoreElements();
  962. }
  964. #ifdef VIRTUAL_MID_LEVEL_IO
  965. void CObjectIStreamAsnBinary::ReadContainer(const CContainerTypeInfo* cType,
  966.                                             TObjectPtr containerPtr)
  967. {
  968.     if ( cType->RandomElementsOrder() )
  969.         ExpectSysTag(eUniversal, true, eSet);
  970.     else
  971.         ExpectSysTag(eUniversal, true, eSequence);
  972.     ExpectIndefiniteLength();
  974.     BEGIN_OBJECT_FRAME(eFrameArrayElement);
  976.     CContainerTypeInfo::CIterator iter;
  977.     bool old_element = cType->InitIterator(iter, containerPtr);
  978.     TTypeInfo elementType = cType->GetElementType();
  979.     while ( HaveMoreElements() ) {
  980.         if ( old_element ) {
  981.             elementType->ReadData(*this, cType->GetElementPtr(iter));
  982.             old_element = cType->NextElement(iter);
  983.         }
  984.         else {
  985.             cType->AddElement(containerPtr, *this);
  986.         }
  987.     }
  988.     if ( old_element ) {
  989.         cType->EraseAllElements(iter);
  990.     }
  992.     END_OBJECT_FRAME();
  994.     ExpectEndOfContent();
  995. }
  997. void CObjectIStreamAsnBinary::SkipContainer(const CContainerTypeInfo* cType)
  998. {
  999.     if ( cType->RandomElementsOrder() )
  1000.         ExpectSysTag(eUniversal, true, eSet);
  1001.     else
  1002.         ExpectSysTag(eUniversal, true, eSequence);
  1003.     ExpectIndefiniteLength();
  1005.     TTypeInfo elementType = cType->GetElementType();
  1006.     BEGIN_OBJECT_FRAME(eFrameArrayElement);
  1008.     while ( HaveMoreElements() ) {
  1009.         SkipObject(elementType);
  1010.     }
  1012.     END_OBJECT_FRAME();
  1014.     ExpectEndOfContent();
  1015. }
  1016. #endif
  1018. void CObjectIStreamAsnBinary::BeginClass(const CClassTypeInfo* classInfo)
  1019. {
  1020.     if ( classInfo->RandomOrder() )
  1021.         ExpectSysTag(eUniversal, true, eSet);
  1022.     else
  1023.         ExpectSysTag(eUniversal, true, eSequence);
  1024.     ExpectIndefiniteLength();
  1025. }
  1027. void CObjectIStreamAsnBinary::EndClass(void)
  1028. {
  1029.     ExpectEndOfContent();
  1030. }
  1032. void CObjectIStreamAsnBinary::UnexpectedMember(TTag tag)
  1033. {
  1034.     ThrowError(fFormatError,
  1035.                "unexpected member: ["+NStr::IntToString(tag)+"]");
  1036. }
  1038. TMemberIndex
  1039. CObjectIStreamAsnBinary::BeginClassMember(const CClassTypeInfo* classType)
  1040. {
  1041.     if ( !HaveMoreElements() )
  1042.         return kInvalidMember;
  1044.     TTag tag = PeekTag(eContextSpecific, true);
  1045.     ExpectIndefiniteLength();
  1046.     TMemberIndex index = classType->GetMembers().Find(tag);
  1047.     if ( index == kInvalidMember )
  1048.         if (GetSkipUnknownMembers() == eSerialSkipUnknown_Yes) {
  1049.             ReadAnyContent();
  1050.             ExpectEndOfContent();
  1051.             return BeginClassMember(classType);
  1052.         } else {
  1053.             UnexpectedMember(tag);
  1054.         }
  1055.     return index;
  1056. }
  1058. TMemberIndex
  1059. CObjectIStreamAsnBinary::BeginClassMember(const CClassTypeInfo* classType,
  1060.                                           TMemberIndex pos)
  1061. {
  1062.     if ( !HaveMoreElements() )
  1063.         return kInvalidMember;
  1065.     TTag tag = PeekTag(eContextSpecific, true);
  1066.     ExpectIndefiniteLength();
  1067.     TMemberIndex index = classType->GetMembers().Find(tag, pos);
  1068.     if ( index == kInvalidMember )
  1069.         if (GetSkipUnknownMembers() == eSerialSkipUnknown_Yes) {
  1070.             ReadAnyContent();
  1071.             ExpectEndOfContent();
  1072.             return BeginClassMember(classType, pos);
  1073.         } else {
  1074.             UnexpectedMember(tag);
  1075.         }
  1076.     return index;
  1077. }
  1079. void CObjectIStreamAsnBinary::EndClassMember(void)
  1080. {
  1081.     ExpectEndOfContent();
  1082. }
  1084. #ifdef VIRTUAL_MID_LEVEL_IO
  1085. void CObjectIStreamAsnBinary::ReadClassRandom(const CClassTypeInfo* classType,
  1086.                                               TObjectPtr classPtr)
  1087. {
  1088.     BeginClass(classType);
  1090.     ReadClassRandomContentsBegin(classType);
  1092.     TMemberIndex index;
  1093.     while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
  1094.         ReadClassRandomContentsMember(classPtr);
  1095.         EndClassMember();
  1096.     }
  1098.     ReadClassRandomContentsEnd();
  1100.     EndClass();
  1101. }
  1103. void CObjectIStreamAsnBinary::ReadClassSequential(const CClassTypeInfo* classType,
  1104.                                                   TObjectPtr classPtr)
  1105. {
  1106.     BeginClass(classType);
  1107.     ReadClassSequentialContentsBegin(classType);
  1109.     TMemberIndex index;
  1110.     while ( (index = BeginClassMember(classType,*pos)) != kInvalidMember ) {
  1111.         ReadClassSequentialContentsMember(classPtr);
  1112.         EndClassMember();
  1113.     }
  1115.     ReadClassSequentialContentsEnd(classPtr);
  1116.     EndClass();
  1117. }
  1119. void CObjectIStreamAsnBinary::SkipClassRandom(const CClassTypeInfo* classType)
  1120. {
  1121.     BeginClass(classType);
  1122.     SkipClassRandomContentsBegin(classType);
  1124.     TMemberIndex index;
  1125.     while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
  1126.         SkipClassRandomContentsMember();
  1127.         EndClassMember();
  1128.     }
  1130.     SkipClassRandomContentsEnd();
  1131.     EndClass();
  1132. }
  1134. void CObjectIStreamAsnBinary::SkipClassSequential(const CClassTypeInfo* classType)
  1135. {
  1136.     BeginClass(classType);
  1137.     SkipClassSequentialContentsBegin(classType);
  1139.     TMemberIndex index;
  1140.     while ( (index = BeginClassMember(classType,*pos)) != kInvalidMember ) {
  1141.         SkipClassSequentialContentsMember();
  1142.         EndClassMember();
  1143.     }
  1145.     SkipClassSequentialContentsEnd();
  1146.     EndClass();
  1147. }
  1148. #endif
  1150. TMemberIndex CObjectIStreamAsnBinary::BeginChoiceVariant(const CChoiceTypeInfo* choiceType)
  1151. {
  1152.     TTag tag = PeekTag(eContextSpecific, true);
  1153.     ExpectIndefiniteLength();
  1154.     TMemberIndex index = choiceType->GetVariants().Find(tag);
  1155.     if ( index == kInvalidMember )
  1156.         UnexpectedMember(tag);
  1157.     return index;
  1158. }
  1160. void CObjectIStreamAsnBinary::EndChoiceVariant(void)
  1161. {
  1162.     ExpectEndOfContent();
  1163. }
  1165. #ifdef VIRTUAL_MID_LEVEL_IO
  1166. void CObjectIStreamAsnBinary::ReadChoice(const CChoiceTypeInfo* choiceType,
  1167.                                          TObjectPtr choicePtr)
  1168. {
  1169.     TMemberIndex index = BeginChoiceVariant(choiceType);
  1171.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1172.     BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());
  1174.     variantInfo->ReadVariant(*this, choicePtr);
  1176.     END_OBJECT_FRAME();
  1178.     EndChoiceVariant();
  1179. }
  1181. void CObjectIStreamAsnBinary::SkipChoice(const CChoiceTypeInfo* choiceType)
  1182. {
  1183.     TMemberIndex index = BeginChoiceVariant(choiceType);
  1185.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1186.     BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());
  1188.     variantInfo->SkipVariant(*this);
  1190.     END_OBJECT_FRAME();
  1192.     EndChoiceVariant();
  1193. }
  1194. #endif
  1196. void CObjectIStreamAsnBinary::BeginBytes(ByteBlock& block)
  1197. {
  1198.     ExpectSysTag(eOctetString);
  1199.     block.SetLength(ReadLength());
  1200. }
  1202. size_t CObjectIStreamAsnBinary::ReadBytes(ByteBlock& ,
  1203.                                           char* dst, size_t length)
  1204. {
  1205.     ReadBytes(dst, length);
  1206.     return length;
  1207. }
  1209. void CObjectIStreamAsnBinary::EndBytes(const ByteBlock& )
  1210. {
  1211.     EndOfTag();
  1212. }
  1214. void CObjectIStreamAsnBinary::BeginChars(CharBlock& block)
  1215. {
  1216.     ExpectSysTag(eVisibleString);
  1217.     block.SetLength(ReadLength());
  1218. }
  1220. size_t CObjectIStreamAsnBinary::ReadChars(CharBlock& ,
  1221.                                           char* dst, size_t length)
  1222. {
  1223.     ReadBytes(dst, length);
  1224.     return length;
  1225. }
  1227. void CObjectIStreamAsnBinary::EndChars(const CharBlock& )
  1228. {
  1229.     EndOfTag();
  1230. }
  1232. void CObjectIStreamAsnBinary::ReadNull(void)
  1233. {
  1234.     ExpectSysTag(eNull);
  1235.     ExpectShortLength(0);
  1236.     EndOfTag();
  1237. }
  1239. bool CObjectIStreamAsnBinary::ReadAnyContent()
  1240. {
  1241.     Uint1 byte = PeekAnyTag();
  1242.     if (ExtractConstructed(byte) && PeekIndefiniteLength()) {
  1243.         ExpectIndefiniteLength();
  1244.         if (ReadAnyContent()) {
  1245.             while (HaveMoreElements()) {
  1246.                 ReadAnyContent();
  1247.             }
  1248.             ExpectEndOfContent();
  1249.         }
  1250.         return true;
  1251.     }
  1252.     size_t length = ReadLength();
  1253.     if (length) {
  1254.         SkipBytes(length);
  1255.     }
  1256.     EndOfTag();
  1257.     return (length != 0);
  1258. }
  1260. void CObjectIStreamAsnBinary::ReadAnyContentObject(CAnyContentObject& )
  1261. {
  1262.     NCBI_THROW(CSerialException,eNotImplemented,
  1263.         "CObjectIStreamAsnBinary::ReadAnyContentObject: "
  1264.         "unable to read AnyContent object in ASN binary");
  1265. }
  1267. void CObjectIStreamAsnBinary::SkipAnyContentObject(void)
  1268. {
  1269.     NCBI_THROW(CSerialException,eNotImplemented,
  1270.         "CObjectIStreamAsnBinary::SkipAnyContentObject: "
  1271.         "unable to skip AnyContent object in ASN binary");
  1272. }
  1274. CObjectIStream::EPointerType CObjectIStreamAsnBinary::ReadPointerType(void)
  1275. {
  1276.     Uint1 byte = PeekTagByte();
  1277.     // variants:
  1278.     //    eUniversal,   !constructed, eNull             -> NULL
  1279.     //    eApplication,  constructed, eMemberReference  -> member reference
  1280.     //    eApplication,  constructed, eLongTag          -> other class
  1281.     //    eApplication, !constructed, eObjectReference  -> object reference
  1282.     // any other -> this class
  1283.     if ( byte == eEndOfContentsByte ) {
  1284.         ExpectShortLength(0);
  1285.         EndOfTag();
  1286.         return eNullPointer;
  1287.     }
  1288.     else if ( byte == MakeTagByte(eApplication, true, eLongTag) ) {
  1289.         return eOtherPointer;
  1290.     }
  1291.     else if ( byte == MakeTagByte(eApplication, false, eObjectReference) ) {
  1292.         return eObjectPointer;
  1293.     }
  1294.     // by default: try this class
  1295.     return eThisPointer;
  1296. }
  1298. TEnumValueType CObjectIStreamAsnBinary::ReadEnum(const CEnumeratedTypeValues& values)
  1299. {
  1300.     TEnumValueType value;
  1301.     if ( values.IsInteger() ) {
  1302.         // allow any integer
  1303.         ExpectSysTag(eInteger);
  1304.         ReadStdSigned(*this, value);
  1305.     }
  1306.     else {
  1307.         // enum element by value
  1308.         ExpectSysTag(eEnumerated);
  1309.         ReadStdSigned(*this, value);
  1310.         values.FindName(value, false); // check value
  1311.     }
  1312.     return value;
  1313. }
  1315. CObjectIStream::TObjectIndex CObjectIStreamAsnBinary::ReadObjectPointer(void)
  1316. {
  1317.     TObjectIndex data;
  1318.     ReadStdSigned(*this, data);
  1319.     return data;
  1320. }
  1322. string CObjectIStreamAsnBinary::ReadOtherPointer(void)
  1323. {
  1324.     string className = PeekClassTag();
  1325.     ExpectIndefiniteLength();
  1326.     return className;
  1327. }
  1329. void CObjectIStreamAsnBinary::ReadOtherPointerEnd(void)
  1330. {
  1331.     ExpectEndOfContent();
  1332. }
  1334. bool CObjectIStreamAsnBinary::SkipRealValue(void)
  1335. {
  1336.     if ( PeekTagByte() == 0 && PeekTagByte(1) == 0 )
  1337.         return false;
  1338.     Uint1 byte = PeekAnyTag();
  1339.     if ( ExtractConstructed(byte) ) {
  1340.         // constructed
  1341.         ExpectIndefiniteLength();
  1342.         while ( SkipRealValue() )
  1343.             ;
  1344.         ExpectEndOfContent();
  1345.     }
  1346.     else {
  1347.         SkipTagData();
  1348.     }
  1349.     return true;
  1350. }
  1353. void CObjectIStreamAsnBinary::SkipBool(void)
  1354. {
  1355.     ExpectSysTag(eBoolean);
  1356.     ExpectShortLength(1);
  1357.     ReadByte();
  1358.     EndOfTag();
  1359. }
  1361. void CObjectIStreamAsnBinary::SkipChar(void)
  1362. {
  1363.     ExpectSysTag(eGeneralString);
  1364.     ExpectShortLength(1);
  1365.     ReadByte();
  1366.     EndOfTag();
  1367. }
  1369. void CObjectIStreamAsnBinary::SkipSNumber(void)
  1370. {
  1371.     ExpectSysTag(eInteger);
  1372.     SkipTagData();
  1373. }
  1375. void CObjectIStreamAsnBinary::SkipUNumber(void)
  1376. {
  1377.     ExpectSysTag(eInteger);
  1378.     SkipTagData();
  1379. }
  1381. void CObjectIStreamAsnBinary::SkipFNumber(void)
  1382. {
  1383.     ExpectSysTag(eReal);
  1384.     size_t length = ReadLength();
  1385.     if ( length < 2 )
  1386.         ThrowError(fFormatError, "too short REAL data: length < 2");
  1387.     if ( length > kMaxDoubleLength )
  1388.         ThrowError(fFormatError, "too long REAL data: length > "
  1389.             + NStr::UIntToString(kMaxDoubleLength));
  1391.     ExpectByte(eDecimal);
  1392.     length--;
  1393.     SkipBytes(length);
  1394.     EndOfTag();
  1395. }
  1397. void CObjectIStreamAsnBinary::SkipString(EStringType /*type*/)
  1398. {
  1399.     ExpectSysTag(eVisibleString);
  1400.     SkipTagData();
  1401. }
  1403. void CObjectIStreamAsnBinary::SkipStringStore(void)
  1404. {
  1405.     ExpectSysTag(eApplication, false, eStringStore);
  1406.     SkipTagData();
  1407. }
  1409. void CObjectIStreamAsnBinary::SkipNull(void)
  1410. {
  1411.     ExpectSysTag(eNull);
  1412.     ExpectShortLength(0);
  1413.     EndOfTag();
  1414. }
  1416. void CObjectIStreamAsnBinary::SkipByteBlock(void)
  1417. {
  1418.     ExpectSysTag(eOctetString);
  1419.     SkipTagData();
  1420. }
  1422. void CObjectIStreamAsnBinary::SkipTagData(void)
  1423. {
  1424.     SkipBytes(ReadLength());
  1425.     EndOfTag();
  1426. }
  1428. END_NCBI_SCOPE