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

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

生物技术

开发平台：

C/C++

objistrasn.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objistrasn.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:40:57  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.92
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: objistrasn.cpp,v 1000.3 2004/06/01 19:40:57 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. */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbistd.hpp>
  43. #include <corelib/ncbiutil.hpp>
  44. #include <serial/objistrasn.hpp>
  45. #include <serial/member.hpp>
  46. #include <serial/enumvalues.hpp>
  47. #include <serial/memberlist.hpp>
  48. #include <serial/objhook.hpp>
  49. #include <serial/classinfo.hpp>
  50. #include <serial/choice.hpp>
  51. #include <serial/continfo.hpp>
  52. #include <serial/objistrimpl.hpp>
  53. #include <math.h>
  54. #if !defined(DBL_MAX_10_EXP) || !defined(FLT_MAX)
  55. # include <float.h>
  56. #endif
  58. BEGIN_NCBI_SCOPE
  60. CObjectIStream* CObjectIStream::CreateObjectIStreamAsn(void)
  61. {
  62.     return new CObjectIStreamAsn();
  63. }
  65. CObjectIStreamAsn::CObjectIStreamAsn(EFixNonPrint how)
  66.     : CObjectIStream(eSerial_AsnText), m_FixMethod(how)
  67. {
  68. }
  70. CObjectIStreamAsn::CObjectIStreamAsn(CNcbiIstream& in,
  71.                                      EFixNonPrint how)
  72.     : CObjectIStream(eSerial_AsnText), m_FixMethod(how)
  73. {
  74.     Open(in);
  75. }
  77. CObjectIStreamAsn::CObjectIStreamAsn(CNcbiIstream& in,
  78.                                      bool deleteIn,
  79.                                      EFixNonPrint how)
  80.     : CObjectIStream(eSerial_AsnText), m_FixMethod(how)
  81. {
  82.     Open(in, deleteIn);
  83. }
  85. string CObjectIStreamAsn::GetPosition(void) const
  86. {
  87.     return "line "+NStr::UIntToString(m_Input.GetLine());
  88. }
  90. inline
  91. bool CObjectIStreamAsn::FirstIdChar(char c)
  92. {
  93.     return isalpha(c) || c == '_';
  94. }
  96. inline
  97. bool CObjectIStreamAsn::IdChar(char c)
  98. {
  99.     return isalnum(c) || c == '_' || c == '.';
  100. }
  102. inline
  103. char CObjectIStreamAsn::GetChar(void)
  104. {
  105.     return m_Input.GetChar();
  106. }
  108. inline
  109. char CObjectIStreamAsn::PeekChar(void)
  110. {
  111.     return m_Input.PeekChar();
  112. }
  114. inline
  115. void CObjectIStreamAsn::SkipEndOfLine(char c)
  116. {
  117.     m_Input.SkipEndOfLine(c);
  118. }
  120. inline
  121. char CObjectIStreamAsn::SkipWhiteSpaceAndGetChar(void)
  122. {
  123.     char c = SkipWhiteSpace();
  124.     m_Input.SkipChar();
  125.     return c;
  126. }
  128. inline
  129. char CObjectIStreamAsn::GetChar(bool skipWhiteSpace)
  130. {
  131.     return skipWhiteSpace? SkipWhiteSpaceAndGetChar(): m_Input.GetChar();
  132. }
  134. inline
  135. char CObjectIStreamAsn::PeekChar(bool skipWhiteSpace)
  136. {
  137.     return skipWhiteSpace? SkipWhiteSpace(): m_Input.PeekChar();
  138. }
  140. inline
  141. bool CObjectIStreamAsn::GetChar(char expect, bool skipWhiteSpace)
  142. {
  143.     if ( PeekChar(skipWhiteSpace) != expect ) {
  144.         return false;
  145.     }
  146.     m_Input.SkipChar();
  147.     return true;
  148. }
  150. void CObjectIStreamAsn::Expect(char expect, bool skipWhiteSpace)
  151. {
  152.     if ( !GetChar(expect, skipWhiteSpace) ) {
  153.         string msg("'");
  154.         msg += expect;
  155.         msg += "' expected";
  156.         ThrowError(fFormatError, msg);
  157.     }
  158. }
  160. bool CObjectIStreamAsn::Expect(char choiceTrue, char choiceFalse,
  161.                                bool skipWhiteSpace)
  162. {
  163.     char c = GetChar(skipWhiteSpace);
  164.     if ( c == choiceTrue ) {
  165.         return true;
  166.     }
  167.     else if ( c == choiceFalse ) {
  168.         return false;
  169.     }
  170.     m_Input.UngetChar(c);
  171.     string msg("'");
  172.     msg += choiceTrue;
  173.     msg += "' or '";
  174.     msg += choiceFalse;
  175.     msg += "' expected";
  176.     ThrowError(fFormatError, msg);
  177.     return false;
  178. }
  180. char CObjectIStreamAsn::SkipWhiteSpace(void)
  181. {
  182.     try { // catch CEofException
  183.         for ( ;; ) {
  184.             char c = m_Input.SkipSpaces();
  185.             switch ( c ) {
  186.             case 't':
  187.                 m_Input.SkipChar();
  188.                 continue;
  189.             case 'r':
  190.             case 'n':
  191.                 m_Input.SkipChar();
  192.                 SkipEndOfLine(c);
  193.                 continue;
  194.             case '-':
  195.                 // check for comments
  196.                 if ( m_Input.PeekChar(1) != '-' ) {
  197.                     return '-';
  198.                 }
  199.                 m_Input.SkipChars(2);
  200.                 // skip comments
  201.                 SkipComments();
  202.                 continue;
  203.             default:
  204.                 return c;
  205.             }
  206.         }
  207.     } catch (CEofException& e) {
  208.         // There should be no eof here, report as an error
  209.         if (GetStackDepth() < 2) {
  210.             throw;
  211.         } else {
  212.             ThrowError(fEOF, e.what());
  213.         }
  214.     }
  215.     return '';
  216. }
  218. void CObjectIStreamAsn::SkipComments(void)
  219. {
  220.     try {
  221.         for ( ;; ) {
  222.             char c = GetChar();
  223.             switch ( c ) {
  224.             case 'r':
  225.             case 'n':
  226.                 SkipEndOfLine(c);
  227.                 return;
  228.             case '-':
  229.                 c = GetChar();
  230.                 switch ( c ) {
  231.                 case 'r':
  232.                 case 'n':
  233.                     SkipEndOfLine(c);
  234.                     return;
  235.                 case '-':
  236.                     return;
  237.                 }
  238.                 continue;
  239.             default:
  240.                 continue;
  241.             }
  242.         }
  243.     }
  244.     catch ( CEofException& /* ignored */ ) {
  245.         return;
  246.     }
  247. }
  249. CLightString CObjectIStreamAsn::ScanEndOfId(bool isId)
  250. {
  251.     if ( isId ) {
  252.         for ( size_t i = 1; ; ++i ) {
  253.             char c = m_Input.PeekCharNoEOF(i);
  254.             if ( !IdChar(c) &&
  255.                  (c != '-' || !IdChar(m_Input.PeekChar(i + 1))) ) {
  256.                 const char* ptr = m_Input.GetCurrentPos();
  257.                 m_Input.SkipChars(i);
  258.                 return CLightString(ptr, i);
  259.             }
  260.         }
  261.     }
  262.     return CLightString();
  263. }
  265. CLightString CObjectIStreamAsn::ReadTypeId(char c)
  266. {
  267.     if ( c == '[' ) {
  268.         for ( size_t i = 1; ; ++i ) {
  269.             switch ( m_Input.PeekChar(i) ) {
  270.             case 'r':
  271.             case 'n':
  272.                 ThrowError(fFormatError, "end of line: expected ']'");
  273.                 break;
  274.             case ']':
  275.                 {
  276.                     const char* ptr = m_Input.GetCurrentPos();
  277.                     m_Input.SkipChars(i);
  278.                     return CLightString(ptr + 1, i - 2);
  279.                 }
  280.             }
  281.         }
  282.     }
  283.     else {
  284.         return ScanEndOfId(FirstIdChar(c));
  285.     }
  286. }
  288. CLightString CObjectIStreamAsn::ReadNumber(void)
  289. {
  290.     char c = SkipWhiteSpace();
  291.     if ( c != '-' && c != '+' && !isdigit(c) )
  292.         ThrowError(fFormatError, "invalid number");
  293.     for ( size_t i = 1; ; ++i ) {
  294.         c = m_Input.PeekChar(i);
  295.         if ( !isdigit(c) ) {
  296.             const char* ptr = m_Input.GetCurrentPos();
  297.             m_Input.SkipChars(i);
  298.             return CLightString(ptr, i);
  299.         }
  300.     }
  301. }
  303. inline
  304. CLightString CObjectIStreamAsn::ReadUCaseId(char c)
  305. {
  306.     return ScanEndOfId(isupper(c) != 0);
  307. }
  309. inline
  310. CLightString CObjectIStreamAsn::ReadLCaseId(char c)
  311. {
  312.     return ScanEndOfId(islower(c) != 0);
  313. }
  315. inline
  316. CLightString CObjectIStreamAsn::ReadMemberId(char c)
  317. {
  318.     if ( c == '[' ) {
  319.         for ( size_t i = 1; ; ++i ) {
  320.             switch ( m_Input.PeekChar(i) ) {
  321.             case 'r':
  322.             case 'n':
  323.                 ThrowError(fFormatError, "end of line: expected ']'");
  324.                 break;
  325.             case ']':
  326.                 {
  327.                     const char* ptr = m_Input.GetCurrentPos();
  328.                     m_Input.SkipChars(++i);
  329.                     return CLightString(ptr + 1, i - 2);
  330.                 }
  331.             }
  332.         }
  333.     }
  334.     else {
  335.         return ScanEndOfId(islower(c) != 0);
  336.     }
  337. }
  339. TMemberIndex CObjectIStreamAsn::GetMemberIndex
  340.     (const CClassTypeInfo* classType,
  341.      const CLightString& id)
  342. {
  343.     TMemberIndex idx;
  344.     if (id.GetLength() > 0  &&  isdigit(id.GetString()[0])) {
  345.         idx = classType->GetMembers().Find
  346.             (CMemberId::TTag(NStr::StringToInt(id)));
  347.     }
  348.     else {
  349.         idx = classType->GetMembers().Find(id);
  350.     }
  351.     return idx;
  352. }
  354. TMemberIndex CObjectIStreamAsn::GetMemberIndex
  355.     (const CClassTypeInfo* classType,
  356.      const CLightString& id,
  357.      const TMemberIndex pos)
  358. {
  359.     TMemberIndex idx;
  360.     if (id.GetLength() > 0  &&  isdigit(id.GetString()[0])) {
  361.         idx = classType->GetMembers().Find
  362.             (CMemberId::TTag(NStr::StringToInt(id)), pos);
  363.     }
  364.     else {
  365.         idx = classType->GetMembers().Find(id, pos);
  366.     }
  367.     return idx;
  368. }
  370. TMemberIndex CObjectIStreamAsn::GetChoiceIndex
  371.     (const CChoiceTypeInfo* choiceType,
  372.      const CLightString& id)
  373. {
  374.     TMemberIndex idx;
  375.     if (id.GetLength() > 0  &&  isdigit(id.GetString()[0])) {
  376.         idx = choiceType->GetVariants().Find
  377.             (CMemberId::TTag(NStr::StringToInt(id)));
  378.     }
  379.     else {
  380.         idx = choiceType->GetVariants().Find(id);
  381.     }
  382.     return idx;
  383. }
  385. void CObjectIStreamAsn::ReadNull(void)
  386. {
  387.     if ( SkipWhiteSpace() == 'N' && 
  388.          m_Input.PeekCharNoEOF(1) == 'U' &&
  389.          m_Input.PeekCharNoEOF(2) == 'L' &&
  390.          m_Input.PeekCharNoEOF(3) == 'L' &&
  391.          !IdChar(m_Input.PeekCharNoEOF(4)) ) {
  392.         m_Input.SkipChars(4);
  393.     }
  394.     else
  395.         ThrowError(fFormatError, "'NULL' expected");
  396. }
  398. void CObjectIStreamAsn::ReadAnyContent(string& value)
  399. {
  400.     char to = GetChar(true);
  401.     value += to;
  402.     if (to == '{') {
  403.         to = '}';
  404.     } else if (to == '"') {
  405.     } else {
  406.         to = '';
  407.     }
  409.     bool space = false;
  410.     for (char c = m_Input.PeekChar(); ; c = m_Input.PeekChar()) {
  411.         if (to != '"') {
  412.             if (isspace(c)) {
  413.                 if (space) {
  414.                     m_Input.SkipChar();
  415.                     continue;
  416.                 }
  417.                 c = ' ';
  418.                 space = true;
  419.             } else {
  420.                 space = false;;
  421.             }
  422.             if (to != '}' && c == ',') {
  423.                 return;
  424.             } else if (c == '"' || c == '{') {
  425.                 ReadAnyContent(value);
  426.                 continue;
  427.             }
  428.         }
  429.         if (c == to) {
  430.             value += c;
  431.             m_Input.SkipChar();
  432.             return;
  433.         }
  434.         if (c == '"' || c == '{') {
  435.             ReadAnyContent(value);
  436.             continue;
  437.         }
  438.         value += c;
  439.         m_Input.SkipChar();
  440.     }
  441. }
  443. void CObjectIStreamAsn::ReadAnyContentObject(CAnyContentObject& obj)
  444. {
  445.     CLightString id = ReadMemberId(SkipWhiteSpace());
  446.     obj.SetName( id);
  447.     string value;
  448.     ReadAnyContent(value);
  449.     obj.SetValue(value);
  450. }
  452. void CObjectIStreamAsn::SkipAnyContentObject(void)
  453. {
  454.     CAnyContentObject obj;
  455.     ReadAnyContentObject(obj);
  456. }
  458. string CObjectIStreamAsn::ReadFileHeader()
  459. {
  460.     CLightString id = ReadTypeId(SkipWhiteSpace());
  461.     string s(id);
  462.     if ( SkipWhiteSpace() == ':' && 
  463.          m_Input.PeekCharNoEOF(1) == ':' &&
  464.          m_Input.PeekCharNoEOF(2) == '=' ) {
  465.         m_Input.SkipChars(3);
  466.     }
  467.     else
  468.         ThrowError(fFormatError, "'::=' expected");
  469.     return s;
  470. }
  472. TEnumValueType CObjectIStreamAsn::ReadEnum(const CEnumeratedTypeValues& values)
  473. {
  474.     // not integer
  475.     CLightString id = ReadLCaseId(SkipWhiteSpace());
  476.     if ( !id.Empty() ) {
  477.         // enum element by name
  478.         return values.FindValue(id);
  479.     }
  480.     // enum element by value
  481.     TEnumValueType value = m_Input.GetInt4();
  482.     if ( !values.IsInteger() ) // check value
  483.         values.FindName(value, false);
  484.     
  485.     return value;
  486. }
  488. bool CObjectIStreamAsn::ReadBool(void)
  489. {
  490.     switch ( SkipWhiteSpace() ) {
  491.     case 'T':
  492.         if ( m_Input.PeekCharNoEOF(1) == 'R' &&
  493.              m_Input.PeekCharNoEOF(2) == 'U' &&
  494.              m_Input.PeekCharNoEOF(3) == 'E' &&
  495.              !IdChar(m_Input.PeekCharNoEOF(4)) ) {
  496.             m_Input.SkipChars(4);
  497.             return true;
  498.         }
  499.         break;
  500.     case 'F':
  501.         if ( m_Input.PeekCharNoEOF(1) == 'A' &&
  502.              m_Input.PeekCharNoEOF(2) == 'L' &&
  503.              m_Input.PeekCharNoEOF(3) == 'S' &&
  504.              m_Input.PeekCharNoEOF(4) == 'E' &&
  505.              !IdChar(m_Input.PeekCharNoEOF(5)) ) {
  506.             m_Input.SkipChars(5);
  507.             return false;
  508.         }
  509.         break;
  510.     }
  511.     ThrowError(fFormatError, "TRUE or FALSE expected");
  512.     return false;
  513. }
  515. char CObjectIStreamAsn::ReadChar(void)
  516. {
  517.     string s;
  518.     ReadString(s);
  519.     if ( s.size() != 1 ) {
  520.         ThrowError(fFormatError,
  521.                    """ + s + "": one char string expected");
  522.     }
  523.     return s[0];
  524. }
  526. Int4 CObjectIStreamAsn::ReadInt4(void)
  527. {
  528.     SkipWhiteSpace();
  529.     return m_Input.GetInt4();
  530. }
  532. Uint4 CObjectIStreamAsn::ReadUint4(void)
  533. {
  534.     SkipWhiteSpace();
  535.     return m_Input.GetUint4();
  536. }
  538. Int8 CObjectIStreamAsn::ReadInt8(void)
  539. {
  540.     SkipWhiteSpace();
  541.     return m_Input.GetInt8();
  542. }
  544. Uint8 CObjectIStreamAsn::ReadUint8(void)
  545. {
  546.     SkipWhiteSpace();
  547.     return m_Input.GetUint8();
  548. }
  550. double CObjectIStreamAsn::ReadDouble(void)
  551. {
  552.     Expect('{', true);
  553.     CLightString mantissaStr = ReadNumber();
  554.     size_t mantissaLength = mantissaStr.GetLength();
  555.     char buffer[128];
  556.     if ( mantissaLength >= sizeof(buffer) - 1 )
  557.         ThrowError(fFormatError, "buffer overflow");
  558.     memcpy(buffer, mantissaStr.GetString(), mantissaLength);
  559.     buffer[mantissaLength] = '';
  560.     char* endptr;
  561.     double mantissa = strtod(buffer, &endptr);
  562.     if ( *endptr != 0 )
  563.         ThrowError(fFormatError, "bad double in line "
  564.             + NStr::UIntToString(m_Input.GetLine()));
  565.     Expect(',', true);
  566.     unsigned base = ReadUint4();
  567.     Expect(',', true);
  568.     int exp = ReadInt4();
  569.     Expect('}', true);
  570.     if ( base != 2 && base != 10 )
  571.         ThrowError(fFormatError, "illegal REAL base (must be 2 or 10)");
  573.     if ( base == 10 ) {     /* range checking only on base 10, for doubles */
  574.         if ( exp > DBL_MAX_10_EXP )   /* exponent too big */
  575.             ThrowError(fOverflow, "double overflow");
  576.         else if ( exp < DBL_MIN_10_EXP )  /* exponent too small */
  577.             return 0;
  578.     }
  580.     return mantissa * pow(double(base), exp);
  581. }
  583. void CObjectIStreamAsn::BadStringChar(size_t startLine, char c)
  584. {
  585.     ThrowError(fFormatError,
  586.                "bad char in string starting at line "+
  587.                NStr::UIntToString(startLine)+": "+
  588.                NStr::IntToString(c));
  589. }
  591. void CObjectIStreamAsn::UnendedString(size_t startLine)
  592. {
  593.     ThrowError(fFormatError,
  594.                "unclosed string starts at line "+
  595.                NStr::UIntToString(startLine));
  596. }
  599. inline
  600. void CObjectIStreamAsn::AppendStringData(string& s,
  601.                                          size_t count,
  602.                                          EFixNonPrint fix_method,
  603.                                          size_t line)
  604. {
  605.     const char* data = m_Input.GetCurrentPos();
  606.     if ( fix_method != eFNP_Allow ) {
  607.         size_t done = 0;
  608.         for ( size_t i = 0; i < count; ++i ) {
  609.             char c = data[i];
  610.             if ( !GoodVisibleChar(c) ) {
  611.                 if ( i > done ) {
  612.                     s.append(data + done, i - done);
  613.                 }
  614.                 FixVisibleChar(c, fix_method, line);
  615.                 s += c;
  616.                 done = i + 1;
  617.             }
  618.         }
  619.         if ( done < count ) {
  620.             s.append(data + done, count - done);
  621.         }
  622.     }
  623.     else {
  624.         s.append(data, count);
  625.     }
  626.     if ( count > 0 ) {
  627.         m_Input.SkipChars(count);
  628.     }
  629. }
  632. void CObjectIStreamAsn::AppendLongStringData(string& s,
  633.                                              size_t count,
  634.                                              EFixNonPrint fix_method,
  635.                                              size_t line)
  636. {
  637.     // Reserve extra-space to reduce heap reallocation
  638.     if ( s.empty() ) {
  639.         s.reserve(count*2);
  640.     }
  641.     else if ( s.capacity() < (s.size()+1)*1.1 ) {
  642.         s.reserve(s.size()*2);
  643.     }
  644.     AppendStringData(s, count, fix_method, line);
  645. }
  648. void CObjectIStreamAsn::ReadStringValue(string& s, EFixNonPrint fix_method)
  649. {
  650.     Expect('"', true);
  651.     size_t startLine = m_Input.GetLine();
  652.     size_t i = 0;
  653.     s.erase();
  654.     try {
  655.         for (;;) {
  656.             char c = m_Input.PeekChar(i);
  657.             switch ( c ) {
  658.             case 'r':
  659.             case 'n':
  660.                 // flush string
  661.                 AppendLongStringData(s, i, fix_method, startLine);
  662.                 m_Input.SkipChar(); // 'r' or 'n'
  663.                 i = 0;
  664.                 // skip end of line
  665.                 SkipEndOfLine(c);
  666.                 break;
  667.             case '"':
  668.                 s.reserve(s.size() + i);
  669.                 AppendStringData(s, i, fix_method, startLine);
  670.                 m_Input.SkipChar(); // quote
  671.                 if ( m_Input.PeekCharNoEOF() != '"' ) {
  672.                     // end of string
  673.                     return;
  674.                 }
  675.                 else {
  676.                     // double quote -> one quote
  677.                     i = 1;
  678.                 }
  679.                 break;
  680.             default:
  681.                 // ok: append char
  682.                 if ( ++i == 128 ) {
  683.                     // too long string -> flush it
  684.                     AppendLongStringData(s, i, fix_method, startLine);
  685.                     i = 0;
  686.                 }
  687.                 break;
  688.             }
  689.         }
  690.     }
  691.     catch ( CEofException& ) {
  692.         UnendedString(startLine);
  693.         throw;
  694.     }
  695. }
  697. void CObjectIStreamAsn::ReadString(string& s, EStringType type)
  698. {
  699.     ReadStringValue(s, type == eStringTypeUTF8? eFNP_Allow: m_FixMethod);
  700. }
  702. void CObjectIStreamAsn::SkipBool(void)
  703. {
  704.     switch ( SkipWhiteSpace() ) {
  705.     case 'T':
  706.         if ( m_Input.PeekCharNoEOF(1) == 'R' &&
  707.              m_Input.PeekCharNoEOF(2) == 'U' &&
  708.              m_Input.PeekCharNoEOF(3) == 'E' &&
  709.              !IdChar(m_Input.PeekCharNoEOF(4)) ) {
  710.             m_Input.SkipChars(4);
  711.             return;
  712.         }
  713.         break;
  714.     case 'F':
  715.         if ( m_Input.PeekCharNoEOF(1) == 'A' &&
  716.              m_Input.PeekCharNoEOF(2) == 'L' &&
  717.              m_Input.PeekCharNoEOF(3) == 'S' &&
  718.              m_Input.PeekCharNoEOF(4) == 'E' &&
  719.              !IdChar(m_Input.PeekCharNoEOF(5)) ) {
  720.             m_Input.SkipChars(5);
  721.             return;
  722.         }
  723.         break;
  724.     }
  725.     ThrowError(fFormatError, "TRUE or FALSE expected");
  726. }
  728. void CObjectIStreamAsn::SkipChar(void)
  729. {
  730.     // TODO: check string length to be 1
  731.     SkipString();
  732. }
  734. void CObjectIStreamAsn::SkipSNumber(void)
  735. {
  736.     size_t i;
  737.     char c = SkipWhiteSpace();
  738.     switch ( c ) {
  739.     case '-':
  740.     case '+':
  741.         c = m_Input.PeekChar(1);
  742.         // next char
  743.         i = 2;
  744.         break;
  745.     default:
  746.         // next char
  747.         i = 1;
  748.         break;
  749.     }
  750.     if ( c < '0' || c > '9' ) {
  751.         ThrowError(fFormatError, "bad signed integer in line "
  752.             + NStr::UIntToString(m_Input.GetLine()));
  753.     }
  754.     while ( (c = m_Input.PeekChar(i)) >= '0' && c <= '9' ) {
  755.         ++i;
  756.     }
  757.     m_Input.SkipChars(i);
  758. }
  760. void CObjectIStreamAsn::SkipUNumber(void)
  761. {
  762.     size_t i;
  763.     char c = SkipWhiteSpace();
  764.     switch ( c ) {
  765.     case '+':
  766.         c = m_Input.PeekChar(1);
  767.         // next char
  768.         i = 2;
  769.         break;
  770.     default:
  771.         // next char
  772.         i = 1;
  773.         break;
  774.     }
  775.     if ( c < '0' || c > '9' ) {
  776.         ThrowError(fFormatError, "bad unsigned integer in line "
  777.             + NStr::UIntToString(m_Input.GetLine()));
  778.     }
  779.     while ( (c = m_Input.PeekCharNoEOF(i)) >= '0' && c <= '9' ) {
  780.         ++i;
  781.     }
  782.     m_Input.SkipChars(i);
  783. }
  785. void CObjectIStreamAsn::SkipFNumber(void)
  786. {
  787.     Expect('{', true);
  788.     SkipSNumber();
  789.     Expect(',', true);
  790.     unsigned base = ReadUint4();
  791.     Expect(',', true);
  792.     SkipSNumber();
  793.     Expect('}', true);
  794.     if ( base != 2 && base != 10 )
  795.         ThrowError(fFormatError, "illegal REAL base (must be 2 or 10)");
  796. }
  798. void CObjectIStreamAsn::SkipString(EStringType type)
  799. {
  800.     Expect('"', true);
  801.     size_t startLine = m_Input.GetLine();
  802.     size_t i = 0;
  803.     try {
  804.         for (;;) {
  805.             char c = m_Input.PeekChar(i);
  806.             switch ( c ) {
  807.             case 'r':
  808.             case 'n':
  809.                 // flush string
  810.                 m_Input.SkipChars(i + 1);
  811.                 i = 0;
  812.                 // skip end of line
  813.                 SkipEndOfLine(c);
  814.                 break;
  815.             case '"':
  816.                 if ( m_Input.PeekChar(i + 1) == '"' ) {
  817.                     // double quote -> one quote
  818.                     m_Input.SkipChars(i + 2);
  819.                     i = 0;
  820.                 }
  821.                 else {
  822.                     // end of string
  823.                     m_Input.SkipChars(i + 1);
  824.                     return;
  825.                 }
  826.                 break;
  827.             default:
  828.                 if (type == eStringTypeVisible) {
  829.                     FixVisibleChar(c, m_FixMethod, startLine);
  830.                 }
  831.                 // ok: skip char
  832.                 if ( ++i == 128 ) {
  833.                     // too long string -> flush it
  834.                     m_Input.SkipChars(i);
  835.                     i = 0;
  836.                 }
  837.                 break;
  838.             }
  839.         }
  840.     }
  841.     catch ( CEofException& ) {
  842.         UnendedString(startLine);
  843.         throw;
  844.     }
  845. }
  847. void CObjectIStreamAsn::SkipNull(void)
  848. {
  849.     if ( SkipWhiteSpace() == 'N' &&
  850.          m_Input.PeekCharNoEOF(1) == 'U' &&
  851.          m_Input.PeekCharNoEOF(2) == 'L' &&
  852.          m_Input.PeekCharNoEOF(3) == 'L' &&
  853.          !IdChar(m_Input.PeekCharNoEOF(4)) ) {
  854.         m_Input.SkipChars(4);
  855.         return;
  856.     }
  857.     ThrowError(fFormatError, "NULL expected");
  858. }
  860. void CObjectIStreamAsn::SkipByteBlock(void)
  861. {
  862.     Expect(''', true);
  863.     for ( ;; ) {
  864.         char c = GetChar();
  865.         if ( c >= '0' && c <= '9' ) {
  866.             continue;
  867.         }
  868.         else if ( c >= 'A' && c <= 'Z' ) {
  869.             continue;
  870.         }
  871.         else if ( c >= 'a' && c <= 'z' ) {
  872.             continue;
  873.         }
  874.         else if ( c == ''' ) {
  875.             break;
  876.         }
  877.         else if ( c == 'r' || c == 'n' ) {
  878.             SkipEndOfLine(c);
  879.         }
  880.         else {
  881.             m_Input.UngetChar(c);
  882.             ThrowError(fFormatError, "bad char in octet string: #"
  883.                 + NStr::IntToString(c));
  884.         }
  885.     }
  886.     Expect('H', true);
  887. }
  889. void CObjectIStreamAsn::StartBlock(void)
  890. {
  891.     Expect('{', true);
  892.     m_BlockStart = true;
  893. }
  895. bool CObjectIStreamAsn::NextElement(void)
  896. {
  897.     char c = SkipWhiteSpace();
  898.     if ( m_BlockStart ) {
  899.         // first element
  900.         m_BlockStart = false;
  901.         return c != '}';
  902.     }
  903.     else {
  904.         // next element
  905.         if ( c == ',' ) {
  906.             m_Input.SkipChar();
  907.             return true;
  908.         }
  909.         else if ( c != '}' )
  910.             ThrowError(fFormatError, "',' or '}' expected");
  911.         return false;
  912.     }
  913. }
  915. void CObjectIStreamAsn::EndBlock(void)
  916. {
  917.     Expect('}');
  918. }
  920. void CObjectIStreamAsn::BeginContainer(const CContainerTypeInfo* /*cType*/)
  921. {
  922.     StartBlock();
  923. }
  925. void CObjectIStreamAsn::EndContainer(void)
  926. {
  927.     EndBlock();
  928. }
  930. bool CObjectIStreamAsn::BeginContainerElement(TTypeInfo /*elementType*/)
  931. {
  932.     return NextElement();
  933. }
  935. #ifdef VIRTUAL_MID_LEVEL_IO
  936. void CObjectIStreamAsn::ReadContainer(const CContainerTypeInfo* contType,
  937.                                       TObjectPtr contPtr)
  938. {
  939.     StartBlock();
  940.     
  941.     BEGIN_OBJECT_FRAME(eFrameArrayElement);
  943.     CContainerTypeInfo::CIterator iter;
  944.     bool old_element = contType->InitIterator(iter, contPtr);
  945.     TTypeInfo elementType = contType->GetElementType();
  946.     while ( NextElement() ) {
  947.         if ( old_element ) {
  948.             elementType->ReadData(*this, contType->GetElementPtr(iter));
  949.             old_element = contType->NextElement(iter);
  950.         }
  951.         else {
  952.             contType->AddElement(contPtr, *this);
  953.         }
  954.     }
  955.     if ( old_element ) {
  956.         contType->EraseAllElements(iter);
  957.     }
  959.     END_OBJECT_FRAME();
  961.     EndBlock();
  962. }
  964. void CObjectIStreamAsn::SkipContainer(const CContainerTypeInfo* contType)
  965. {
  966.     StartBlock();
  968.     TTypeInfo elementType = contType->GetElementType();
  969.     BEGIN_OBJECT_FRAME(eFrameArrayElement);
  971.     while ( NextElement() ) {
  972.         SkipObject(elementType);
  973.     }
  975.     END_OBJECT_FRAME();
  977.     EndBlock();
  978. }
  979. #endif
  981. void CObjectIStreamAsn::BeginClass(const CClassTypeInfo* /*classInfo*/)
  982. {
  983.     StartBlock();
  984. }
  986. void CObjectIStreamAsn::EndClass(void)
  987. {
  988.     EndBlock();
  989. }
  991. void CObjectIStreamAsn::UnexpectedMember(const CLightString& id,
  992.                                          const CItemsInfo& items)
  993. {
  994.     string message =
  995.         """+string(id)+"": unexpected member, should be one of: ";
  996.     for ( CItemsInfo::CIterator i(items); i.Valid(); ++i ) {
  997.         message += '"' + items.GetItemInfo(i)->GetId().ToString() + "" ";
  998.     }
  999.     ThrowError(fFormatError, message);
  1000. }
  1002. TMemberIndex
  1003. CObjectIStreamAsn::BeginClassMember(const CClassTypeInfo* classType)
  1004. {
  1005.     if ( !NextElement() )
  1006.         return kInvalidMember;
  1008.     CLightString id = ReadMemberId(SkipWhiteSpace());
  1009.     TMemberIndex index = GetMemberIndex(classType, id);
  1010.     if ( index == kInvalidMember ) {
  1011.         if (GetSkipUnknownMembers() == eSerialSkipUnknown_Yes) {
  1012.             string value;
  1013.             ReadAnyContent(value);
  1014.             return BeginClassMember(classType);
  1015.         } else {
  1016.             UnexpectedMember(id, classType->GetMembers());
  1017.         }
  1018.     }
  1019.     return index;
  1020. }
  1022. TMemberIndex
  1023. CObjectIStreamAsn::BeginClassMember(const CClassTypeInfo* classType,
  1024.                                     TMemberIndex pos)
  1025. {
  1026.     if ( !NextElement() )
  1027.         return kInvalidMember;
  1029.     CLightString id = ReadMemberId(SkipWhiteSpace());
  1030.     TMemberIndex index = GetMemberIndex(classType, id, pos);
  1031.     if ( index == kInvalidMember ) {
  1032.         if (GetSkipUnknownMembers() == eSerialSkipUnknown_Yes) {
  1033.             string value;
  1034.             ReadAnyContent(value);
  1035.             return BeginClassMember(classType, pos);
  1036.         } else {
  1037.             UnexpectedMember(id, classType->GetMembers());
  1038.         }
  1039.     }
  1040.     return index;
  1041. }
  1043. #ifdef VIRTUAL_MID_LEVEL_IO
  1044. void CObjectIStreamAsn::ReadClassRandom(const CClassTypeInfo* classType,
  1045.                                         TObjectPtr classPtr)
  1046. {
  1047.     StartBlock();
  1048.     
  1049.     ReadClassRandomContentsBegin(classType);
  1051.     TMemberIndex index;
  1052.     while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
  1053.         ReadClassRandomContentsMember(classPtr);
  1054.     }
  1056.     ReadClassRandomContentsEnd();
  1057.     
  1058.     EndBlock();
  1059. }
  1061. void CObjectIStreamAsn::ReadClassSequential(const CClassTypeInfo* classType,
  1062.                                             TObjectPtr classPtr)
  1063. {
  1064.     StartBlock();
  1065.     
  1066.     ReadClassSequentialContentsBegin(classType);
  1068.     TMemberIndex index;
  1069.     while ( (index = BeginClassMember(classType,*pos)) != kInvalidMember ) {
  1070.         ReadClassSequentialContentsMember(classPtr);
  1071.     }
  1073.     ReadClassSequentialContentsEnd(classPtr);
  1074.     
  1075.     EndBlock();
  1076. }
  1078. void CObjectIStreamAsn::SkipClassRandom(const CClassTypeInfo* classType)
  1079. {
  1080.     StartBlock();
  1081.     
  1082.     SkipClassRandomContentsBegin(classType);
  1084.     TMemberIndex index;
  1085.     while ( (index = BeginClassMember(classType)) != kInvalidMember ) {
  1086.         SkipClassRandomContentsMember();
  1087.     }
  1089.     SkipClassRandomContentsEnd();
  1090.     
  1091.     EndBlock();
  1092. }
  1094. void CObjectIStreamAsn::SkipClassSequential(const CClassTypeInfo* classType)
  1095. {
  1096.     StartBlock();
  1097.     
  1098.     SkipClassSequentialContentsBegin(classType);
  1100.     TMemberIndex index;
  1101.     while ( (index = BeginClassMember(classType,*pos)) != kInvalidMember ) {
  1102.         SkipClassSequentialContentsMember();
  1103.     }
  1105.     SkipClassSequentialContentsEnd();
  1106.     
  1107.     EndBlock();
  1108. }
  1109. #endif
  1111. TMemberIndex CObjectIStreamAsn::BeginChoiceVariant(const CChoiceTypeInfo* choiceType)
  1112. {
  1113.     CLightString id = ReadMemberId(SkipWhiteSpace());
  1114.     if ( id.Empty() )
  1115.         ThrowError(fFormatError, "choice variant id expected");
  1117.     TMemberIndex index = GetChoiceIndex(choiceType, id);
  1118.     if ( index == kInvalidMember )
  1119.         UnexpectedMember(id, choiceType->GetVariants());
  1121.     return index;
  1122. }
  1124. #ifdef VIRTUAL_MID_LEVEL_IO
  1125. void CObjectIStreamAsn::ReadChoice(const CChoiceTypeInfo* choiceType,
  1126.                                    TObjectPtr choicePtr)
  1127. {
  1128.     TMemberIndex index = BeginChoiceVariant(choiceType);
  1130.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1131.     BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());
  1133.     variantInfo->ReadVariant(*this, choicePtr);
  1135.     END_OBJECT_FRAME();
  1136. }
  1138. void CObjectIStreamAsn::SkipChoice(const CChoiceTypeInfo* choiceType)
  1139. {
  1140.     TMemberIndex index = BeginChoiceVariant(choiceType);
  1142.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1143.     BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());
  1145.     variantInfo->SkipVariant(*this);
  1147.     END_OBJECT_FRAME();
  1148. }
  1149. #endif
  1151. void CObjectIStreamAsn::BeginBytes(ByteBlock& )
  1152. {
  1153.     Expect(''', true);
  1154. }
  1156. int CObjectIStreamAsn::GetHexChar(void)
  1157. {
  1158.     for ( ;; ) {
  1159.         char c = GetChar();
  1160.         if ( c >= '0' && c <= '9' ) {
  1161.             return c - '0';
  1162.         }
  1163.         else if ( c >= 'A' && c <= 'F' ) {
  1164.             return c - 'A' + 10;
  1165.         }
  1166.         else if ( c >= 'a' && c <= 'f' ) {
  1167.             return c - 'a' + 10;
  1168.         }
  1169.         switch ( c ) {
  1170.         case ''':
  1171.             return -1;
  1172.         case 'r':
  1173.         case 'n':
  1174.             SkipEndOfLine(c);
  1175.             break;
  1176.         default:
  1177.             m_Input.UngetChar(c);
  1178.             ThrowError(fFormatError, "bad char in octet string: #"
  1179.                 + NStr::IntToString(c));
  1180.         }
  1181.     }
  1182. }
  1184. size_t CObjectIStreamAsn::ReadBytes(ByteBlock& block,
  1185.                                     char* dst, size_t length)
  1186. {
  1187.     size_t count = 0;
  1188.     while ( length-- > 0 ) {
  1189.         int c1 = GetHexChar();
  1190.         if ( c1 < 0 ) {
  1191.             block.EndOfBlock();
  1192.             return count;
  1193.         }
  1194.         int c2 = GetHexChar();
  1195.         if ( c2 < 0 ) {
  1196.             *dst++ = c1 << 4;
  1197.             count++;
  1198.             block.EndOfBlock();
  1199.             return count;
  1200.         }
  1201.         else {
  1202.             *dst++ = (c1 << 4) | c2;
  1203.             count++;
  1204.         }
  1205.     }
  1206.     return count;
  1207. }
  1209. void CObjectIStreamAsn::EndBytes(const ByteBlock& )
  1210. {
  1211.     Expect('H');
  1212. }
  1214. void CObjectIStreamAsn::BeginChars(CharBlock& )
  1215. {
  1216.     Expect('"', true);
  1217. }
  1219. size_t CObjectIStreamAsn::ReadChars(CharBlock& block,
  1220.                                     char* dst, size_t length)
  1221. {
  1222.     size_t count = 0;
  1223.     try {
  1224.         while (length-- > 0) {
  1225.             char c = m_Input.GetChar();
  1226.             switch ( c ) {
  1227.             case 'r':
  1228.             case 'n':
  1229.                 break;
  1230.             case '"':
  1231.                 if ( m_Input.PeekCharNoEOF() == '"' ) {
  1232.                     m_Input.SkipChar();
  1233.                     dst[count++] = c;
  1234.                 }
  1235.                 else {
  1236.                     // end of string
  1237.                     // Check the string for non-printable characters
  1238.                     EFixNonPrint fix_method = m_FixMethod;
  1239.                     if ( fix_method != eFNP_Allow ) {
  1240.                         size_t line = m_Input.GetLine();
  1241.                         for (size_t i = 0;  i < count;  i++) {
  1242.                             FixVisibleChar(dst[i], fix_method, line);
  1243.                         }
  1244.                     }
  1245.                     block.EndOfBlock();
  1246.                     return count;
  1247.                 }
  1248.                 break;
  1249.             default:
  1250.                 // ok: append char
  1251.                 {
  1252.                     dst[count++] = c;
  1253.                 }
  1254.                 break;
  1255.             }
  1256.         }
  1257.     }
  1258.     catch ( CEofException& ) {
  1259.         UnendedString(m_Input.GetLine());
  1260.         throw;
  1261.     }
  1262.     return count;
  1263. }
  1265. CObjectIStream::EPointerType CObjectIStreamAsn::ReadPointerType(void)
  1266. {
  1267.     switch ( PeekChar(true) ) {
  1268.     case 'N':
  1269.         if ( m_Input.PeekCharNoEOF(1) == 'U' &&
  1270.              m_Input.PeekCharNoEOF(2) == 'L' &&
  1271.              m_Input.PeekCharNoEOF(3) == 'L' &&
  1272.              !IdChar(m_Input.PeekCharNoEOF(4)) ) {
  1273.             // "NULL"
  1274.             m_Input.SkipChars(4);
  1275.             return eNullPointer;
  1276.         }
  1277.         break;
  1278.     case '@':
  1279.         m_Input.SkipChar();
  1280.         return eObjectPointer;
  1281.     case ':':
  1282.         m_Input.SkipChar();
  1283.         return eOtherPointer;
  1284.     default:
  1285.         break;
  1286.     }
  1287.     return eThisPointer;
  1288. }
  1290. CObjectIStream::TObjectIndex CObjectIStreamAsn::ReadObjectPointer(void)
  1291. {
  1292.     if ( sizeof(TObjectIndex) == sizeof(Int4) )
  1293.         return ReadInt4();
  1294.     else if ( sizeof(TObjectIndex) == sizeof(Int8) )
  1295.         return TObjectIndex(ReadInt8());
  1296.     else
  1297.         ThrowError(fIllegalCall, "invalid size of TObjectIndex:"
  1298.             " must be either sizeof(Int4) or sizeof(Int8)");
  1299.     return 0;
  1300. }
  1302. string CObjectIStreamAsn::ReadOtherPointer(void)
  1303. {
  1304.     return ReadTypeId(SkipWhiteSpace());
  1305. }
  1307. END_NCBI_SCOPE
  1309. /* ---------------------------------------------------------------------------
  1310. * $Log: objistrasn.cpp,v $
  1311. * Revision 1000.3  2004/06/01 19:40:57  gouriano
  1312. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.92
  1313. *
  1314. * Revision 1.92  2004/05/17 21:03:03  gorelenk
  1315. * Added include of PCH ncbi_pch.hpp
  1316. *
  1317. * Revision 1.91  2004/05/04 17:05:17  gouriano
  1318. * Check double for overflow
  1319. *
  1320. * Revision 1.90  2004/03/23 15:39:23  gouriano
  1321. * Added setup options for skipping unknown data members
  1322. *
  1323. * Revision 1.89  2004/03/09 16:16:59  gouriano
  1324. * Corrected reading of sequential data
  1325. *
  1326. * Revision 1.88  2004/03/05 20:29:38  gouriano
  1327. * make it possible to skip unknown data fields
  1328. *
  1329. * Revision 1.87  2003/11/26 19:59:40  vasilche
  1330. * GetPosition() and GetDataFormat() methods now are implemented
  1331. * in parent classes CObjectIStream and CObjectOStream to avoid
  1332. * pure virtual method call in destructors.
  1333. *
  1334. * Revision 1.86  2003/08/25 15:59:09  gouriano
  1335. * added possibility to use namespaces in XML i/o streams
  1336. *
  1337. * Revision 1.85  2003/08/19 18:32:38  vasilche
  1338. * Optimized reading and writing strings.
  1339. * Avoid string reallocation when checking char values.
  1340. * Try to reuse old string data when string reference counting is not working.
  1341. *
  1342. * Revision 1.84  2003/08/14 20:03:58  vasilche
  1343. * Avoid memory reallocation when reading over preallocated object.
  1344. * Simplified CContainerTypeInfo iterators interface.
  1345. *
  1346. * Revision 1.83  2003/08/13 15:47:44  gouriano
  1347. * implemented serialization of AnyContent objects
  1348. *
  1349. * Revision 1.82  2003/05/22 20:10:02  gouriano
  1350. * added UTF8 strings
  1351. *
  1352. * Revision 1.81  2003/05/16 18:02:18  gouriano
  1353. * revised exception error messages
  1354. *
  1355. * Revision 1.80  2003/02/28 15:09:28  gouriano
  1356. * pass CEofException if there is no object in the input stream
  1357. *
  1358. * Revision 1.79  2002/12/23 19:00:49  dicuccio
  1359. * Tabs -> Spaces.  Lof to end.
  1360. *
  1361. * Revision 1.78  2002/12/23 18:41:49  dicuccio
  1362. * Minor tweaks to avoid warnings in MSVC
  1363. *
  1364. * Revision 1.77  2002/11/18 19:49:36  grichenk
  1365. * More details in error messages
  1366. *
  1367. * Revision 1.76  2002/11/05 17:45:54  grichenk
  1368. * Throw runtime_error instead of CEofException when a stream is broken
  1369. *
  1370. * Revision 1.75  2002/10/25 14:49:27  vasilche
  1371. * NCBI C Toolkit compatibility code extracted to libxcser library.
  1372. * Serial streams flags names were renamed to fXxx.
  1373. *
  1374. * Names of flags
  1375. *
  1376. * Revision 1.74  2001/12/09 07:42:25  vakatov
  1377. * Fixed a warning
  1378. *
  1379. * Revision 1.73  2001/10/17 20:41:23  grichenk
  1380. * Added CObjectOStream::CharBlock class
  1381. *
  1382. * Revision 1.72  2001/10/16 17:15:47  grichenk
  1383. * Fixed bug in CObjectIStreamAsn::ReadString()
  1384. *
  1385. * Revision 1.71  2001/08/02 22:28:42  grichenk
  1386. * Added memory pre-allocation on n for long strings
  1387. *
  1388. * Revision 1.70  2001/07/25 19:12:25  grichenk
  1389. * Added memory pre-allocation for long strings
  1390. *
  1391. * Revision 1.69  2001/06/11 14:35:00  grichenk
  1392. * Added support for numeric tags in ASN.1 specifications and data streams.
  1393. *
  1394. * Revision 1.68  2001/06/07 17:12:50  grichenk
  1395. * Redesigned checking and substitution of non-printable characters
  1396. * in VisibleString
  1397. *
  1398. * Revision 1.67  2001/05/17 15:07:08  lavr
  1399. * Typos corrected
  1400. *
  1401. * Revision 1.66  2001/01/22 23:12:05  vakatov
  1402. * CObjectIStreamAsn::{Read,Skip}ClassSequential() -- use curr.member "pos"
  1403. *
  1404. * Revision 1.65  2001/01/05 20:10:51  vasilche
  1405. * CByteSource, CIStrBuffer, COStrBuffer, CLightString, CChecksum, CWeakMap
  1406. * were moved to util.
  1407. *
  1408. * Revision 1.64  2001/01/03 15:22:26  vasilche
  1409. * Fixed limited buffer size for REAL data in ASN.1 binary format.
  1410. * Fixed processing non ASCII symbols in ASN.1 text format.
  1411. *
  1412. * Revision 1.63  2000/12/26 22:24:11  vasilche
  1413. * Fixed errors of compilation on Mac.
  1414. *
  1415. * Revision 1.62  2000/12/15 21:29:01  vasilche
  1416. * Moved some typedefs/enums from corelib/ncbistd.hpp.
  1417. * Added flags to CObjectIStream/CObjectOStream: eFlagAllowNonAsciiChars.
  1418. * TByte typedef replaced by Uint1.
  1419. *
  1420. * Revision 1.61  2000/12/15 15:38:44  vasilche
  1421. * Added support of Int8 and long double.
  1422. * Enum values now have type Int4 instead of long.
  1423. *
  1424. * Revision 1.60  2000/11/20 17:25:36  vasilche
  1425. * Added prototypes of functions.
  1426. *
  1427. * Revision 1.59  2000/10/20 15:51:41  vasilche
  1428. * Fixed data error processing.
  1429. * Added interface for constructing container objects directly into output stream.
  1430. * object.hpp, object.inl and object.cpp were split to
  1431. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  1432. *
  1433. * Revision 1.58  2000/10/17 18:45:34  vasilche
  1434. * Added possibility to turn off object cross reference detection in
  1435. * CObjectIStream and CObjectOStream.
  1436. *
  1437. * Revision 1.57  2000/10/04 19:18:59  vasilche
  1438. * Fixed processing floating point data.
  1439. *
  1440. * Revision 1.56  2000/10/03 17:22:43  vasilche
  1441. * Reduced header dependency.
  1442. * Reduced size of debug libraries on WorkShop by 3 times.
  1443. * Fixed tag allocation for parent classes.
  1444. * Fixed CObject allocation/deallocation in streams.
  1445. * Moved instantiation of several templates in separate source file.
  1446. *
  1447. * Revision 1.55  2000/09/29 16:18:23  vasilche
  1448. * Fixed binary format encoding/decoding on 64 bit compulers.
  1449. * Implemented CWeakMap<> for automatic cleaning map entries.
  1450. * Added cleaning local hooks via CWeakMap<>.
  1451. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  1452. * Added some user interface methods to CObjectIStream, CObjectOStream and
  1453. * CObjectStreamCopier.
  1454. *
  1455. * Revision 1.54  2000/09/18 20:00:23  vasilche
  1456. * Separated CVariantInfo and CMemberInfo.
  1457. * Implemented copy hooks.
  1458. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  1459. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  1460. *
  1461. * Revision 1.53  2000/09/01 13:16:17  vasilche
  1462. * Implemented class/container/choice iterators.
  1463. * Implemented CObjectStreamCopier for copying data without loading into memory.
  1464. *
  1465. * Revision 1.52  2000/08/15 19:44:49  vasilche
  1466. * Added Read/Write hooks:
  1467. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  1468. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  1469. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  1470. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  1471. *
  1472. * Revision 1.51  2000/07/03 20:47:22  vasilche
  1473. * Removed unused variables/functions.
  1474. *
  1475. * Revision 1.50  2000/07/03 20:39:55  vasilche
  1476. * Fixed comments.
  1477. *
  1478. * Revision 1.49  2000/07/03 18:42:45  vasilche
  1479. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  1480. * Reduced header dependency.
  1481. *
  1482. * Revision 1.48  2000/06/16 16:31:19  vasilche
  1483. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  1484. *
  1485. * Revision 1.47  2000/06/07 19:45:59  vasilche
  1486. * Some code cleaning.
  1487. * Macros renaming in more clear way.
  1488. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  1489. *
  1490. * Revision 1.46  2000/06/01 19:07:03  vasilche
  1491. * Added parsing of XML data.
  1492. *
  1493. * Revision 1.45  2000/05/24 20:08:47  vasilche
  1494. * Implemented XML dump.
  1495. *
  1496. * Revision 1.44  2000/05/09 16:38:39  vasilche
  1497. * CObject::GetTypeInfo now moved to CObjectGetTypeInfo::GetTypeInfo to reduce possible errors.
  1498. * Added write context to CObjectOStream.
  1499. * Inlined most of methods of helping class Member, Block, ByteBlock etc.
  1500. *
  1501. * Revision 1.43  2000/05/03 14:38:14  vasilche
  1502. * SERIAL: added support for delayed reading to generated classes.
  1503. * DATATOOL: added code generation for delayed reading.
  1504. *
  1505. * Revision 1.42  2000/04/28 16:58:12  vasilche
  1506. * Added classes CByteSource and CByteSourceReader for generic reading.
  1507. * Added delayed reading of choice variants.
  1508. *
  1509. * Revision 1.41  2000/04/13 14:50:27  vasilche
  1510. * Added CObjectIStream::Open() and CObjectOStream::Open() for easier use.
  1511. *
  1512. * Revision 1.40  2000/03/29 15:55:28  vasilche
  1513. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  1514. * Added generic iterators by class -
  1515. *   CTypeIterator<class>, CTypeConstIterator<class>,
  1516. *   CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  1517. *   CObjectsIterator and CObjectsConstIterator.
  1518. *
  1519. * Revision 1.39  2000/03/14 14:42:31  vasilche
  1520. * Fixed error reporting.
  1521. *
  1522. * Revision 1.38  2000/03/07 14:06:22  vasilche
  1523. * Added stream buffering to ASN.1 binary input.
  1524. * Optimized class loading/storing.
  1525. * Fixed bugs in processing OPTIONAL fields.
  1526. * Added generation of reference counted objects.
  1527. *
  1528. * Revision 1.37  2000/02/17 20:02:44  vasilche
  1529. * Added some standard serialization exceptions.
  1530. * Optimized text/binary ASN.1 reading.
  1531. * Fixed wrong encoding of StringStore in ASN.1 binary format.
  1532. * Optimized logic of object collection.
  1533. *
  1534. * Revision 1.36  2000/02/11 17:10:24  vasilche
  1535. * Optimized text parsing.
  1536. *
  1537. * Revision 1.35  2000/02/01 21:47:22  vasilche
  1538. * Added CGeneratedChoiceTypeInfo for generated choice classes.
  1539. * Added buffering to CObjectIStreamAsn.
  1540. * Removed CMemberInfo subclasses.
  1541. * Added support for DEFAULT/OPTIONAL members.
  1542. *
  1543. * Revision 1.34  2000/01/11 14:27:42  vasilche
  1544. * Found absent DBL_* macros in float.h
  1545. *
  1546. * Revision 1.33  2000/01/11 14:16:45  vasilche
  1547. * Fixed pow ambiguity.
  1548. *
  1549. * Revision 1.32  2000/01/10 19:46:40  vasilche
  1550. * Fixed encoding/decoding of REAL type.
  1551. * Fixed encoding/decoding of StringStore.
  1552. * Fixed encoding/decoding of NULL type.
  1553. * Fixed error reporting.
  1554. * Reduced object map (only classes).
  1555. *
  1556. * Revision 1.31  2000/01/05 19:43:54  vasilche
  1557. * Fixed error messages when reading from ASN.1 binary file.
  1558. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  1559. * Added TAG support to key/value of map.
  1560. * Added support of NULL variant in CHOICE.
  1561. *
  1562. * Revision 1.30  1999/12/17 19:05:03  vasilche
  1563. * Simplified generation of GetTypeInfo methods.
  1564. *
  1565. * Revision 1.29  1999/11/18 20:19:01  vakatov
  1566. * ExpectString() -- get rid of the CodeWarrior(MAC) C++ compiler warning
  1567. *
  1568. * Revision 1.28  1999/10/25 20:19:51  vasilche
  1569. * Fixed strings representation in text ASN.1 files.
  1570. *
  1571. * Revision 1.27  1999/10/04 16:22:17  vasilche
  1572. * Fixed bug with old ASN.1 structures.
  1573. *
  1574. * Revision 1.26  1999/09/24 18:19:18  vasilche
  1575. * Removed dependency on NCBI toolkit.
  1576. *
  1577. * Revision 1.25  1999/09/23 21:16:07  vasilche
  1578. * Removed dependence on asn.h
  1579. *
  1580. * Revision 1.24  1999/09/23 18:56:58  vasilche
  1581. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  1582. *
  1583. * Revision 1.23  1999/09/22 20:11:55  vasilche
  1584. * Modified for compilation on IRIX native c++ compiler.
  1585. *
  1586. * Revision 1.22  1999/08/17 15:13:06  vasilche
  1587. * Comments are allowed in ASN.1 text files.
  1588. * String values now parsed in accordance with ASN.1 specification.
  1589. *
  1590. * Revision 1.21  1999/08/13 15:53:50  vasilche
  1591. * C++ analog of asntool: datatool
  1592. *
  1593. * Revision 1.20  1999/07/26 18:31:35  vasilche
  1594. * Implemented skipping of unused values.
  1595. * Added more useful error report.
  1596. *
  1597. * Revision 1.19  1999/07/22 17:33:51  vasilche
  1598. * Unified reading/writing of objects in all three formats.
  1599. *
  1600. * Revision 1.18  1999/07/21 14:20:04  vasilche
  1601. * Added serialization of bool.
  1602. *
  1603. * Revision 1.17  1999/07/20 18:23:10  vasilche
  1604. * Added interface to old ASN.1 routines.
  1605. * Added fixed choice of subclasses to use for pointers.
  1606. *
  1607. * Revision 1.16  1999/07/19 15:50:33  vasilche
  1608. * Added interface to old ASN.1 routines.
  1609. * Added naming of key/value in STL map.
  1610. *
  1611. * Revision 1.15  1999/07/14 18:58:09  vasilche
  1612. * Fixed ASN.1 types/field naming.
  1613. *
  1614. * Revision 1.14  1999/07/13 20:18:18  vasilche
  1615. * Changed types naming.
  1616. *
  1617. * Revision 1.13  1999/07/09 16:32:54  vasilche
  1618. * Added OCTET STRING write/read.
  1619. *
  1620. * Revision 1.12  1999/07/07 21:15:02  vasilche
  1621. * Cleaned processing of string types (string, char*, const char*).
  1622. *
  1623. * Revision 1.11  1999/07/07 19:59:05  vasilche
  1624. * Reduced amount of data allocated on heap
  1625. * Cleaned ASN.1 structures info
  1626. *
  1627. * Revision 1.10  1999/07/07 18:18:32  vasilche
  1628. * Fixed some bugs found by MS VC++
  1629. *
  1630. * Revision 1.9  1999/07/02 21:31:55  vasilche
  1631. * Implemented reading from ASN.1 binary format.
  1632. *
  1633. * Revision 1.8  1999/07/01 17:55:30  vasilche
  1634. * Implemented ASN.1 binary write.
  1635. *
  1636. * Revision 1.7  1999/06/30 16:04:55  vasilche
  1637. * Added support for old ASN.1 structures.
  1638. *
  1639. * Revision 1.6  1999/06/24 14:44:55  vasilche
  1640. * Added binary ASN.1 output.
  1641. *
  1642. * Revision 1.5  1999/06/18 16:26:49  vasilche
  1643. * Fixed bug with unget() in MSVS
  1644. *
  1645. * Revision 1.4  1999/06/17 21:08:51  vasilche
  1646. * Fixed bug with unget()
  1647. *
  1648. * Revision 1.3  1999/06/17 20:42:05  vasilche
  1649. * Fixed storing/loading of pointers.
  1650. *
  1651. * Revision 1.2  1999/06/16 20:58:04  vasilche
  1652. * Added GetPtrTypeRef to avoid conflict in MSVS.
  1653. *
  1654. * Revision 1.1  1999/06/16 20:35:31  vasilche
  1655. * Cleaned processing of blocks of data.
  1656. * Added input from ASN.1 text format.
  1657. *
  1658. * Revision 1.7  1999/06/15 16:19:49  vasilche
  1659. * Added ASN.1 object output stream.
  1660. *
  1661. * Revision 1.6  1999/06/11 19:14:58  vasilche
  1662. * Working binary serialization and deserialization of first test object.
  1663. *
  1664. * Revision 1.5  1999/06/10 21:06:46  vasilche
  1665. * Working binary output and almost working binary input.
  1666. *
  1667. * Revision 1.4  1999/06/07 20:10:02  vasilche
  1668. * Avoid using of numeric_limits.
  1669. *
  1670. * Revision 1.3  1999/06/07 19:30:25  vasilche
  1671. * More bug fixes
  1672. *
  1673. * Revision 1.2  1999/06/04 20:51:45  vasilche
  1674. * First compilable version of serialization.
  1675. *
  1676. * Revision 1.1  1999/05/19 19:56:53  vasilche
  1677. * Commit just in case.
  1678. *
  1679. * ===========================================================================
  1680. */