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

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

生物技术

开发平台：

C/C++

typeinfo.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: typeinfo.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:41:59  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.45
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: typeinfo.cpp,v 1000.4 2004/06/01 19:41:59 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Author: Eugene Vasilchenko
  36. *
  37. * File Description:
  38. *   !!! PUT YOUR DESCRIPTION HERE !!!
  39. *
  40. * ---------------------------------------------------------------------------
  41. * $Log: typeinfo.cpp,v $
  42. * Revision 1000.4  2004/06/01 19:41:59  gouriano
  43. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.45
  44. *
  45. * Revision 1.45  2004/05/17 21:03:03  gorelenk
  46. * Added include of PCH ncbi_pch.hpp
  47. *
  48. * Revision 1.44  2004/01/05 14:25:22  gouriano
  49. * Added possibility to set serialization hooks by stack path
  50. *
  51. * Revision 1.43  2003/11/24 14:10:05  grichenk
  52. * Changed base class for CAliasTypeInfo to CPointerTypeInfo
  53. *
  54. * Revision 1.42  2003/11/18 18:11:49  grichenk
  55. * Resolve aliased type info before using it in CObjectTypeInfo
  56. *
  57. * Revision 1.41  2003/09/16 14:48:36  gouriano
  58. * Enhanced AnyContent objects to support XML namespaces and attribute info items.
  59. *
  60. * Revision 1.40  2003/08/26 19:25:58  gouriano
  61. * added possibility to discard a member of an STL container
  62. * (from a read hook)
  63. *
  64. * Revision 1.39  2003/08/25 15:59:09  gouriano
  65. * added possibility to use namespaces in XML i/o streams
  66. *
  67. * Revision 1.38  2003/07/29 18:47:48  vasilche
  68. * Fixed thread safeness of object stream hooks.
  69. *
  70. * Revision 1.37  2003/06/04 17:02:13  rsmith
  71. * Move static mutex out of function to work around CW complex initialization bug.
  72. *
  73. * Revision 1.36  2003/03/10 18:54:26  gouriano
  74. * use new structured exceptions (based on CException)
  75. *
  76. * Revision 1.35  2002/12/23 18:42:22  dicuccio
  77. * Added #include to avoid warnings in Wn32 about deletion of incomplete types
  78. *
  79. * Revision 1.34  2002/09/19 20:05:44  vasilche
  80. * Safe initialization of static mutexes
  81. *
  82. * Revision 1.33  2002/08/13 13:56:06  grichenk
  83. * Improved MT-safety in CTypeInfo and CTypeRef
  84. *
  85. * Revision 1.32  2001/12/09 07:38:13  vakatov
  86. * Got rid of a minor GCC warning (fixed member's order of initialization)
  87. *
  88. * Revision 1.31  2001/10/22 15:16:22  grichenk
  89. * Optimized CTypeInfo::IsCObject()
  90. *
  91. * Revision 1.30  2001/05/17 15:07:09  lavr
  92. * Typos corrected
  93. *
  94. * Revision 1.29  2000/11/07 17:25:42  vasilche
  95. * Fixed encoding of XML:
  96. *     removed unnecessary apostrophes in OCTET STRING
  97. *     removed unnecessary content in NULL
  98. * Added module names to CTypeInfo and CEnumeratedTypeValues
  99. *
  100. * Revision 1.28  2000/10/20 15:51:44  vasilche
  101. * Fixed data error processing.
  102. * Added interface for constructing container objects directly into output stream.
  103. * object.hpp, object.inl and object.cpp were split to
  104. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  105. *
  106. * Revision 1.27  2000/10/03 17:22:45  vasilche
  107. * Reduced header dependency.
  108. * Reduced size of debug libraries on WorkShop by 3 times.
  109. * Fixed tag allocation for parent classes.
  110. * Fixed CObject allocation/deallocation in streams.
  111. * Moved instantiation of several templates in separate source file.
  112. *
  113. * Revision 1.26  2000/09/29 16:18:24  vasilche
  114. * Fixed binary format encoding/decoding on 64 bit compulers.
  115. * Implemented CWeakMap<> for automatic cleaning map entries.
  116. * Added cleaning local hooks via CWeakMap<>.
  117. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  118. * Added some user interface methods to CObjectIStream, CObjectOStream and
  119. * CObjectStreamCopier.
  120. *
  121. * Revision 1.25  2000/09/18 20:00:26  vasilche
  122. * Separated CVariantInfo and CMemberInfo.
  123. * Implemented copy hooks.
  124. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  125. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  126. *
  127. * Revision 1.24  2000/08/15 19:44:51  vasilche
  128. * Added Read/Write hooks:
  129. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  130. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  131. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  132. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  133. *
  134. * Revision 1.23  2000/07/03 18:42:48  vasilche
  135. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  136. * Reduced header dependency.
  137. *
  138. * Revision 1.22  2000/06/16 16:31:22  vasilche
  139. * Changed implementation of choices and classes info to allow use of the same classes in generated and user written classes.
  140. *
  141. * Revision 1.21  2000/06/07 19:46:01  vasilche
  142. * Some code cleaning.
  143. * Macros renaming in more clear way.
  144. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  145. *
  146. * Revision 1.20  2000/05/24 20:08:50  vasilche
  147. * Implemented XML dump.
  148. *
  149. * Revision 1.19  2000/03/29 15:55:30  vasilche
  150. * Added two versions of object info - CObjectInfo and CConstObjectInfo.
  151. * Added generic iterators by class -
  152. *  CTypeIterator<class>, CTypeConstIterator<class>,
  153. *  CStdTypeIterator<type>, CStdTypeConstIterator<type>,
  154. *  CObjectsIterator and CObjectsConstIterator.
  155. *
  156. * Revision 1.18  2000/02/17 20:02:46  vasilche
  157. * Added some standard serialization exceptions.
  158. * Optimized text/binary ASN.1 reading.
  159. * Fixed wrong encoding of StringStore in ASN.1 binary format.
  160. * Optimized logic of object collection.
  161. *
  162. * Revision 1.17  1999/12/17 19:05:05  vasilche
  163. * Simplified generation of GetTypeInfo methods.
  164. *
  165. * Revision 1.16  1999/09/14 18:54:21  vasilche
  166. * Fixed bugs detected by gcc & egcs.
  167. * Removed unneeded includes.
  168. *
  169. * Revision 1.15  1999/08/31 17:50:09  vasilche
  170. * Implemented several macros for specific data types.
  171. * Added implicit members.
  172. * Added multimap and set.
  173. *
  174. * Revision 1.14  1999/07/20 18:23:14  vasilche
  175. * Added interface to old ASN.1 routines.
  176. * Added fixed choice of subclasses to use for pointers.
  177. *
  178. * Revision 1.13  1999/07/19 15:50:39  vasilche
  179. * Added interface to old ASN.1 routines.
  180. * Added naming of key/value in STL map.
  181. *
  182. * Revision 1.12  1999/07/13 20:18:24  vasilche
  183. * Changed types naming.
  184. *
  185. * Revision 1.11  1999/07/07 19:59:09  vasilche
  186. * Reduced amount of data allocated on heap
  187. * Cleaned ASN.1 structures info
  188. *
  189. * Revision 1.10  1999/07/07 18:18:32  vasilche
  190. * Fixed some bugs found by MS VC++
  191. *
  192. * Revision 1.9  1999/07/01 17:55:36  vasilche
  193. * Implemented ASN.1 binary write.
  194. *
  195. * Revision 1.8  1999/06/30 16:05:06  vasilche
  196. * Added support for old ASN.1 structures.
  197. *
  198. * Revision 1.7  1999/06/24 14:45:02  vasilche
  199. * Added binary ASN.1 output.
  200. *
  201. * Revision 1.6  1999/06/15 16:19:53  vasilche
  202. * Added ASN.1 object output stream.
  203. *
  204. * Revision 1.5  1999/06/10 21:06:50  vasilche
  205. * Working binary output and almost working binary input.
  206. *
  207. * Revision 1.4  1999/06/07 20:42:58  vasilche
  208. * Fixed compilation under MS VS
  209. *
  210. * Revision 1.3  1999/06/07 19:30:28  vasilche
  211. * More bug fixes
  212. *
  213. * Revision 1.2  1999/06/04 20:51:51  vasilche
  214. * First compilable version of serialization.
  215. *
  216. * Revision 1.1  1999/05/19 19:56:59  vasilche
  217. * Commit just in case.
  218. *
  219. * ===========================================================================
  220. */
  222. #include <ncbi_pch.hpp>
  223. #include <corelib/ncbithr.hpp>
  224. #include <serial/typeinfo.hpp>
  225. #include <serial/typeinfoimpl.hpp>
  226. #include <serial/objistr.hpp>
  227. #include <serial/objostr.hpp>
  228. #include <serial/objcopy.hpp>
  229. #include <serial/serialimpl.hpp>
  230. #include <corelib/ncbimtx.hpp>
  232. BEGIN_NCBI_SCOPE
  234. /* put back inside GetTypeInfoMutex when Mac CodeWarrior 9 comes out */
  235. DEFINE_STATIC_MUTEX(s_TypeInfoMutex);
  237. SSystemMutex& GetTypeInfoMutex(void)
  238. {
  239.     return s_TypeInfoMutex;
  240. }
  243. class CTypeInfoFunctions
  244. {
  245. public:
  246.     static void ReadWithHook(CObjectIStream& in,
  247.                              TTypeInfo objectType, TObjectPtr objectPtr);
  248.     static void WriteWithHook(CObjectOStream& out,
  249.                               TTypeInfo objectType, TConstObjectPtr objectPtr);
  250.     static void SkipWithHook(CObjectIStream& stream,
  251.                              TTypeInfo objectType);
  252.     static void CopyWithHook(CObjectStreamCopier& copier,
  253.                              TTypeInfo objectType);
  254. };
  256. class CNamespaceInfoItem
  257. {
  258. public:
  259.     CNamespaceInfoItem(void);
  260.     CNamespaceInfoItem(const CNamespaceInfoItem& other);
  261.     virtual ~CNamespaceInfoItem(void);
  263.     bool HasNamespaceName(void) const;
  264.     const string& GetNamespaceName(void) const;
  265.     void SetNamespaceName(const string& ns_name);
  267.     bool HasNamespacePrefix(void) const;
  268.     const string& GetNamespacePrefix(void) const;
  269.     void SetNamespacePrefix(const string& ns_prefix);
  271. private:
  272.     string m_NsName;
  273.     string m_NsPrefix;
  274.     bool   m_NsPrefixSet;
  275. };
  277. typedef CTypeInfoFunctions TFunc;
  279. CTypeInfo::CTypeInfo(ETypeFamily typeFamily, size_t size)
  280.     : m_TypeFamily(typeFamily), m_Size(size), m_Name(),
  281.       m_InfoItem(0),
  282.       m_IsCObject(false),
  283.       m_CreateFunction(&CVoidTypeFunctions::Create),
  284.       m_ReadHookData(&CVoidTypeFunctions::Read, &TFunc::ReadWithHook),
  285.       m_WriteHookData(&CVoidTypeFunctions::Write, &TFunc::WriteWithHook),
  286.       m_SkipHookData(&CVoidTypeFunctions::Skip, &TFunc::SkipWithHook),
  287.       m_CopyHookData(&CVoidTypeFunctions::Copy, &TFunc::CopyWithHook)
  288. {
  289.     return;
  290. }
  293. CTypeInfo::CTypeInfo(ETypeFamily typeFamily, size_t size, const char* name)
  294.     : m_TypeFamily(typeFamily), m_Size(size), m_Name(name),
  295.       m_InfoItem(0),
  296.       m_IsCObject(false),
  297.       m_CreateFunction(&CVoidTypeFunctions::Create),
  298.       m_ReadHookData(&CVoidTypeFunctions::Read, &TFunc::ReadWithHook),
  299.       m_WriteHookData(&CVoidTypeFunctions::Write, &TFunc::WriteWithHook),
  300.       m_SkipHookData(&CVoidTypeFunctions::Skip, &TFunc::SkipWithHook),
  301.       m_CopyHookData(&CVoidTypeFunctions::Copy, &TFunc::CopyWithHook)
  302. {
  303.     return;
  304. }
  307. CTypeInfo::CTypeInfo(ETypeFamily typeFamily, size_t size, const string& name)
  308.     : m_TypeFamily(typeFamily), m_Size(size), m_Name(name),
  309.       m_InfoItem(0),
  310.       m_IsCObject(false),
  311.       m_CreateFunction(&CVoidTypeFunctions::Create),
  312.       m_ReadHookData(&CVoidTypeFunctions::Read, &TFunc::ReadWithHook),
  313.       m_WriteHookData(&CVoidTypeFunctions::Write, &TFunc::WriteWithHook),
  314.       m_SkipHookData(&CVoidTypeFunctions::Skip, &TFunc::SkipWithHook),
  315.       m_CopyHookData(&CVoidTypeFunctions::Copy, &TFunc::CopyWithHook)
  316. {
  317.     return;
  318. }
  321. CTypeInfo::~CTypeInfo(void)
  322. {
  323.     if (m_InfoItem) {
  324.         delete m_InfoItem;
  325.     }
  326.     return;
  327. }
  329. bool CTypeInfo::HasNamespaceName(void) const
  330. {
  331.     return m_InfoItem ? m_InfoItem->HasNamespaceName() : false;
  332. }
  334. const string& CTypeInfo::GetNamespaceName(void) const
  335. {
  336.     return m_InfoItem ? m_InfoItem->GetNamespaceName() : kEmptyStr;
  337. }
  339. void CTypeInfo::SetNamespaceName(const string& ns_name) const
  340. {
  341.     x_CreateInfoItemIfNeeded();
  342.     m_InfoItem->SetNamespaceName(ns_name);
  343. }
  345. bool CTypeInfo::HasNamespacePrefix(void) const
  346. {
  347.     return m_InfoItem ? m_InfoItem->HasNamespacePrefix() : false;
  348. }
  350. const string& CTypeInfo::GetNamespacePrefix(void) const
  351. {
  352.     return m_InfoItem ? m_InfoItem->GetNamespacePrefix() : kEmptyStr;
  353. }
  355. void CTypeInfo::SetNamespacePrefix(const string& ns_prefix) const
  356. {
  357.     x_CreateInfoItemIfNeeded();
  358.     m_InfoItem->SetNamespacePrefix(ns_prefix);
  359. }
  361. void CTypeInfo::x_CreateInfoItemIfNeeded(void) const
  362. {
  363.     if (!m_InfoItem) {
  364.         m_InfoItem = new CNamespaceInfoItem;
  365.     }
  366. }
  368. const string& CTypeInfo::GetModuleName(void) const
  369. {
  370.     return m_ModuleName;
  371. }
  373. void CTypeInfo::SetModuleName(const string& name)
  374. {
  375.     if ( !m_ModuleName.empty() )
  376.         NCBI_THROW(CSerialException,eFail, "cannot change module name");
  377.     m_ModuleName = name;
  378. }
  380. void CTypeInfo::SetModuleName(const char* name)
  381. {
  382.     SetModuleName(string(name));
  383. }
  385. void CTypeInfo::Delete(TObjectPtr /*object*/) const
  386. {
  387.     NCBI_THROW(CSerialException,eIllegalCall,
  388.         "This type cannot be allocated on heap");
  389. }
  391. void CTypeInfo::DeleteExternalObjects(TObjectPtr /*object*/) const
  392. {
  393. }
  395. TTypeInfo CTypeInfo::GetRealTypeInfo(TConstObjectPtr ) const
  396. {
  397.     return this;
  398. }
  400. bool CTypeInfo::IsType(TTypeInfo typeInfo) const
  401. {
  402.     return this == typeInfo;
  403. }
  405. bool CTypeInfo::MayContainType(TTypeInfo /*typeInfo*/) const
  406. {
  407.     return false;
  408. }
  410. const CObject* CTypeInfo::GetCObjectPtr(TConstObjectPtr /*objectPtr*/) const
  411. {
  412.     return 0;
  413. }
  415. bool CTypeInfo::IsParentClassOf(const CClassTypeInfo* /*classInfo*/) const
  416. {
  417.     return false;
  418. }
  420. void CTypeInfo::SetCreateFunction(TTypeCreate func)
  421. {
  422.     m_CreateFunction = func;
  423. }
  425. void CTypeInfo::SetLocalReadHook(CObjectIStream& stream,
  426.                                  CReadObjectHook* hook)
  427. {
  428.     CMutexGuard guard(GetTypeInfoMutex());
  429.     m_ReadHookData.SetLocalHook(stream.m_ObjectHookKey, hook);
  430. }
  432. void CTypeInfo::SetGlobalReadHook(CReadObjectHook* hook)
  433. {
  434.     CMutexGuard guard(GetTypeInfoMutex());
  435.     m_ReadHookData.SetGlobalHook(hook);
  436. }
  438. void CTypeInfo::ResetLocalReadHook(CObjectIStream& stream)
  439. {
  440.     CMutexGuard guard(GetTypeInfoMutex());
  441.     m_ReadHookData.ResetLocalHook(stream.m_ObjectHookKey);
  442. }
  444. void CTypeInfo::ResetGlobalReadHook(void)
  445. {
  446.     CMutexGuard guard(GetTypeInfoMutex());
  447.     m_ReadHookData.ResetGlobalHook();
  448. }
  450. void CTypeInfo::SetPathReadHook(CObjectIStream* in, const string& path,
  451.                                 CReadObjectHook* hook)
  452. {
  453.     CMutexGuard guard(GetTypeInfoMutex());
  454.     m_ReadHookData.SetPathHook(in,path,hook);
  455. }
  457. void CTypeInfo::SetGlobalWriteHook(CWriteObjectHook* hook)
  458. {
  459.     CMutexGuard guard(GetTypeInfoMutex());
  460.     m_WriteHookData.SetGlobalHook(hook);
  461. }
  463. void CTypeInfo::SetLocalWriteHook(CObjectOStream& stream,
  464.                                  CWriteObjectHook* hook)
  465. {
  466.     CMutexGuard guard(GetTypeInfoMutex());
  467.     m_WriteHookData.SetLocalHook(stream.m_ObjectHookKey, hook);
  468. }
  470. void CTypeInfo::ResetGlobalWriteHook(void)
  471. {
  472.     CMutexGuard guard(GetTypeInfoMutex());
  473.     m_WriteHookData.ResetGlobalHook();
  474. }
  476. void CTypeInfo::ResetLocalWriteHook(CObjectOStream& stream)
  477. {
  478.     CMutexGuard guard(GetTypeInfoMutex());
  479.     m_WriteHookData.ResetLocalHook(stream.m_ObjectHookKey);
  480. }
  482. void CTypeInfo::SetPathWriteHook(CObjectOStream* out, const string& path,
  483.                                  CWriteObjectHook* hook)
  484. {
  485.     CMutexGuard guard(GetTypeInfoMutex());
  486.     m_WriteHookData.SetPathHook(out,path,hook);
  487. }
  489. void CTypeInfo::SetGlobalSkipHook(CSkipObjectHook* hook)
  490. {
  491.     CMutexGuard guard(GetTypeInfoMutex());
  492.     m_SkipHookData.SetGlobalHook(hook);
  493. }
  495. void CTypeInfo::SetLocalSkipHook(CObjectIStream& stream,
  496.                                  CSkipObjectHook* hook)
  497. {
  498.     CMutexGuard guard(GetTypeInfoMutex());
  499.     m_SkipHookData.SetLocalHook(stream.m_ObjectSkipHookKey, hook);
  500. }
  502. void CTypeInfo::ResetGlobalSkipHook(void)
  503. {
  504.     CMutexGuard guard(GetTypeInfoMutex());
  505.     m_SkipHookData.ResetGlobalHook();
  506. }
  508. void CTypeInfo::ResetLocalSkipHook(CObjectIStream& stream)
  509. {
  510.     CMutexGuard guard(GetTypeInfoMutex());
  511.     m_SkipHookData.ResetLocalHook(stream.m_ObjectSkipHookKey);
  512. }
  514. void CTypeInfo::SetPathSkipHook(CObjectIStream* in, const string& path,
  515.                                 CSkipObjectHook* hook)
  516. {
  517.     CMutexGuard guard(GetTypeInfoMutex());
  518.     m_SkipHookData.SetPathHook(in,path,hook);
  519. }
  521. void CTypeInfo::SetGlobalCopyHook(CCopyObjectHook* hook)
  522. {
  523.     CMutexGuard guard(GetTypeInfoMutex());
  524.     m_CopyHookData.SetGlobalHook(hook);
  525. }
  527. void CTypeInfo::SetLocalCopyHook(CObjectStreamCopier& stream,
  528.                                  CCopyObjectHook* hook)
  529. {
  530.     CMutexGuard guard(GetTypeInfoMutex());
  531.     m_CopyHookData.SetLocalHook(stream.m_ObjectHookKey, hook);
  532. }
  534. void CTypeInfo::ResetGlobalCopyHook(void)
  535. {
  536.     CMutexGuard guard(GetTypeInfoMutex());
  537.     m_CopyHookData.ResetGlobalHook();
  538. }
  540. void CTypeInfo::ResetLocalCopyHook(CObjectStreamCopier& stream)
  541. {
  542.     CMutexGuard guard(GetTypeInfoMutex());
  543.     m_CopyHookData.ResetLocalHook(stream.m_ObjectHookKey);
  544. }
  546. void CTypeInfo::SetPathCopyHook(CObjectStreamCopier* copier, const string& path,
  547.                                 CCopyObjectHook* hook)
  548. {
  549.     CMutexGuard guard(GetTypeInfoMutex());
  550.     m_CopyHookData.SetPathHook(copier ? &(copier->In()) : 0,path,hook);
  551. }
  553. void CTypeInfo::SetReadFunction(TTypeReadFunction func)
  554. {
  555.     m_ReadHookData.SetDefaultFunction(func);
  556. }
  558. void CTypeInfo::SetWriteFunction(TTypeWriteFunction func)
  559. {
  560.     m_WriteHookData.SetDefaultFunction(func);
  561. }
  563. void CTypeInfo::SetCopyFunction(TTypeCopyFunction func)
  564. {
  565.     m_CopyHookData.SetDefaultFunction(func);
  566. }
  568. void CTypeInfo::SetSkipFunction(TTypeSkipFunction func)
  569. {
  570.     m_SkipHookData.SetDefaultFunction(func);
  571. }
  573. void CTypeInfoFunctions::ReadWithHook(CObjectIStream& stream,
  574.                                       TTypeInfo objectType,
  575.                                       TObjectPtr objectPtr)
  576. {
  577.     CReadObjectHook* hook =
  578.         objectType->m_ReadHookData.GetHook(stream.m_ObjectHookKey);
  579.     if (!hook) {
  580.         hook = objectType->m_ReadHookData.GetPathHook(stream);
  581.     }
  582.     if ( hook )
  583.         hook->ReadObject(stream, CObjectInfo(objectPtr, objectType));
  584.     else
  585.         objectType->DefaultReadData(stream, objectPtr);
  586. }
  588. void CTypeInfoFunctions::WriteWithHook(CObjectOStream& stream,
  589.                                        TTypeInfo objectType,
  590.                                        TConstObjectPtr objectPtr)
  591. {
  592.     CWriteObjectHook* hook =
  593.         objectType->m_WriteHookData.GetHook(stream.m_ObjectHookKey);
  594.     if (!hook) {
  595.         hook = objectType->m_WriteHookData.GetPathHook(stream);
  596.     }
  597.     if ( hook )
  598.         hook->WriteObject(stream, CConstObjectInfo(objectPtr, objectType));
  599.     else
  600.         objectType->DefaultWriteData(stream, objectPtr);
  601. }
  603. void CTypeInfoFunctions::SkipWithHook(CObjectIStream& stream,
  604.                                       TTypeInfo objectType)
  605. {
  606.     CSkipObjectHook* hook =
  607.         objectType->m_SkipHookData.GetHook(stream.m_ObjectSkipHookKey);
  608.     if (!hook) {
  609.         hook = objectType->m_SkipHookData.GetPathHook(stream);
  610.     }
  611.     if ( hook )
  612.         hook->SkipObject(stream, objectType);
  613.     else
  614.         objectType->DefaultSkipData(stream);
  615. }
  617. void CTypeInfoFunctions::CopyWithHook(CObjectStreamCopier& stream,
  618.                                       TTypeInfo objectType)
  619. {
  620.     CCopyObjectHook* hook =
  621.         objectType->m_CopyHookData.GetHook(stream.m_ObjectHookKey);
  622.     if (!hook) {
  623.         hook = objectType->m_CopyHookData.GetPathHook(stream.In());
  624.     }
  625.     if ( hook )
  626.         hook->CopyObject(stream, objectType);
  627.     else
  628.         objectType->DefaultCopyData(stream);
  629. }
  632. CNamespaceInfoItem::CNamespaceInfoItem(void)
  633. {
  634.     m_NsPrefixSet = false;
  635. }
  637. CNamespaceInfoItem::CNamespaceInfoItem(const CNamespaceInfoItem& other)
  638. {
  639.     m_NsName      = other.m_NsName;
  640.     m_NsPrefix    = other.m_NsPrefix;
  641.     m_NsPrefixSet = other.m_NsPrefixSet;
  642. }
  644. CNamespaceInfoItem::~CNamespaceInfoItem(void)
  645. {
  646. }
  648. bool CNamespaceInfoItem::HasNamespaceName(void) const
  649. {
  650.     return !m_NsName.empty();
  651. }
  653. const string& CNamespaceInfoItem::GetNamespaceName(void) const
  654. {
  655.     return m_NsName;
  656. }
  658. void CNamespaceInfoItem::SetNamespaceName(const string& ns_name)
  659. {
  660.     m_NsName = ns_name;
  661. }
  663. bool CNamespaceInfoItem::HasNamespacePrefix(void) const
  664. {
  665.     return m_NsPrefixSet;
  666. }
  668. const string& CNamespaceInfoItem::GetNamespacePrefix(void) const
  669. {
  670.     return m_NsPrefix;
  671. }
  673. void CNamespaceInfoItem::SetNamespacePrefix(const string& ns_prefix)
  674. {
  675.     m_NsPrefix = ns_prefix;
  676.     m_NsPrefixSet = !m_NsPrefix.empty();
  677. }
  679. END_NCBI_SCOPE