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

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

生物技术

开发平台：

C/C++

objostrxml.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: objostrxml.cpp,v $
  4.  * PRODUCTION Revision 1000.5  2004/06/01 19:41:18  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.73
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: objostrxml.cpp,v 1000.5 2004/06/01 19:41:18 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. *   XML object output stream
  39. *
  40. * ---------------------------------------------------------------------------
  41. * $Log: objostrxml.cpp,v $
  42. * Revision 1000.5  2004/06/01 19:41:18  gouriano
  43. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.73
  44. *
  45. * Revision 1.73  2004/05/19 17:26:19  gouriano
  46. * Corrected serialization of containers when the code was generated by DTD
  47. *
  48. * Revision 1.72  2004/05/17 21:03:03  gorelenk
  49. * Added include of PCH ncbi_pch.hpp
  50. *
  51. * Revision 1.71  2004/05/04 17:04:43  gouriano
  52. * Check double for being finite
  53. *
  54. * Revision 1.70  2004/01/29 20:43:04  gouriano
  55. * Corrected writing of AnyContent objects in case it has attributes
  56. * with previously undefined namespaces, or tags with empty content
  57. *
  58. * Revision 1.69  2004/01/22 20:48:38  gouriano
  59. * corrected writing of namespace prefixes
  60. *
  61. * Revision 1.68  2004/01/08 17:42:00  gouriano
  62. * Added encoding Windows-1252.
  63. * Made it possible to omit document type declaration
  64. *
  65. * Revision 1.67  2003/11/26 19:59:41  vasilche
  66. * GetPosition() and GetDataFormat() methods now are implemented
  67. * in parent classes CObjectIStream and CObjectOStream to avoid
  68. * pure virtual method call in destructors.
  69. *
  70. * Revision 1.66  2003/11/21 16:16:48  vasilche
  71. * More efficient writing of hex numbers.
  72. *
  73. * Revision 1.65  2003/10/31 17:39:40  grichenk
  74. * Allow empty containers
  75. *
  76. * Revision 1.64  2003/09/25 19:44:08  gouriano
  77. * Corrected serialization of AnyContent object's attributes
  78. *
  79. * Revision 1.63  2003/09/22 20:55:23  gouriano
  80. * Corrected writing of AnyContent objects in case of no schema reference
  81. *
  82. * Revision 1.62  2003/09/16 14:48:36  gouriano
  83. * Enhanced AnyContent objects to support XML namespaces and attribute info items.
  84. *
  85. * Revision 1.61  2003/08/25 15:59:09  gouriano
  86. * added possibility to use namespaces in XML i/o streams
  87. *
  88. * Revision 1.60  2003/08/13 18:23:54  gouriano
  89. * corrected XML schema namespace name
  90. *
  91. * Revision 1.59  2003/08/13 15:47:45  gouriano
  92. * implemented serialization of AnyContent objects
  93. *
  94. * Revision 1.58  2003/07/02 13:01:29  gouriano
  95. * added ability to read/write XML files with reference to schema
  96. *
  97. * Revision 1.57  2003/06/30 15:39:48  gouriano
  98. * added encoding (utf-8 or iso-8859-1)
  99. *
  100. * Revision 1.56  2003/06/24 20:57:36  gouriano
  101. * corrected code generation and serialization of non-empty unnamed containers (XML)
  102. *
  103. * Revision 1.55  2003/05/22 20:10:02  gouriano
  104. * added UTF8 strings
  105. *
  106. * Revision 1.54  2003/05/16 18:02:18  gouriano
  107. * revised exception error messages
  108. *
  109. * Revision 1.53  2003/04/29 18:30:37  gouriano
  110. * object data member initialization verification
  111. *
  112. * Revision 1.52  2003/03/26 16:14:23  vasilche
  113. * Removed TAB symbols. Some formatting.
  114. *
  115. * Revision 1.51  2003/02/07 16:09:22  gouriano
  116. * correction of GetContainerElementTypeFamily for the case of copying objects
  117. *
  118. * Revision 1.50  2003/02/05 17:08:00  gouriano
  119. * added possibility to read/write objects generated from an ASN.1 spec as "standard" XML - without scope prefixes
  120. *
  121. * Revision 1.49  2003/02/04 17:06:25  gouriano
  122. * added check for NaN in WriteDouble
  123. *
  124. * Revision 1.48  2003/01/22 21:03:16  gouriano
  125. * remove trailing zeros when writing a float value
  126. *
  127. * Revision 1.47  2003/01/22 20:53:09  gouriano
  128. * more control on how a float value is to be written
  129. *
  130. * Revision 1.46  2003/01/21 19:32:26  gouriano
  131. * corrected reading containers of primitive types
  132. *
  133. * Revision 1.45  2003/01/10 17:48:41  gouriano
  134. * added check for empty container
  135. *
  136. * Revision 1.44  2003/01/10 16:54:10  gouriano
  137. * fixed a bug with optional class members
  138. *
  139. * Revision 1.43  2002/12/26 21:35:45  gouriano
  140. * corrected handling choice's XML attributes
  141. *
  142. * Revision 1.42  2002/12/26 19:32:34  gouriano
  143. * changed XML I/O streams to properly handle object copying
  144. *
  145. * Revision 1.41  2002/12/17 19:04:32  gouriano
  146. * corrected reading/writing of character references
  147. *
  148. * Revision 1.40  2002/12/12 21:08:07  gouriano
  149. * implemented handling of complex XML containers
  150. *
  151. * Revision 1.39  2002/11/26 22:10:31  gouriano
  152. * added unnamed lists of sequences (choices) as container elements
  153. *
  154. * Revision 1.38  2002/11/20 21:22:51  gouriano
  155. * corrected processing of unnamed sequences as choice variants
  156. *
  157. * Revision 1.37  2002/11/19 19:48:51  gouriano
  158. * added support of XML attributes of choice variants
  159. *
  160. * Revision 1.36  2002/11/14 21:00:18  gouriano
  161. * added support of XML attribute lists
  162. *
  163. * Revision 1.35  2002/10/25 14:49:27  vasilche
  164. * NCBI C Toolkit compatibility code extracted to libxcser library.
  165. * Serial streams flags names were renamed to fXxx.
  166. *
  167. * Names of flags
  168. *
  169. * Revision 1.34  2002/10/18 14:27:09  gouriano
  170. * added possibility to enable/disable/set public identifier
  171. *
  172. * Revision 1.33  2002/10/15 13:47:59  gouriano
  173. * modified to handle "standard" (generated from DTD) XML i/o
  174. *
  175. * Revision 1.32  2002/10/08 18:59:38  grichenk
  176. * Check for null pointers in containers (assert in debug mode,
  177. * warning in release).
  178. *
  179. * Revision 1.31  2002/09/25 19:37:36  gouriano
  180. * added the possibility of having no tag prefix in XML I/O streams
  181. *
  182. * Revision 1.30  2002/03/07 22:02:02  grichenk
  183. * Added "Separator" modifier for CObjectOStream
  184. *
  185. * Revision 1.29  2001/11/09 19:07:58  grichenk
  186. * Fixed DTDFilePrefix functions
  187. *
  188. * Revision 1.28  2001/10/17 20:41:26  grichenk
  189. * Added CObjectOStream::CharBlock class
  190. *
  191. * Revision 1.27  2001/10/17 18:18:30  grichenk
  192. * Added CObjectOStreamXml::xxxFilePrefix() and
  193. * CObjectOStreamXml::xxxFileName()
  194. *
  195. * Revision 1.26  2001/05/17 15:07:08  lavr
  196. * Typos corrected
  197. *
  198. * Revision 1.25  2001/04/25 20:41:53  vakatov
  199. * <limits.h>, <float.h>  --->  <corelib/ncbi_limits.h>
  200. *
  201. * Revision 1.24  2001/04/13 14:57:15  kholodov
  202. * Added: SetDTDFileName function to set DTD module name in XML header
  203. *
  204. * Revision 1.23  2000/12/26 22:24:14  vasilche
  205. * Fixed errors of compilation on Mac.
  206. *
  207. * Revision 1.22  2000/12/15 15:38:45  vasilche
  208. * Added support of Int8 and long double.
  209. * Enum values now have type Int4 instead of long.
  210. *
  211. * Revision 1.21  2000/12/04 19:02:41  beloslyu
  212. * changes for FreeBSD
  213. *
  214. * Revision 1.20  2000/11/07 17:25:41  vasilche
  215. * Fixed encoding of XML:
  216. *     removed unnecessary apostrophes in OCTET STRING
  217. *     removed unnecessary content in NULL
  218. * Added module names to CTypeInfo and CEnumeratedTypeValues
  219. *
  220. * Revision 1.19  2000/10/20 15:51:43  vasilche
  221. * Fixed data error processing.
  222. * Added interface for constructing container objects directly into output stream.
  223. * object.hpp, object.inl and object.cpp were split to
  224. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  225. *
  226. * Revision 1.18  2000/10/17 18:45:35  vasilche
  227. * Added possibility to turn off object cross reference detection in
  228. * CObjectIStream and CObjectOStream.
  229. *
  230. * Revision 1.17  2000/10/13 20:22:56  vasilche
  231. * Fixed warnings on 64 bit compilers.
  232. * Fixed missing typename in templates.
  233. *
  234. * Revision 1.16  2000/10/13 16:28:40  vasilche
  235. * Reduced header dependency.
  236. * Avoid use of templates with virtual methods.
  237. * Reduced amount of different maps used.
  238. * All this lead to smaller compiled code size (libraries and programs).
  239. *
  240. * Revision 1.15  2000/10/05 15:52:51  vasilche
  241. * Avoid using snprintf because it's missing on osf1_gcc
  242. *
  243. * Revision 1.14  2000/10/05 13:17:17  vasilche
  244. * Added missing #include <stdio.h>
  245. *
  246. * Revision 1.13  2000/10/04 19:19:00  vasilche
  247. * Fixed processing floating point data.
  248. *
  249. * Revision 1.12  2000/10/03 17:22:45  vasilche
  250. * Reduced header dependency.
  251. * Reduced size of debug libraries on WorkShop by 3 times.
  252. * Fixed tag allocation for parent classes.
  253. * Fixed CObject allocation/deallocation in streams.
  254. * Moved instantiation of several templates in separate source file.
  255. *
  256. * Revision 1.11  2000/09/29 16:18:24  vasilche
  257. * Fixed binary format encoding/decoding on 64 bit compulers.
  258. * Implemented CWeakMap<> for automatic cleaning map entries.
  259. * Added cleaning local hooks via CWeakMap<>.
  260. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  261. * Added some user interface methods to CObjectIStream, CObjectOStream and
  262. * CObjectStreamCopier.
  263. *
  264. * Revision 1.10  2000/09/26 17:38:22  vasilche
  265. * Fixed incomplete choiceptr implementation.
  266. * Removed temporary comments.
  267. *
  268. * Revision 1.9  2000/09/18 20:00:25  vasilche
  269. * Separated CVariantInfo and CMemberInfo.
  270. * Implemented copy hooks.
  271. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  272. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  273. *
  274. * Revision 1.8  2000/09/01 13:16:20  vasilche
  275. * Implemented class/container/choice iterators.
  276. * Implemented CObjectStreamCopier for copying data without loading into memory.
  277. *
  278. * Revision 1.7  2000/08/15 19:44:50  vasilche
  279. * Added Read/Write hooks:
  280. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  281. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  282. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  283. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  284. *
  285. * Revision 1.6  2000/07/03 18:42:46  vasilche
  286. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  287. * Reduced header dependency.
  288. *
  289. * Revision 1.5  2000/06/16 19:24:22  vasilche
  290. * Updated MSVC project.
  291. * Fixed error on MSVC with static const class member.
  292. *
  293. * Revision 1.4  2000/06/16 16:31:22  vasilche
  294. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  295. *
  296. * Revision 1.3  2000/06/07 19:46:00  vasilche
  297. * Some code cleaning.
  298. * Macros renaming in more clear way.
  299. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  300. *
  301. * Revision 1.2  2000/06/01 19:07:05  vasilche
  302. * Added parsing of XML data.
  303. *
  304. * Revision 1.1  2000/05/24 20:08:49  vasilche
  305. * Implemented XML dump.
  306. *
  307. * ===========================================================================
  308. */
  310. #include <ncbi_pch.hpp>
  311. #include <corelib/ncbistd.hpp>
  312. #include <corelib/ncbi_limits.h>
  314. #include <serial/objostrxml.hpp>
  315. #include <serial/objistr.hpp>
  316. #include <serial/objcopy.hpp>
  317. #include <serial/memberid.hpp>
  318. #include <serial/memberlist.hpp>
  319. #include <serial/enumvalues.hpp>
  320. #include <serial/objhook.hpp>
  321. #include <serial/classinfo.hpp>
  322. #include <serial/choice.hpp>
  323. #include <serial/continfo.hpp>
  324. #include <serial/delaybuf.hpp>
  325. #include <serial/ptrinfo.hpp>
  327. #include <stdio.h>
  328. #include <math.h>
  330. BEGIN_NCBI_SCOPE
  332. CObjectOStream* CObjectOStream::OpenObjectOStreamXml(CNcbiOstream& out,
  333.                                                      bool deleteOut)
  334. {
  335.     return new CObjectOStreamXml(out, deleteOut);
  336. }
  339. string CObjectOStreamXml::sm_DefaultDTDFilePrefix = "";
  340. string CObjectOStreamXml::sm_DefaultSchemaNamespace = "http://www.ncbi.nlm.nih.gov";
  342. CObjectOStreamXml::CObjectOStreamXml(CNcbiOstream& out, bool deleteOut)
  343.     : CObjectOStream(eSerial_Xml, out, deleteOut),
  344.       m_LastTagAction(eTagClose), m_EndTag(true),
  345.       m_UseDefaultDTDFilePrefix( true),
  346.       m_UsePublicId( true),
  347.       m_Attlist( false), m_StdXml( false), m_EnforcedStdXml( false),
  348.       m_RealFmt( eRealScientificFormat ), m_Encoding( eEncoding_Unknown ),
  349.       m_UseSchemaRef( false ), m_UseSchemaLoc( true ), m_UseDTDRef( true )
  350. {
  351.     m_Output.SetBackLimit(1);
  352. }
  354. CObjectOStreamXml::~CObjectOStreamXml(void)
  355. {
  356. }
  358. void CObjectOStreamXml::SetEncoding(EEncoding enc)
  359. {
  360.     m_Encoding = enc;
  361. }
  363. CObjectOStreamXml::EEncoding CObjectOStreamXml::GetEncoding(void) const
  364. {
  365.     return m_Encoding;
  366. }
  368. void CObjectOStreamXml::SetReferenceSchema(bool use_schema)
  369. {
  370.     m_UseSchemaRef = use_schema;
  371. }
  373. bool CObjectOStreamXml::GetReferenceSchema(void) const
  374. {
  375.     return m_UseSchemaRef;
  376. }
  377. void CObjectOStreamXml::SetReferenceDTD(bool use_dtd)
  378. {
  379.     m_UseDTDRef = use_dtd;
  380. }
  381. bool CObjectOStreamXml::GetReferenceDTD(void) const
  382. {
  383.     return m_UseDTDRef;
  384. }
  386. void CObjectOStreamXml::SetUseSchemaLocation(bool use_loc)
  387. {
  388.     m_UseSchemaLoc = use_loc;
  389. }
  390. bool CObjectOStreamXml::GetUseSchemaLocation(void) const
  391. {
  392.     return m_UseSchemaLoc;
  393. }
  396. CObjectOStreamXml::ERealValueFormat
  397.     CObjectOStreamXml::GetRealValueFormat(void) const
  398. {
  399.     return m_RealFmt;
  400. }
  401. void CObjectOStreamXml::SetRealValueFormat(
  402.     CObjectOStreamXml::ERealValueFormat fmt)
  403. {
  404.     m_RealFmt = fmt;
  405. }
  406. void CObjectOStreamXml::SetEnforcedStdXml(bool set)
  407. {
  408.     m_EnforcedStdXml = set;
  409.     if (m_EnforcedStdXml) {
  410.         m_StdXml = false;
  411.     }
  412. }
  415. string CObjectOStreamXml::GetPosition(void) const
  416. {
  417.     return "line "+NStr::UIntToString(m_Output.GetLine());
  418. }
  420. static string GetPublicModuleName(TTypeInfo type)
  421. {
  422.     const string& s = type->GetModuleName();
  423.     string name;
  424.     for ( string::const_iterator i = s.begin(); i != s.end(); ++i ) {
  425.         char c = *i;
  426.         if ( !isalnum(c) )
  427.             name += ' ';
  428.         else
  429.             name += c;
  430.     }
  431.     return name;
  432. }
  434. string CObjectOStreamXml::GetModuleName(TTypeInfo type)
  435. {
  436.     string name;
  437.     if( !m_DTDFileName.empty() ) {
  438.         name = m_DTDFileName;
  439.     }
  440.     else {
  441.         const string& s = type->GetModuleName();
  442.         for ( string::const_iterator i = s.begin(); i != s.end(); ++i ) {
  443.             char c = *i;
  444.             if ( c == '-' )
  445.                 name += '_';
  446.             else
  447.                 name += c;
  448.         }
  449.     }
  450.     return name;
  451. }
  453. void CObjectOStreamXml::WriteFileHeader(TTypeInfo type)
  454. {
  455.     m_Output.PutString("<?xml version="1.0");
  456.     switch (m_Encoding) {
  457.     default:
  458.         break;
  459.     case eEncoding_UTF8:
  460.         m_Output.PutString("" encoding="UTF-8");
  461.         break;
  462.     case eEncoding_ISO8859_1:
  463.         m_Output.PutString("" encoding="ISO-8859-1");   
  464.         break;
  465.     case eEncoding_Windows_1252:
  466.         m_Output.PutString("" encoding="Windows-1252");   
  467.         break;
  468.     }
  469.     m_Output.PutString(""?>");
  470.     m_Output.PutEol();
  472.     if (!m_UseSchemaRef && m_UseDTDRef) {
  473.         m_Output.PutString("<!DOCTYPE ");
  474.         m_Output.PutString(type->GetName());
  475.     
  476.         if (m_UsePublicId) {
  477.             m_Output.PutString(" PUBLIC "");
  478.             if (m_PublicId.empty()) {
  479.                 m_Output.PutString("-//NCBI//");
  480.                 m_Output.PutString(GetPublicModuleName(type));
  481.                 m_Output.PutString("/EN");
  482.             } else {
  483.                 m_Output.PutString(m_PublicId);
  484.             }
  485.             m_Output.PutString(""");
  486.         } else {
  487.             m_Output.PutString(" SYSTEM");
  488.         }
  489.         m_Output.PutString(" "");
  490.         m_Output.PutString(GetDTDFilePrefix() + GetModuleName(type));
  491.         m_Output.PutString(".dtd">");
  492.         m_Output.PutEol();
  493.     }
  494.     m_LastTagAction = eTagClose;
  495. }
  497. void CObjectOStreamXml::x_WriteClassNamespace(TTypeInfo type)
  498. {
  499.     OpenTagEndBack();
  501.     if (m_UseSchemaLoc) {
  502.         m_Output.PutEol();
  503.         m_Output.PutString("   ");
  504.     }
  505.     m_Output.PutString(" xmlns");
  506.     if (!m_CurrNsPrefix.empty()) {
  507.        m_Output.PutChar(':');
  508.        m_Output.PutString(m_CurrNsPrefix);
  509.     }
  510.     m_Output.PutString("="");
  512.     string ns_name( m_NsPrefixToName[m_CurrNsPrefix]);
  513.     if (ns_name.empty()) {
  514.         ns_name = GetDefaultSchemaNamespace();
  515.     }
  516.     m_Output.PutString(ns_name + """);
  518.     if (m_UseSchemaLoc) {
  519.         m_Output.PutEol();
  520.         string xs_name("http://www.w3.org/2001/XMLSchema-instance");
  521.         string xs_prefix("xs");
  522.         if (m_NsNameToPrefix.find(xs_name) == m_NsNameToPrefix.end()) {
  523.             for (char a='a';
  524.                 m_NsPrefixToName.find(xs_prefix) != m_NsPrefixToName.end(); ++a) {
  525.                 xs_prefix += a;
  526.             }
  527.             m_NsPrefixToName[xs_prefix] = xs_name;
  528.             m_NsNameToPrefix[xs_name] = xs_prefix;
  529.             m_Output.PutString("    xmlns:");
  530.             m_Output.PutString(xs_prefix + "="");
  531.             m_Output.PutString(xs_name + """);
  532.             m_Output.PutEol();
  533.             m_Output.PutString("    ");
  534.             m_Output.PutString(xs_prefix);
  535.             m_Output.PutString(":schemaLocation="");
  536.             m_Output.PutString(ns_name + " ");
  537.             m_Output.PutString(GetDTDFilePrefix() + GetModuleName(type));
  538.             m_Output.PutString(".xsd"");
  539.             m_Output.PutEol();
  540.         }
  541.     }
  542.     OpenTagEnd();
  543. }
  545. bool CObjectOStreamXml::x_ProcessTypeNamespace(TTypeInfo type)
  546. {
  547.     if (m_UseSchemaRef) {
  548.         string nsName;
  549.         if (type->HasNamespaceName()) {
  550.             nsName = type->GetNamespaceName();
  551.         } else if (m_NsPrefixes.empty()) {
  552.             nsName = GetDefaultSchemaNamespace();
  553.         }
  554.         return x_BeginNamespace(nsName,type->GetNamespacePrefix());
  555.     }
  556.     return false;
  557. }
  559. void CObjectOStreamXml::x_EndTypeNamespace(void)
  560. {
  561.     if (m_UseSchemaRef) {
  562.         if (TopFrame().HasTypeInfo()) {
  563.             TTypeInfo type = TopFrame().GetTypeInfo();
  564.             if (type->HasNamespaceName()) {
  565.                 x_EndNamespace(type->GetNamespaceName());
  566.             }
  567.         }
  568.     }
  569. }
  571. bool CObjectOStreamXml::x_BeginNamespace(const string& ns_name,
  572.                                          const string& ns_prefix)
  573. {
  574.     if (!m_UseSchemaRef || ns_name.empty()) {
  575.         return false;
  576.     }
  577.     string nsPrefix(ns_prefix);
  578.     if (m_NsNameToPrefix.find(ns_name) == m_NsNameToPrefix.end()) {
  579.         for (char a='a';
  580.             m_NsPrefixToName.find(nsPrefix) != m_NsPrefixToName.end(); ++a) {
  581.             nsPrefix += a;
  582.         }
  583.         m_CurrNsPrefix = nsPrefix;
  584.         m_NsNameToPrefix[ns_name] = nsPrefix;
  585.         m_NsPrefixToName[nsPrefix] = ns_name;
  586.         m_NsPrefixes.push(nsPrefix);
  587.         return true;
  588.     } else {
  589.         m_CurrNsPrefix = m_NsNameToPrefix[ns_name];
  590.         m_NsPrefixes.push(m_CurrNsPrefix);
  591.     }
  592.     return false;
  593. }
  595. void CObjectOStreamXml::x_EndNamespace(const string& ns_name)
  596. {
  597.     if (!m_UseSchemaRef || ns_name.empty()) {
  598.         return;
  599.     }
  600.     string nsPrefix = m_NsNameToPrefix[ns_name];
  601. // not sure about it - should we erase them or not?
  602. //    m_NsNameToPrefix.erase(ns_name);
  603. //    m_NsPrefixToName.erase(nsPrefix);
  604.     m_NsPrefixes.pop();
  605.     m_CurrNsPrefix = m_NsPrefixes.empty() ? kEmptyStr : m_NsPrefixes.top();
  606.     if (!m_Attlist && GetStackDepth() <= 2) {
  607.         m_NsNameToPrefix.clear();
  608.         m_NsPrefixToName.clear();
  609.     }
  610. }
  612. void CObjectOStreamXml::WriteEnum(const CEnumeratedTypeValues& values,
  613.                                   TEnumValueType value,
  614.                                   const string& valueName)
  615. {
  616.     if ( !values.GetName().empty() ) {
  617.         // global enum
  618.         OpenTagStart();
  619.         m_Output.PutString(values.GetName());
  620.         if ( !valueName.empty() ) {
  621.             m_Output.PutString(" value="");
  622.             m_Output.PutString(valueName);
  623.             m_Output.PutChar('"');
  624.         }
  625.         if ( values.IsInteger() ) {
  626.             OpenTagEnd();
  627.             m_Output.PutInt4(value);
  628.             CloseTagStart();
  629.             m_Output.PutString(values.GetName());
  630.             CloseTagEnd();
  631.         }
  632.         else {
  633.             _ASSERT(!valueName.empty());
  634.             SelfCloseTagEnd();
  635.             m_LastTagAction = eTagClose;
  636.         }
  637.     }
  638.     else {
  639.         // local enum (member, variant or element)
  640.         if ( valueName.empty() ) {
  641.             _ASSERT(values.IsInteger());
  642.             m_Output.PutInt4(value);
  643.         }
  644.         else {
  645.             if (m_LastTagAction == eAttlistTag) {
  646.                 m_Output.PutString(valueName);
  647.             } else {
  648.                 OpenTagEndBack();
  649.                 m_Output.PutString(" value="");
  650.                 m_Output.PutString(valueName);
  651.                 m_Output.PutChar('"');
  652.                 if ( values.IsInteger() ) {
  653.                     OpenTagEnd();
  654.                     m_Output.PutInt4(value);
  655.                 }
  656.                 else {
  657.                     SelfCloseTagEnd();
  658.                 }
  659.             }
  660.         }
  661.     }
  662. }
  664. void CObjectOStreamXml::WriteEnum(const CEnumeratedTypeValues& values,
  665.                                   TEnumValueType value)
  666. {
  667.     WriteEnum(values, value, values.FindName(value, values.IsInteger()));
  668. }
  670. void CObjectOStreamXml::CopyEnum(const CEnumeratedTypeValues& values,
  671.                                  CObjectIStream& in)
  672. {
  673.     TEnumValueType value = in.ReadEnum(values);
  674.     WriteEnum(values, value, values.FindName(value, values.IsInteger()));
  675. }
  677. void CObjectOStreamXml::WriteEscapedChar(char c)
  678. {
  679. //  http://www.w3.org/TR/2000/REC-xml-20001006#NT-Char
  680.     switch ( c ) {
  681.     case '&':
  682.         m_Output.PutString("&amp;");
  683.         break;
  684.     case '<':
  685.         m_Output.PutString("&lt;");
  686.         break;
  687.     case '>':
  688.         m_Output.PutString("&gt;");
  689.         break;
  690.     case ''':
  691.         m_Output.PutString("&apos;");
  692.         break;
  693.     case '"':
  694.         m_Output.PutString("&quot;");
  695.         break;
  696.     default:
  697.         if ((unsigned int)c < 0x20) {
  698.             m_Output.PutString("&#x");
  699.             Uint1 ch = c;
  700.             unsigned hi = ch >> 4;
  701.             unsigned lo = ch & 0xF;
  702.             if ( hi ) {
  703.                 m_Output.PutChar("0123456789abcdef"[hi]);
  704.             }
  705.             m_Output.PutChar("0123456789abcdef"[lo]);
  706.             m_Output.PutChar(';');
  707.         } else if ((unsigned int)c >= 0x80) {
  708.             if ( m_Encoding == eEncoding_UTF8 ||
  709.                  m_Encoding == eEncoding_Unknown ) {
  710.                 Uint1 ch = c;
  711.                 m_Output.PutChar((ch >> 6) | 0xC0);
  712.                 m_Output.PutChar((ch & 0x3F) | 0x80);
  713.             } else {
  714.                 m_Output.PutChar(c);
  715.             }
  716.         } else {
  717.             m_Output.PutChar(c);
  718.         }
  719.         break;
  720.     }
  721. }
  723. void CObjectOStreamXml::WriteBool(bool data)
  724. {
  725.     OpenTagEndBack();
  726.     if ( data )
  727.         m_Output.PutString(" value="true"");
  728.     else
  729.         m_Output.PutString(" value="false"");
  730.     SelfCloseTagEnd();
  731. }
  733. void CObjectOStreamXml::WriteChar(char data)
  734. {
  735.     WriteEscapedChar(data);
  736. }
  738. void CObjectOStreamXml::WriteInt4(Int4 data)
  739. {
  740.     m_Output.PutInt4(data);
  741. }
  743. void CObjectOStreamXml::WriteUint4(Uint4 data)
  744. {
  745.     m_Output.PutUint4(data);
  746. }
  748. void CObjectOStreamXml::WriteInt8(Int8 data)
  749. {
  750.     m_Output.PutInt8(data);
  751. }
  753. void CObjectOStreamXml::WriteUint8(Uint8 data)
  754. {
  755.     m_Output.PutUint8(data);
  756. }
  758. void CObjectOStreamXml::WriteDouble2(double data, size_t digits)
  759. {
  760.     if (isnan(data)) {
  761.         ThrowError(fInvalidData, "invalid double: not a number");
  762.     }
  763.     if (!finite(data)) {
  764.         ThrowError(fInvalidData, "invalid double: infinite");
  765.     }
  766.     char buffer[512];
  767.     SIZE_TYPE width;
  768.     if (m_RealFmt == eRealFixedFormat) {
  769.         int shift = int(ceil(log10(fabs(data))));
  770.         int precision = int(digits - shift);
  771.         if ( precision < 0 )
  772.             precision = 0;
  773.         if ( precision > 64 ) // limit precision of data
  774.             precision = 64;
  775.         width = NStr::DoubleToString(data, (unsigned int)precision,
  776.                                     buffer, sizeof(buffer));
  777.         if (precision != 0) {
  778.             while (buffer[width-1] == '0') {
  779.                 --width;
  780.             }
  781.             if (buffer[width-1] == '.') {
  782.                 --width;
  783.             }
  784.         }
  785.     } else {
  786.         width = sprintf(buffer, "%.*g", digits, data);
  787.     }
  788.     m_Output.PutString(buffer, width);
  789. }
  791. void CObjectOStreamXml::WriteDouble(double data)
  792. {
  793.     WriteDouble2(data, DBL_DIG);
  794. }
  796. void CObjectOStreamXml::WriteFloat(float data)
  797. {
  798.     WriteDouble2(data, FLT_DIG);
  799. }
  801. void CObjectOStreamXml::WriteNull(void)
  802. {
  803.     OpenTagEndBack();
  804.     SelfCloseTagEnd();
  805. }
  807. void CObjectOStreamXml::WriteAnyContentObject(const CAnyContentObject& obj)
  808. {
  809.     if (obj.GetName().empty()) {
  810.         return;
  811.     }
  812.     string ns_name(obj.GetNamespaceName());
  813.     bool needNs = x_BeginNamespace(ns_name,obj.GetNamespacePrefix());
  814.     OpenTag(obj.GetName());
  816.     if (m_UseSchemaRef) {
  817.         OpenTagEndBack();
  818.         if (needNs) {
  819.             m_Output.PutEol();
  820.             m_Output.PutString("    xmlns");
  821.             if (!m_CurrNsPrefix.empty()) {
  822.                 m_Output.PutChar(':');
  823.                 m_Output.PutString(m_CurrNsPrefix);
  824.             }
  825.             m_Output.PutString("="");
  826.             m_Output.PutString(ns_name);
  827.             m_Output.PutChar('"');
  828.         }
  830.         const vector<CSerialAttribInfoItem>& attlist = obj.GetAttributes();
  831.         if (!attlist.empty()) {
  832.             m_Attlist = true;
  833.             vector<CSerialAttribInfoItem>::const_iterator it;
  834.             for ( it = attlist.begin(); it != attlist.end(); ++it) {
  835.                 string ns(it->GetNamespaceName());
  836.                 string ns_prefix;
  837.                 if (x_BeginNamespace(ns,kEmptyStr)) {
  838.                     m_Output.PutEol();
  839.                     m_Output.PutString("    xmlns");
  840.                     ns_prefix = m_NsNameToPrefix[ns];
  841.                     if (!ns_prefix.empty()) {
  842.                         m_Output.PutChar(':');
  843.                         m_Output.PutString(ns_prefix);
  844.                     }
  845.                     m_Output.PutString("="");
  846.                     m_Output.PutString(ns);
  847.                     m_Output.PutChar('"');
  848.                 }
  849.                 ns_prefix = m_NsNameToPrefix[ns];
  851.                 m_Output.PutEol();
  852.                 m_Output.PutString("    ");
  853.                 if (!ns_prefix.empty()) {
  854.                     m_Output.PutString(ns_prefix);
  855.                     m_Output.PutChar(':');
  856.                 }
  857.                 m_Output.PutString(it->GetName());
  858.                 m_Output.PutString("="");
  859.                 m_Output.PutString(it->GetValue());
  860.                 m_Output.PutChar('"');
  861.                 x_EndNamespace(ns);
  862.             }
  863.             m_Attlist = false;
  864.         }
  865.         OpenTagEnd();
  866.     }
  868. // value
  869. // no verification on write!
  870.     const string& value = obj.GetValue();
  871.     bool was_open = true;
  872.     for (string::const_iterator is=value.begin(); is != value.end(); ++is) {
  873.         if (*is == '/' && *(is+1) == '>') {
  874.             m_Output.DecIndentLevel();
  875.             was_open = false;
  876.         }
  877.         if (*is == '<') {
  878.             if (*(is+1) == '/') {
  879.                 m_Output.DecIndentLevel();
  880.                 if (!was_open) {
  881.                     m_Output.PutEol();
  882.                 }
  883.                 was_open = false;
  884.             } else {
  885.                 m_Output.PutEol();
  886.                 m_Output.IncIndentLevel();
  887.                 was_open = true;
  888.             }
  889.         }
  890.         m_Output.PutChar(*is);
  891.         if (*is == '<') {
  892.             if (*(is+1) == '/') {
  893.                 m_Output.PutChar(*(++is));
  894.             }
  895.             if (m_UseSchemaRef && !m_CurrNsPrefix.empty()) {
  896.                 m_Output.PutString(m_CurrNsPrefix);
  897.                 m_Output.PutChar(':');
  898.             }
  899.         }
  900.     }
  902. // close tag
  903.     if (!was_open) {
  904.         m_Output.PutEol(false);
  905.         m_EndTag = true;
  906.     }
  907.     CloseTag(obj.GetName());
  908.     x_EndNamespace(ns_name);
  909. }
  911. void CObjectOStreamXml::CopyAnyContentObject(CObjectIStream& in)
  912. {
  913.     NCBI_THROW(CSerialException,eNotImplemented,"not yet");
  914. }
  916. void CObjectOStreamXml::WriteCString(const char* str)
  917. {
  918.     if ( str == 0 ) {
  919.         OpenTagEndBack();
  920.         SelfCloseTagEnd();
  921.     }
  922.     else {
  923.         while ( *str ) {
  924.             WriteEscapedChar(*str++);
  925.         }
  926.     }
  927. }
  929. void CObjectOStreamXml::WriteString(const string& str, EStringType type)
  930. {
  931.     EEncoding enc = m_Encoding;
  932.     if (type == eStringTypeUTF8) {
  933.         if (m_Encoding == eEncoding_UTF8 || m_Encoding == eEncoding_Unknown) {
  934.             m_Encoding = eEncoding_ISO8859_1;
  935.         } else {
  936.             string tmp = (static_cast<const CStringUTF8&>(str)).AsAscii();
  937.             WriteString( tmp, eStringTypeVisible);
  938.             return;
  939.         }
  940.     }
  941.     for ( string::const_iterator i = str.begin(); i != str.end(); ++i ) {
  942.         WriteEscapedChar(*i);
  943.     }
  944.     m_Encoding = enc;
  945. }
  947. void CObjectOStreamXml::WriteStringStore(const string& str)
  948. {
  949.     for ( string::const_iterator i = str.begin(); i != str.end(); ++i ) {
  950.         WriteEscapedChar(*i);
  951.     }
  952. }
  954. void CObjectOStreamXml::CopyString(CObjectIStream& in)
  955. {
  956.     string str;
  957.     in.ReadStd(str);
  958.     for ( string::const_iterator i = str.begin(); i != str.end(); ++i ) {
  959.         WriteEscapedChar(*i);
  960.     }
  961. }
  963. void CObjectOStreamXml::CopyStringStore(CObjectIStream& in)
  964. {
  965.     string str;
  966.     in.ReadStringStore(str);
  967.     for ( string::const_iterator i = str.begin(); i != str.end(); ++i ) {
  968.         WriteEscapedChar(*i);
  969.     }
  970. }
  972. void CObjectOStreamXml::WriteNullPointer(void)
  973. {
  974.     OpenTagEndBack();
  975.     SelfCloseTagEnd();
  976. }
  978. void CObjectOStreamXml::WriteObjectReference(TObjectIndex index)
  979. {
  980.     m_Output.PutString("<object index=");
  981.     if ( sizeof(TObjectIndex) == sizeof(Int4) )
  982.         m_Output.PutInt4(Int4(index));
  983.     else if ( sizeof(TObjectIndex) == sizeof(Int8) )
  984.         m_Output.PutInt8(index);
  985.     else
  986.         ThrowError(fIllegalCall, "invalid size of TObjectIndex"
  987.             "must be either sizeof(Int4) or sizeof(Int8)");
  988.     m_Output.PutString("/>");
  989.     m_EndTag = true;
  990. }
  992. void CObjectOStreamXml::WriteTag(const string& name)
  993. {
  994.     if (!m_Attlist && !m_CurrNsPrefix.empty()) {
  995.         m_Output.PutString(m_CurrNsPrefix);
  996.         m_Output.PutChar(':');
  997.     }
  998.     m_Output.PutString(name);
  999. }
  1001. void CObjectOStreamXml::OpenTagStart(void)
  1002. {
  1003.     if (m_Attlist) {
  1004.         if ( m_LastTagAction == eTagOpen ) {
  1005.             m_Output.PutChar(' ');
  1006.             m_LastTagAction = eAttlistTag;
  1007.         }
  1008.     } else {
  1009.         if (!m_EndTag)
  1010.             m_Output.PutEol(false);
  1011.         m_Output.PutIndent();
  1012.         m_Output.PutChar('<');
  1013.         m_LastTagAction = eTagOpen;
  1014.     }
  1015.     m_EndTag = false;
  1016. }
  1018. void CObjectOStreamXml::OpenTagEnd(void)
  1019. {
  1020.     if (m_Attlist) {
  1021.         if ( m_LastTagAction == eAttlistTag ) {
  1022.             m_Output.PutString("="");
  1023.         }
  1024.     } else {
  1025.         if ( m_LastTagAction == eTagOpen ) {
  1026.             m_Output.PutChar('>');
  1027.             m_Output.IncIndentLevel();
  1028.             m_LastTagAction = eTagClose;
  1029.         }
  1030.     }
  1031. }
  1033. void CObjectOStreamXml::OpenTagEndBack(void)
  1034. {
  1035.     _ASSERT(m_LastTagAction == eTagClose);
  1036.     m_LastTagAction = eTagOpen;
  1037.     m_Output.BackChar('>');
  1038.     m_Output.DecIndentLevel();
  1039. }
  1041. void CObjectOStreamXml::SelfCloseTagEnd(void)
  1042. {
  1043.     _ASSERT(m_LastTagAction == eTagOpen);
  1044.     m_Output.PutString("/>");
  1045.     m_Output.PutEol(false);
  1046.     m_LastTagAction = eTagSelfClosed;
  1047.     m_EndTag = true;
  1048. }
  1050. void CObjectOStreamXml::EolIfEmptyTag(void)
  1051. {
  1052.     _ASSERT(m_LastTagAction != eTagSelfClosed);
  1053.     if ( m_LastTagAction == eTagOpen ) {
  1054.         m_Output.PutEol(false);
  1055.         m_LastTagAction = eTagClose;
  1056.     }
  1057. }
  1059. void CObjectOStreamXml::CloseTagStart(void)
  1060. {
  1061.     _ASSERT(m_LastTagAction != eTagSelfClosed);
  1062.     m_Output.DecIndentLevel();
  1063.     if (m_EndTag)
  1064.         m_Output.PutIndent();
  1065.     m_Output.PutString("</");
  1066.     m_LastTagAction = eTagOpen;
  1067. }
  1069. void CObjectOStreamXml::CloseTagEnd(void)
  1070. {
  1071.     m_Output.PutChar('>');
  1072.     m_Output.PutEol(false);
  1073.     m_LastTagAction = eTagClose;
  1074.     m_EndTag = true;
  1075. }
  1077. void CObjectOStreamXml::PrintTagName(size_t level)
  1078. {
  1079.     const TFrame& frame = FetchFrameFromTop(level);
  1080.     switch ( frame.GetFrameType() ) {
  1081.     case TFrame::eFrameNamed:
  1082.     case TFrame::eFrameArray:
  1083.     case TFrame::eFrameClass:
  1084.     case TFrame::eFrameChoice:
  1085.         {
  1086.             _ASSERT(frame.GetTypeInfo());
  1087.             const string& name = frame.GetTypeInfo()->GetName();
  1088.             if ( !name.empty() ) {
  1089.                 WriteTag(name);
  1090. #if defined(NCBI_SERIAL_IO_TRACE)
  1091.     TraceTag(name);
  1092. #endif
  1093.             } else {
  1094.                 PrintTagName(level + 1);
  1095.             }
  1096.             return;
  1097.         }
  1098.     case TFrame::eFrameClassMember:
  1099.     case TFrame::eFrameChoiceVariant:
  1100.         {
  1101.             bool attlist = m_Attlist;
  1102.             if (!x_IsStdXml()) {
  1103.                 PrintTagName(level + 1);
  1104.                 m_Output.PutChar('_');
  1105.                 m_Attlist = true;
  1106.             }
  1107.             WriteTag(frame.GetMemberId().GetName());
  1108.             m_Attlist = attlist;
  1109. #if defined(NCBI_SERIAL_IO_TRACE)
  1110.     TraceTag(frame.GetMemberId().GetName());
  1111. #endif
  1112.             return;
  1113.         }
  1114.     case TFrame::eFrameArrayElement:
  1115.         {
  1116.             PrintTagName(level + 1);
  1117.             if (!x_IsStdXml()) {
  1118.                 m_Output.PutString("_E");
  1119.             }
  1120.             return;
  1121.         }
  1122.     default:
  1123.         break;
  1124.     }
  1125.     ThrowError(fIllegalCall, "illegal frame type");
  1126. }
  1128. void CObjectOStreamXml::WriteOtherBegin(TTypeInfo typeInfo)
  1129. {
  1130.     OpenTag(typeInfo);
  1131. }
  1133. void CObjectOStreamXml::WriteOtherEnd(TTypeInfo typeInfo)
  1134. {
  1135.     CloseTag(typeInfo);
  1136. }
  1138. void CObjectOStreamXml::WriteOther(TConstObjectPtr object,
  1139.                                    TTypeInfo typeInfo)
  1140. {
  1141.     OpenTag(typeInfo);
  1142.     WriteObject(object, typeInfo);
  1143.     CloseTag(typeInfo);
  1144. }
  1146. void CObjectOStreamXml::BeginContainer(const CContainerTypeInfo* containerType)
  1147. {
  1148.     if (!x_IsStdXml()) {
  1149.         OpenTagIfNamed(containerType);
  1150.     }
  1151. }
  1153. void CObjectOStreamXml::EndContainer(void)
  1154. {
  1155.     if (!x_IsStdXml()) {
  1156.         CloseTagIfNamed(TopFrame().GetTypeInfo());
  1157.     }
  1158. }
  1160. bool CObjectOStreamXml::WillHaveName(TTypeInfo elementType)
  1161. {
  1162.     while ( elementType->GetName().empty() ) {
  1163.         if ( elementType->GetTypeFamily() != eTypeFamilyPointer )
  1164.             return false;
  1165.         elementType = CTypeConverter<CPointerTypeInfo>::SafeCast(elementType)->GetPointedType();
  1166.     }
  1167.     // found named type
  1168.     return true;
  1169. }
  1171. void CObjectOStreamXml::BeginContainerElement(TTypeInfo elementType)
  1172. {
  1173.     if ( !WillHaveName(elementType) ) {
  1174.         BeginArrayElement(elementType);
  1175.     }
  1176. }
  1178. void CObjectOStreamXml::EndContainerElement(void)
  1179. {
  1180.     if ( !WillHaveName(TopFrame().GetTypeInfo()) ) {
  1181.         EndArrayElement();
  1182.     }
  1183. }
  1185. #ifdef VIRTUAL_MID_LEVEL_IO
  1186. void CObjectOStreamXml::WriteContainer(const CContainerTypeInfo* cType,
  1187.                                        TConstObjectPtr containerPtr)
  1188. {
  1189.     if ( !cType->GetName().empty() ) {
  1190.         BEGIN_OBJECT_FRAME2(eFrameArray, cType);
  1191.         OpenTag(cType);
  1193.         WriteContainerContents(cType, containerPtr);
  1195.         EolIfEmptyTag();
  1196.         CloseTag(cType);
  1197.         END_OBJECT_FRAME();
  1198.     }
  1199.     else {
  1200.         WriteContainerContents(cType, containerPtr);
  1201.     }
  1202. }
  1203. void CObjectOStreamXml::BeginArrayElement(TTypeInfo elementType)
  1204. {
  1205.     if (x_IsStdXml() && GetRealTypeFamily(elementType) != eTypeFamilyPrimitive) {
  1206.         TopFrame().SetNotag();
  1207.     } else {
  1208.         OpenStackTag(0);
  1209.     }
  1210. }
  1212. void CObjectOStreamXml::EndArrayElement(void)
  1213. {
  1214.     if (TopFrame().GetNotag()) {
  1215.         TopFrame().SetNotag(false);
  1216.     } else {
  1217.         CloseStackTag(0);
  1218.     }
  1219. }
  1221. void CObjectOStreamXml::WriteContainerContents(const CContainerTypeInfo* cType,
  1222.                                                TConstObjectPtr containerPtr)
  1223. {
  1224.     TTypeInfo elementType = cType->GetElementType();
  1225.     CContainerTypeInfo::CConstIterator i;
  1226.     if ( WillHaveName(elementType) ) {
  1227.         if ( cType->InitIterator(i, containerPtr) ) {
  1228.             do {
  1229.                 if (elementType->GetTypeFamily() == eTypeFamilyPointer) {
  1230.                     const CPointerTypeInfo* pointerType =
  1231.                         CTypeConverter<CPointerTypeInfo>::SafeCast(elementType);
  1232.                     _ASSERT(pointerType->GetObjectPointer(cType->GetElementPtr(i)));
  1233.                     if ( !pointerType->GetObjectPointer(cType->GetElementPtr(i)) ) {
  1234.                         ERR_POST(Warning << " NULL pointer found in container: skipping");
  1235.                         continue;
  1236.                     }
  1237.                 }
  1239.                 WriteObject(cType->GetElementPtr(i), elementType);
  1241.             } while ( cType->NextElement(i) );
  1242.         }
  1243.     }
  1244.     else {
  1245.         BEGIN_OBJECT_FRAME2(eFrameArrayElement, elementType);
  1247.         if ( cType->InitIterator(i, containerPtr) ) {
  1248.             do {
  1249.                 BeginArrayElement(elementType);
  1250.                 WriteObject(cType->GetElementPtr(i), elementType);
  1251.                 EndArrayElement();
  1252.             } while ( cType->NextElement(i) );
  1253.         } else {
  1254.             const TFrame& frame = FetchFrameFromTop(1);
  1255.             if (frame.GetFrameType() == CObjectStackFrame::eFrameNamed) {
  1256.                 const CClassTypeInfo* clType =
  1257.                     dynamic_cast<const CClassTypeInfo*>(frame.GetTypeInfo());
  1258.                 if (clType && clType->Implicit() && clType->IsImplicitNonEmpty()) {
  1259.                     ThrowError(fInvalidData, "container is empty");
  1260.                 }
  1261.             }
  1262.         }
  1264.         END_OBJECT_FRAME();
  1265.     }
  1266. }
  1267. #endif
  1269. void CObjectOStreamXml::BeginNamedType(TTypeInfo namedTypeInfo)
  1270. {
  1271.     const CClassTypeInfo* classType =
  1272.         dynamic_cast<const CClassTypeInfo*>(namedTypeInfo);
  1273.     if (classType) {
  1274.         CheckStdXml(classType);
  1275.     }
  1276.     OpenTag(namedTypeInfo);
  1277. }
  1279. void CObjectOStreamXml::EndNamedType(void)
  1280. {
  1281.     CloseTag(TopFrame().GetTypeInfo());
  1282. }
  1284. #ifdef VIRTUAL_MID_LEVEL_IO
  1285. void CObjectOStreamXml::WriteNamedType(TTypeInfo namedTypeInfo,
  1286.                                        TTypeInfo typeInfo,
  1287.                                        TConstObjectPtr object)
  1288. {
  1289.     BEGIN_OBJECT_FRAME2(eFrameNamed, namedTypeInfo);
  1290.     
  1291.     BeginNamedType(namedTypeInfo);
  1292.     WriteObject(object, typeInfo);
  1293.     EndNamedType();
  1295.     END_OBJECT_FRAME();
  1296. }
  1298. void CObjectOStreamXml::CopyNamedType(TTypeInfo namedTypeInfo,
  1299.                                       TTypeInfo objectType,
  1300.                                       CObjectStreamCopier& copier)
  1301. {
  1302.     BEGIN_OBJECT_2FRAMES_OF2(copier, eFrameNamed, namedTypeInfo);
  1303.     copier.In().BeginNamedType(namedTypeInfo);
  1304.     BeginNamedType(namedTypeInfo);
  1305.     CopyObject(objectType, copier);
  1306.     EndNamedType();
  1307.     copier.In().EndNamedType();
  1308.     END_OBJECT_2FRAMES_OF(copier);
  1309. }
  1310. #endif
  1312. void CObjectOStreamXml::CheckStdXml(const CClassTypeInfoBase* classType)
  1313. {
  1314.     if (m_EnforcedStdXml) {
  1315.         m_StdXml = false;
  1316.         return;
  1317.     }
  1318.     TMemberIndex first = classType->GetItems().FirstIndex();
  1319.     m_StdXml = classType->GetItems().GetItemInfo(first)->GetId().HaveNoPrefix();
  1320. }
  1322. ETypeFamily CObjectOStreamXml::GetRealTypeFamily(TTypeInfo typeInfo)
  1323. {
  1324.     ETypeFamily type = typeInfo->GetTypeFamily();
  1325.     if (type == eTypeFamilyPointer) {
  1326.         const CPointerTypeInfo* ptr =
  1327.             dynamic_cast<const CPointerTypeInfo*>(typeInfo);
  1328.         if (ptr) {
  1329.             type = ptr->GetPointedType()->GetTypeFamily();
  1330.         }
  1331.     }
  1332.     return type;
  1333. }
  1335. ETypeFamily CObjectOStreamXml::GetContainerElementTypeFamily(TTypeInfo typeInfo)
  1336. {
  1337.     if (typeInfo->GetTypeFamily() == eTypeFamilyPointer) {
  1338.         const CPointerTypeInfo* ptr =
  1339.             dynamic_cast<const CPointerTypeInfo*>(typeInfo);
  1340.         if (ptr) {
  1341.             typeInfo = ptr->GetPointedType();
  1342.         }
  1343.     }
  1344.     _ASSERT(typeInfo->GetTypeFamily() == eTypeFamilyContainer);
  1345.     const CContainerTypeInfo* ptr =
  1346.         dynamic_cast<const CContainerTypeInfo*>(typeInfo);
  1347.     return GetRealTypeFamily(ptr->GetElementType());
  1348. }
  1350. void CObjectOStreamXml::BeginClass(const CClassTypeInfo* classInfo)
  1351. {
  1352.     CheckStdXml(classInfo);
  1353.     bool needNs = x_ProcessTypeNamespace(classInfo);
  1354.     OpenTagIfNamed(classInfo);
  1355.     if (needNs) {
  1356.         x_WriteClassNamespace(classInfo);
  1357.     }
  1358. }
  1360. void CObjectOStreamXml::EndClass(void)
  1361. {
  1362.     if (!m_Attlist && m_LastTagAction != eTagSelfClosed) {
  1363.         EolIfEmptyTag();
  1364.     }
  1365.     CloseTagIfNamed(TopFrame().GetTypeInfo());
  1366.     x_EndTypeNamespace();
  1367. }
  1369. void CObjectOStreamXml::BeginClassMember(const CMemberId& id)
  1370. {
  1371.     const CClassTypeInfoBase* classType = dynamic_cast<const CClassTypeInfoBase*>
  1372.         (FetchFrameFromTop(1).GetTypeInfo());
  1373.     _ASSERT(classType);
  1374.     BeginClassMember(classType->GetItemInfo(id.GetName())->GetTypeInfo(),id);
  1375. }
  1377. void CObjectOStreamXml::BeginClassMember(TTypeInfo memberType,
  1378.                                          const CMemberId& id)
  1379. {
  1380.     if (x_IsStdXml()) {
  1381.         if(id.IsAttlist()) {
  1382.             if(m_LastTagAction == eTagClose) {
  1383.                 OpenTagEndBack();
  1384.             }
  1385.             m_Attlist = true;
  1386.             TopFrame().SetNotag();
  1387.         } else {
  1388.             ETypeFamily type = GetRealTypeFamily(memberType);
  1389.             bool needTag = true;
  1390.             if (GetEnforcedStdXml()) {
  1391.                 if (type == eTypeFamilyContainer) {
  1392.                     needTag = (GetContainerElementTypeFamily(memberType) !=
  1393.                                eTypeFamilyPrimitive);
  1394.                 }
  1395.             } else {
  1396.                 needTag = (type == eTypeFamilyPrimitive && !id.HasNotag());
  1397.             }
  1398.             if (needTag) {
  1399.                 OpenStackTag(0);
  1400.             } else {
  1401.                 TopFrame().SetNotag();
  1402.             }
  1403.         }
  1404.     } else {
  1405.         OpenStackTag(0);
  1406.     }
  1407. }
  1409. void CObjectOStreamXml::EndClassMember(void)
  1410. {
  1411.     if (TopFrame().GetNotag()) {
  1412.         TopFrame().SetNotag(false);
  1413.         m_Attlist = false;
  1414.         if(m_LastTagAction == eTagOpen) {
  1415.             OpenTagEnd();
  1416.         }
  1417.     } else {
  1418.         CloseStackTag(0);
  1419.     }
  1420. }
  1423. #ifdef VIRTUAL_MID_LEVEL_IO
  1425. void CObjectOStreamXml::WriteClass(const CClassTypeInfo* classType,
  1426.                                    TConstObjectPtr classPtr)
  1427. {
  1428.     if ( !classType->GetName().empty() ) {
  1429.         BEGIN_OBJECT_FRAME2(eFrameClass, classType);
  1431.         BeginClass(classType);
  1432.         for ( CClassTypeInfo::CIterator i(classType); i.Valid(); ++i ) {
  1433.             classType->GetMemberInfo(i)->WriteMember(*this, classPtr);
  1434.         }
  1435.         EndClass();
  1437.         END_OBJECT_FRAME();
  1438.     }
  1439.     else {
  1440.         for ( CClassTypeInfo::CIterator i(classType); i.Valid(); ++i ) {
  1441.             classType->GetMemberInfo(i)->WriteMember(*this, classPtr);
  1442.         }
  1443.     }
  1444. }
  1446. void CObjectOStreamXml::WriteClassMember(const CMemberId& memberId,
  1447.                                          TTypeInfo memberType,
  1448.                                          TConstObjectPtr memberPtr)
  1449. {
  1450.     BEGIN_OBJECT_FRAME2(eFrameClassMember,memberId);
  1452.     BeginClassMember(memberType,memberId);
  1453.     WriteObject(memberPtr, memberType);
  1454.     EndClassMember();
  1456.     END_OBJECT_FRAME();
  1457. }
  1459. bool CObjectOStreamXml::WriteClassMember(const CMemberId& memberId,
  1460.                                          const CDelayBuffer& buffer)
  1461. {
  1462.     if ( !buffer.HaveFormat(eSerial_Xml) )
  1463.         return false;
  1465.     BEGIN_OBJECT_FRAME2(eFrameClassMember, memberId);
  1466.     OpenStackTag(0);
  1467.     
  1468.     Write(buffer.GetSource());
  1469.     
  1470.     CloseStackTag(0);
  1471.     END_OBJECT_FRAME();
  1473.     return true;
  1474. }
  1475. #endif
  1477. void CObjectOStreamXml::BeginChoice(const CChoiceTypeInfo* choiceType)
  1478. {
  1479.     CheckStdXml(choiceType);
  1480.     bool needNs = x_ProcessTypeNamespace(choiceType);
  1481.     OpenTagIfNamed(choiceType);
  1482.     if (needNs) {
  1483.         x_WriteClassNamespace(choiceType);
  1484.     }
  1485. }
  1487. void CObjectOStreamXml::EndChoice(void)
  1488. {
  1489.     CloseTagIfNamed(TopFrame().GetTypeInfo());
  1490.     x_EndTypeNamespace();
  1491. }
  1493. void CObjectOStreamXml::BeginChoiceVariant(const CChoiceTypeInfo* choiceType,
  1494.                                            const CMemberId& id)
  1495. {
  1496.     if (x_IsStdXml()) {
  1497.         const CVariantInfo* var_info = choiceType->GetVariantInfo(id.GetName());
  1498.         ETypeFamily type = GetRealTypeFamily(var_info->GetTypeInfo());
  1499.         bool needTag = true;
  1500.         if (GetEnforcedStdXml()) {
  1501.             if (type == eTypeFamilyContainer) {
  1502.                 needTag = (GetContainerElementTypeFamily(
  1503.                     var_info->GetTypeInfo()) != eTypeFamilyPrimitive);
  1504.             }
  1505.         } else {
  1506.             needTag = (type == eTypeFamilyPrimitive && !id.HasNotag());
  1507.         }
  1508.         if (needTag) {
  1509.             OpenStackTag(0);
  1510.         } else {
  1511.             TopFrame().SetNotag();
  1512.         }
  1513.     } else {
  1514.         OpenStackTag(0);
  1515.     }
  1516. }
  1518. void CObjectOStreamXml::EndChoiceVariant(void)
  1519. {
  1520.     if (TopFrame().GetNotag()) {
  1521.         TopFrame().SetNotag(false);
  1522.     } else {
  1523.         CloseStackTag(0);
  1524.     }
  1525. }
  1527. #ifdef VIRTUAL_MID_LEVEL_IO
  1528. void CObjectOStreamXml::WriteChoice(const CChoiceTypeInfo* choiceType,
  1529.                                     TConstObjectPtr choicePtr)
  1530. {
  1531.     if ( !choiceType->GetName().empty() ) {
  1532.         BEGIN_OBJECT_FRAME2(eFrameChoice, choiceType);
  1533.         OpenTag(choiceType);
  1535.         WriteChoiceContents(choiceType, choicePtr);
  1537.         CloseTag(choiceType);
  1538.         END_OBJECT_FRAME();
  1539.     }
  1540.     else {
  1541.         WriteChoiceContents(choiceType, choicePtr);
  1542.     }
  1543. }
  1545. void CObjectOStreamXml::WriteChoiceContents(const CChoiceTypeInfo* choiceType,
  1546.                                             TConstObjectPtr choicePtr)
  1547. {
  1548.     TMemberIndex index = choiceType->GetIndex(choicePtr);
  1549.     const CVariantInfo* variantInfo = choiceType->GetVariantInfo(index);
  1550.     BEGIN_OBJECT_FRAME2(eFrameChoiceVariant, variantInfo->GetId());
  1551.     OpenStackTag(0);
  1552.     
  1553.     variantInfo->WriteVariant(*this, choicePtr);
  1554.     
  1555.     CloseStackTag(0);
  1556.     END_OBJECT_FRAME();
  1557. }
  1558. #endif
  1560. static const char* const HEX = "0123456789ABCDEF";
  1562. void CObjectOStreamXml::WriteBytes(const ByteBlock& ,
  1563.                                    const char* bytes, size_t length)
  1564. {
  1565.     while ( length-- > 0 ) {
  1566.         char c = *bytes++;
  1567.         m_Output.PutChar(HEX[(c >> 4) & 0xf]);
  1568.         m_Output.PutChar(HEX[c & 0xf]);
  1569.     }
  1570. }
  1572. void CObjectOStreamXml::WriteChars(const CharBlock& ,
  1573.                                    const char* chars, size_t length)
  1574. {
  1575.     while ( length-- > 0 ) {
  1576.         char c = *chars++;
  1577.         WriteEscapedChar(c);
  1578.     }
  1579. }
  1582. void CObjectOStreamXml::WriteSeparator(void)
  1583. {
  1584.     m_Output.PutString(GetSeparator());
  1585. }
  1587. #if defined(NCBI_SERIAL_IO_TRACE)
  1589. void CObjectOStreamXml::TraceTag(const string& name)
  1590. {
  1591.     cout << ", Tag=" << name;
  1592. }
  1594. #endif
  1596. END_NCBI_SCOPE