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

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

生物技术

开发平台：

C/C++

serialimpl.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: serialimpl.hpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/04/12 17:15:44  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [CATCHUP_003] Dev-tree R1.47
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef SERIALIMPL__HPP
  11. #define SERIALIMPL__HPP
  13. /*  $Id: serialimpl.hpp,v 1000.3 2004/04/12 17:15:44 gouriano Exp $
  14. * ===========================================================================
  15. *
  16. *                            PUBLIC DOMAIN NOTICE
  17. *               National Center for Biotechnology Information
  18. *
  19. *  This software/database is a "United States Government Work" under the
  20. *  terms of the United States Copyright Act.  It was written as part of
  21. *  the author's official duties as a United States Government employee and
  22. *  thus cannot be copyrighted.  This software/database is freely available
  23. *  to the public for use. The National Library of Medicine and the U.S.
  24. *  Government have not placed any restriction on its use or reproduction.
  25. *
  26. *  Although all reasonable efforts have been taken to ensure the accuracy
  27. *  and reliability of the software and data, the NLM and the U.S.
  28. *  Government do not and cannot warrant the performance or results that
  29. *  may be obtained by using this software or data. The NLM and the U.S.
  30. *  Government disclaim all warranties, express or implied, including
  31. *  warranties of performance, merchantability or fitness for any particular
  32. *  purpose.
  33. *
  34. *  Please cite the author in any work or product based on this material.
  35. *
  36. * ===========================================================================
  37. *
  38. * Author: Eugene Vasilchenko
  39. *
  40. * File Description:
  41. *   File to be included in modules implementing GetTypeInfo methods.
  42. *
  43. */
  45. #include <corelib/ncbistd.hpp>
  46. #include <corelib/ncbiobj.hpp>
  47. #include <corelib/ncbithr.hpp>
  48. #include <serial/typeinfo.hpp>
  49. #include <serial/stdtypes.hpp>
  50. #include <serial/stltypes.hpp>
  51. #include <serial/ptrinfo.hpp>
  52. #include <serial/enumerated.hpp>
  53. #include <serial/classinfo.hpp>
  54. #include <serial/choice.hpp>
  55. #include <serial/choiceptr.hpp>
  56. #include <serial/autoptrinfo.hpp>
  57. #include <serial/serialbase.hpp>
  58. #include <serial/exception.hpp>
  59. #include <serial/classinfohelper.hpp>
  62. /** @addtogroup GenClassSupport
  63.  *
  64.  * @{
  65.  */
  68. struct valnode;
  70. BEGIN_NCBI_SCOPE
  72. // forward declaration
  73. class CMemberInfo;
  74. class CClassTypeInfoBase;
  75. class CClassTypeInfo;
  76. class CChoiceTypeInfo;
  77. class CDelayBufferData;
  79. //
  80. // define type info getter for standard classes
  81. template<typename T>
  82. inline
  83. TTypeInfoGetter GetStdTypeInfoGetter(const T* )
  84. {
  85.     return &CStdTypeInfo<T>::GetTypeInfo;
  86. }
  88. // some compilers cannot resolve overloading by
  89. // (char* const*) and (const char* const*) in template
  90. // so we'll add explicit implementations:
  92. inline
  93. TTypeInfoGetter GetStdTypeInfoGetter(char* const* )
  94. {
  95.     return &CStdTypeInfo<char*>::GetTypeInfo;
  96. }
  98. inline
  99. TTypeInfoGetter GetStdTypeInfoGetter(const char* const* )
  100. {
  101.     return &CStdTypeInfo<const char*>::GetTypeInfo;
  102. }
  105. // macros used in ADD_*_MEMBER macros to specify complex type
  106. // example: ADD_MEMBER(member, STL_set, (STD, (string)))
  107. #define SERIAL_TYPE(TypeMacro) NCBI_NAME2(SERIAL_TYPE_,TypeMacro)
  108. #define SERIAL_REF(TypeMacro) NCBI_NAME2(SERIAL_REF_,TypeMacro)
  110. #define SERIAL_TYPE_CLASS(ClassName) ClassName
  111. #define SERIAL_REF_CLASS(ClassName) &ClassName::GetTypeInfo
  113. #define SERIAL_TYPE_STD(CType) CType
  114. #define SERIAL_REF_STD(CType) &NCBI_NS_NCBI::CStdTypeInfo<CType>::GetTypeInfo
  116. #define SERIAL_TYPE_StringStore() NCBI_NS_STD::string
  117. #define SERIAL_REF_StringStore() 
  118.     &NCBI_NS_NCBI::CStdTypeInfo<string>::GetTypeInfoStringStore
  120. #define SERIAL_TYPE_null() bool
  121. #define SERIAL_REF_null() 
  122.     &NCBI_NS_NCBI::CStdTypeInfo<bool>::GetTypeInfoNullBool
  124. #define SERIAL_TYPE_ENUM(CType, EnumName) CType
  125. #define SERIAL_REF_ENUM(CType, EnumName) 
  126.     NCBI_NS_NCBI::CreateEnumeratedTypeInfo(CType(0), ENUM_METHOD_NAME(EnumName)())
  128. #define SERIAL_TYPE_ENUM_IN(CType, CppContext, EnumName) CppContext CType
  129. #define SERIAL_REF_ENUM_IN(CType, CppContext, EnumName) 
  130.     NCBI_NS_NCBI::CreateEnumeratedTypeInfo(CppContext CType(0), CppContext ENUM_METHOD_NAME(EnumName)())
  132. #define SERIAL_TYPE_POINTER(TypeMacro,TypeMacroArgs) 
  133.     SERIAL_TYPE(TypeMacro)TypeMacroArgs*
  134. #define SERIAL_REF_POINTER(TypeMacro,TypeMacroArgs) 
  135.     &NCBI_NS_NCBI::CPointerTypeInfo::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  137. #define SERIAL_TYPE_STL_multiset(TypeMacro,TypeMacroArgs) 
  138.     NCBI_NS_STD::multiset<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  139. #define SERIAL_REF_STL_multiset(TypeMacro,TypeMacroArgs) 
  140.     &NCBI_NS_NCBI::CStlClassInfo_multiset<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  142. #define SERIAL_TYPE_STL_set(TypeMacro,TypeMacroArgs) 
  143.     NCBI_NS_STD::set<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  144. #define SERIAL_REF_STL_set(TypeMacro,TypeMacroArgs) 
  145.     &NCBI_NS_NCBI::CStlClassInfo_set<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  147. #define SERIAL_TYPE_STL_multimap(KeyTypeMacro,KeyTypeMacroArgs,ValueTypeMacro,ValueTypeMacroArgs) 
  148.     NCBI_NS_STD::multimap<SERIAL_TYPE(KeyTypeMacro)KeyTypeMacroArgs,SERIAL_TYPE(ValueTypeMacro)ValueTypeMacroArgs >
  149. #define SERIAL_REF_STL_multimap(KeyTypeMacro,KeyTypeMacroArgs,ValueTypeMacro,ValueTypeMacroArgs) 
  150.     CTypeRef(&NCBI_NS_NCBI::CStlClassInfo_multimap<SERIAL_TYPE(KeyTypeMacro)KeyTypeMacroArgs,SERIAL_TYPE(ValueTypeMacro)ValueTypeMacroArgs >::GetTypeInfo, SERIAL_REF(KeyTypeMacro)KeyTypeMacroArgs,SERIAL_REF(ValueTypeMacro)ValueTypeMacroArgs)
  152. #define SERIAL_TYPE_STL_map(KeyTypeMacro,KeyTypeMacroArgs,ValueTypeMacro,ValueTypeMacroArgs) 
  153.     NCBI_NS_STD::map<SERIAL_TYPE(KeyTypeMacro)KeyTypeMacroArgs,SERIAL_TYPE(ValueTypeMacro)ValueTypeMacroArgs >
  154. #define SERIAL_REF_STL_map(KeyTypeMacro,KeyTypeMacroArgs,ValueTypeMacro,ValueTypeMacroArgs) 
  155.     CTypeRef(&NCBI_NS_NCBI::CStlClassInfo_map<SERIAL_TYPE(KeyTypeMacro)KeyTypeMacroArgs,SERIAL_TYPE(ValueTypeMacro)ValueTypeMacroArgs >::GetTypeInfo, SERIAL_REF(KeyTypeMacro)KeyTypeMacroArgs,SERIAL_REF(ValueTypeMacro)ValueTypeMacroArgs)
  157. #define SERIAL_TYPE_STL_list(TypeMacro,TypeMacroArgs) 
  158.     NCBI_NS_STD::list<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  159. #define SERIAL_REF_STL_list(TypeMacro,TypeMacroArgs) 
  160.     &NCBI_NS_NCBI::CStlClassInfo_list<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  162. #define SERIAL_TYPE_STL_list_set(TypeMacro,TypeMacroArgs) 
  163.     NCBI_NS_STD::list<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  164. #define SERIAL_REF_STL_list_set(TypeMacro,TypeMacroArgs) 
  165.     &NCBI_NS_NCBI::CStlClassInfo_list<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetSetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  167. #define SERIAL_TYPE_STL_vector(TypeMacro,TypeMacroArgs) 
  168.     NCBI_NS_STD::vector<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  169. #define SERIAL_REF_STL_vector(TypeMacro,TypeMacroArgs) 
  170.     &NCBI_NS_NCBI::CStlClassInfo_vector<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  172. #define SERIAL_TYPE_STL_vector_set(TypeMacro,TypeMacroArgs) 
  173.     NCBI_NS_STD::vector<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  174. #define SERIAL_REF_STL_vector_set(TypeMacro,TypeMacroArgs) 
  175.     &NCBI_NS_NCBI::CStlClassInfo_vector<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetSetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  177. #define SERIAL_TYPE_STL_CHAR_vector(CharType) NCBI_NS_STD::vector<CharType>
  178. #define SERIAL_REF_STL_CHAR_vector(CharType) 
  179.     &NCBI_NS_NCBI::CStdTypeInfo< SERIAL_TYPE(STL_CHAR_vector)(CharType) >::GetTypeInfo
  181. #define SERIAL_TYPE_STL_auto_ptr(TypeMacro,TypeMacroArgs) 
  182.     NCBI_NS_STD::auto_ptr<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  183. #define SERIAL_REF_STL_auto_ptr(TypeMacro,TypeMacroArgs) 
  184.     &NCBI_NS_NCBI::CStlClassInfo_auto_ptr<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  186. #define SERIAL_TYPE_STL_AutoPtr(TypeMacro,TypeMacroArgs) 
  187.     NCBI_NS_NCBI::AutoPtr<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  188. #define SERIAL_REF_STL_AutoPtr(TypeMacro,TypeMacroArgs) 
  189.     &NCBI_NS_NCBI::CAutoPtrTypeInfo<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  191. #define SERIAL_TYPE_STL_CRef(TypeMacro,TypeMacroArgs) 
  192.     NCBI_NS_NCBI::CRef<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  193. #define SERIAL_REF_STL_CRef(TypeMacro,TypeMacroArgs) 
  194.     &NCBI_NS_NCBI::CRefTypeInfo<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  196. #define SERIAL_TYPE_STL_CConstRef(TypeMacro,TypeMacroArgs) 
  197.     NCBI_NS_NCBI::CConstRef<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  198. #define SERIAL_REF_STL_CConstRef(TypeMacro,TypeMacroArgs) 
  199.     &NCBI_NS_NCBI::CConstRefTypeInfo<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::GetTypeInfo, SERIAL_REF(TypeMacro)TypeMacroArgs
  201. #define SERIAL_TYPE_CHOICE(TypeMacro,TypeMacroArgs) 
  202.     SERIAL_TYPE(TypeMacro)TypeMacroArgs
  203. #define SERIAL_REF_CHOICE(TypeMacro,TypeMacroArgs) 
  204.     &NCBI_NS_NCBI::CChoicePointerTypeInfo::GetTypeInfo, 
  205.     SERIAL_REF(TypeMacro)TypeMacroArgs
  207. //#define SERIAL_TYPE_CHOICERef(ClassName) NCBI_NS_NCBI::CRef<ClassName>
  208. //#define SERIAL_REF_CHOICERef(ClassName) &ClassName::GetChoiceRefTypeInfo
  209. #define SERIAL_TYPE_CHOICERef(TypeMacro,TypeMacroArgs) 
  210.     NCBI_NS_NCBI::CRef<SERIAL_TYPE(TypeMacro)TypeMacroArgs >
  211. #define SERIAL_REF_CHOICERef(TypeMacro,TypeMacroArgs) 
  212.     &NCBI_NS_NCBI::CChoicePointerTypeInfo::GetTypeInfo, 
  213.     SERIAL_REF(TypeMacro)TypeMacroArgs
  215. template<typename T>
  216. struct Check
  217. {
  218.     static const void* Ptr(const T* member)
  219.         {
  220.             return member;
  221.         }
  222.     static const void* PtrPtr(T*const* member)
  223.         {
  224.             return member;
  225.         }
  226.     static const void* ObjectPtrPtr(T*const* member)
  227.         {
  228.             return member;
  229.         }
  230.     static const void* ObjectPtrPtr(CSerialObject*const* member)
  231.         {
  232.             return member;
  233.         }
  234. private:
  235.     Check(void);
  236.     ~Check(void);
  237.     Check(const Check<T>&);
  238.     Check<T>& operator=(const Check<T>&);
  239. };
  241. // Functions preventing memory leaks due to undestroyed type info objects
  242. NCBI_XSERIAL_EXPORT
  243. void RegisterEnumTypeValuesObject(CEnumeratedTypeValues* object);
  245. NCBI_XSERIAL_EXPORT
  246. void RegisterTypeInfoObject(CTypeInfo* object);
  248. template<typename T>
  249. inline
  250. TTypeInfo EnumTypeInfo(const T* member, const CEnumeratedTypeValues* enumInfo)
  251. {
  252.     return CreateEnumeratedTypeInfo(*member, enumInfo);
  253. }
  255. NCBI_XSERIAL_EXPORT SSystemMutex& GetTypeInfoMutex(void);
  257. // internal macros for implementing BEGIN_*_INFO and ADD_*_MEMBER
  258. #define DECLARE_BASE_OBJECT(ClassName) ClassName* base = 0
  259. #define BASE_OBJECT() static_cast<const CClass_Base*>(base)
  260. #define MEMBER_PTR(MemberName) &BASE_OBJECT()->MemberName
  261. #define CLASS_PTR(ClassName) static_cast<const ClassName*>(BASE_OBJECT())
  263. #define BEGIN_BASE_TYPE_INFO(ClassName,BaseClassName,Method,InfoType,Code) 
  264. const NCBI_NS_NCBI::CTypeInfo* Method(void) 
  265. { 
  266.     typedef ClassName CClass; 
  267.     typedef BaseClassName CClass_Base; 
  268.     static InfoType* volatile s_info = 0; 
  269.     InfoType* info = s_info; 
  270.     if ( !info ) { 
  271.         NCBI_NS_NCBI::CMutexGuard GUARD(NCBI_NS_NCBI::GetTypeInfoMutex()); 
  272.         info = s_info; 
  273.         if ( !info ) { 
  274.             DECLARE_BASE_OBJECT(CClass); 
  275.             info = Code; 
  276.             NCBI_NS_NCBI::RegisterTypeInfoObject(info);
  277. #define BEGIN_TYPE_INFO(ClassName, Method, InfoType, Code) 
  278.     BEGIN_BASE_TYPE_INFO(ClassName, ClassName, Method, InfoType, Code)
  279.     
  280. #define END_TYPE_INFO 
  281.             s_info = info; 
  282.         } 
  283.     } 
  284.     return info; 
  285. }
  287. // macros for specifying differents members
  288. #define SERIAL_MEMBER(MemberName,TypeMacro,TypeMacroArgs) 
  289.     NCBI_NS_NCBI::Check<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::Ptr(MEMBER_PTR(MemberName)), SERIAL_REF(TypeMacro)TypeMacroArgs
  290. #define SERIAL_STD_MEMBER(MemberName) 
  291.     MEMBER_PTR(MemberName),NCBI_NS_NCBI::GetStdTypeInfoGetter(MEMBER_PTR(MemberName))
  292. #define SERIAL_CLASS_MEMBER(MemberName) 
  293.     MEMBER_PTR(MemberName),&MEMBER_PTR(MemberName).GetTypeInfo
  294. #define SERIAL_ENUM_MEMBER(MemberName,EnumName) 
  295.     MEMBER_PTR(MemberName), NCBI_NS_NCBI::EnumTypeInfo(MEMBER_PTR(MemberName), ENUM_METHOD_NAME(EnumName)())
  296. #define SERIAL_ENUM_IN_MEMBER(MemberName,CppContext,EnumName) 
  297.     MEMBER_PTR(MemberName), NCBI_NS_NCBI::EnumTypeInfo(MEMBER_PTR(MemberName),CppContext ENUM_METHOD_NAME(EnumName)())
  298. #define SERIAL_REF_MEMBER(MemberName,ClassName) 
  299.     SERIAL_MEMBER(MemberName,STL_CRef,(CLASS,(ClassName)))
  300. #define SERIAL_PTR_CHOICE_VARIANT(MemberName,TypeMacro,TypeMacroArgs) 
  301.     NCBI_NS_NCBI::Check<SERIAL_TYPE(TypeMacro)TypeMacroArgs >::PtrPtr(MEMBER_PTR(MemberName)), SERIAL_REF(TypeMacro)TypeMacroArgs
  302. #define SERIAL_REF_CHOICE_VARIANT(MemberName,ClassName) 
  303.     NCBI_NS_NCBI::Check<SERIAL_TYPE(CLASS)(ClassName)>::ObjectPtrPtr(MEMBER_PTR(MemberName)), SERIAL_REF(CLASS)(ClassName)
  304. #define SERIAL_BASE_CLASS(ClassName) 
  305.     CLASS_PTR(ClassName),&(CLASS_PTR(ClassName)->GetTypeInfo)
  307. // ADD_NAMED_*_MEMBER macros    
  308. #define ADD_NAMED_NULL_MEMBER(MemberAlias,TypeMacro,TypeMacroArgs) 
  309.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  310.                             0,SERIAL_REF(TypeMacro)TypeMacroArgs)
  311. #define ADD_NAMED_MEMBER(MemberAlias,MemberName,TypeMacro,TypeMacroArgs) 
  312.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  313.                             SERIAL_MEMBER(MemberName,TypeMacro,TypeMacroArgs))
  314. #define ADD_NAMED_STD_MEMBER(MemberAlias,MemberName) 
  315.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  316.                             SERIAL_STD_MEMBER(MemberName))
  317. #define ADD_NAMED_CLASS_MEMBER(MemberAlias,MemberName) 
  318.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  319.                             SERIAL_CLASS_MEMBER(MemberName))
  320. #define ADD_NAMED_ENUM_MEMBER(MemberAlias,MemberName,EnumName) 
  321.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  322.                             SERIAL_ENUM_MEMBER(MemberName,EnumName))
  323. #define ADD_NAMED_ENUM_IN_MEMBER(MemberAlias,MemberName,CppContext,EnumName) 
  324.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  325.                   SERIAL_ENUM_IN_MEMBER(MemberName,CppContext,EnumName))
  326. #define ADD_NAMED_REF_MEMBER(MemberAlias,MemberName,ClassName) 
  327.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  328.                             SERIAL_REF_MEMBER(MemberName,ClassName))
  329. #define ADD_NAMED_BASE_CLASS(MemberAlias,ClassName) 
  330.     NCBI_NS_NCBI::AddMember(info,MemberAlias, 
  331.                             SERIAL_BASE_CLASS(ClassName))
  333. // ADD_*_MEMBER macros    
  334. #define ADD_MEMBER(MemberName,TypeMacro,TypeMacroArgs) 
  335.     ADD_NAMED_MEMBER(#MemberName,MemberName,TypeMacro,TypeMacroArgs)
  336. #define ADD_STD_MEMBER(MemberName) 
  337.     ADD_NAMED_STD_MEMBER(#MemberName,MemberName)
  338. #define ADD_CLASS_MEMBER(MemberName) 
  339.     ADD_NAMED_CLASS_MEMBER(#MemberName,MemberName)
  340. #define ADD_ENUM_MEMBER(MemberName,EnumName) 
  341.     ADD_NAMED_ENUM_MEMBER(#MemberName,MemberName,EnumName)
  342. #define ADD_ENUM_IN_MEMBER(MemberName,CppContext,EnumName) 
  343.     ADD_NAMED_ENUM_MEMBER(#MemberName,MemberName,CppContext,EnumName)
  344. #define ADD_REF_MEMBER(MemberName,ClassName) 
  345.     ADD_NAMED_REF_MEMBER(#MemberName,MemberName,ClassName)
  347. // ADD_NAMED_*_CHOICE_VARIANT macros    
  348. #define ADD_NAMED_NULL_CHOICE_VARIANT(MemberAlias,TypeMacro,TypeMacroArgs) 
  349.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  350.         0,SERIAL_REF(TypeMacro)TypeMacroArgs)
  351. #define ADD_NAMED_CHOICE_VARIANT(MemberAlias,MemberName,TypeMacro,TypeMacroArgs) 
  352.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  353.         SERIAL_MEMBER(MemberName,TypeMacro,TypeMacroArgs))
  354. #define ADD_NAMED_STD_CHOICE_VARIANT(MemberAlias,MemberName) 
  355.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  356.         SERIAL_STD_MEMBER(MemberName))
  357. #define ADD_NAMED_ENUM_CHOICE_VARIANT(MemberAlias,MemberName,EnumName) 
  358.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  359.         SERIAL_ENUM_MEMBER(MemberName,EnumName))
  360. #define ADD_NAMED_ENUM_IN_CHOICE_VARIANT(MemberAlias,MemberName,CppContext,EnumName) 
  361.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  362.         SERIAL_ENUM_IN_MEMBER(MemberName,CppContext,EnumName))
  363. #define ADD_NAMED_PTR_CHOICE_VARIANT(MemberAlias,MemberName,TypeMacro,TypeMacroArgs) 
  364.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  365.         SERIAL_PTR_CHOICE_VARIANT(MemberName,TypeMacro,TypeMacroArgs))->SetPointer()
  366. #define ADD_NAMED_REF_CHOICE_VARIANT(MemberAlias,MemberName,ClassName) 
  367.     NCBI_NS_NCBI::AddVariant(info,MemberAlias, 
  368.         SERIAL_REF_CHOICE_VARIANT(MemberName,ClassName))->SetObjectPointer()
  370. // ADD_*_CHOICE_VARIANT macros
  371. #define ADD_CHOICE_VARIANT(MemberName,TypeMacro,TypeMacroArgs) 
  372.     ADD_NAMED_CHOICE_VARIANT(#MemberName,MemberName,TypeMacro,TypeMacroArgs)
  373. #define ADD_STD_CHOICE_VARIANT(MemberName) 
  374.     ADD_NAMED_STD_CHOICE_VARIANT(#MemberName,MemberName)
  375. #define ADD_ENUM_CHOICE_VARIANT(MemberName,EnumName) 
  376.     ADD_NAMED_ENUM_CHOICE_VARIANT(#MemberName,MemberName,EnumName)
  377. #define ADD_ENUM_IN_CHOICE_VARIANT(MemberName,CppContext,EnumName) 
  378.     ADD_NAMED_ENUM_IN_CHOICE_VARIANT(#MemberName,MemberName,CppContext,EnumName)
  379. #define ADD_PTR_CHOICE_VARIANT(MemberName,TypeMacro,TypeMacroArgs) 
  380.     ADD_NAMED_PTR_CHOICE_VARIANT(#MemberName,MemberName,TypeMacro,TypeMacroArgs)
  381. #define ADD_REF_CHOICE_VARIANT(MemberName,ClassName) 
  382.     ADD_NAMED_REF_CHOICE_VARIANT(#MemberName,MemberName,ClassName)
  384. // type info definition macros
  385. #define BEGIN_NAMED_CLASS_INFO(ClassAlias,ClassName) 
  386.     BEGIN_TYPE_INFO(ClassName, 
  387.         ClassName::GetTypeInfo, 
  388.         NCBI_NS_NCBI::CClassTypeInfo, 
  389.         NCBI_NS_NCBI::CClassInfoHelper<CClass>::CreateClassInfo(ClassAlias))
  390. #define BEGIN_CLASS_INFO(ClassName) 
  391.     BEGIN_NAMED_CLASS_INFO(#ClassName, ClassName)
  392. #define BEGIN_NAMED_BASE_CLASS_INFO(ClassAlias,ClassName) 
  393.     BEGIN_BASE_TYPE_INFO(ClassName, NCBI_NAME2(ClassName,_Base), 
  394.         NCBI_NAME2(ClassName,_Base)::GetTypeInfo, 
  395.         NCBI_NS_NCBI::CClassTypeInfo, 
  396.         NCBI_NS_NCBI::CClassInfoHelper<CClass>::CreateClassInfo(ClassAlias))
  397. #define BEGIN_BASE_CLASS_INFO(ClassName) 
  398.     BEGIN_NAMED_BASE_CLASS_INFO(#ClassName, ClassName)
  400. #define SET_CLASS_IMPLICIT() info->SetImplicit()
  401. #define BEGIN_NAMED_IMPLICIT_CLASS_INFO(ClassAlias,ClassName) 
  402.     BEGIN_NAMED_CLASS_INFO(ClassAlias,ClassName); SET_CLASS_IMPLICIT();
  403. #define BEGIN_IMPLICIT_CLASS_INFO(ClassName) 
  404.     BEGIN_CLASS_INFO(ClassName); SET_CLASS_IMPLICIT();
  405. #define BEGIN_NAMED_BASE_IMPLICIT_CLASS_INFO(ClassAlias,ClassName) 
  406.     BEGIN_NAMED_BASE_CLASS_INFO(ClassAlias,ClassName); SET_CLASS_IMPLICIT();
  407. #define BEGIN_BASE_IMPLICIT_CLASS_INFO(ClassName) 
  408.     BEGIN_BASE_CLASS_INFO(ClassName); SET_CLASS_IMPLICIT();
  410. #define SET_CLASS_MODULE(ModuleName) 
  411.     NCBI_NS_NCBI::SetModuleName(info, ModuleName)
  413. #define END_CLASS_INFO END_TYPE_INFO
  415. #define BEGIN_NAMED_ABSTRACT_CLASS_INFO(ClassAlias,ClassName) 
  416.     BEGIN_TYPE_INFO(ClassName, 
  417.         ClassName::GetTypeInfo, 
  418.         NCBI_NS_NCBI::CClassTypeInfo, 
  419.         NCBI_NS_NCBI::CClassInfoHelper<CClass>::CreateAbstractClassInfo(ClassAlias))
  420. #define BEGIN_ABSTRACT_CLASS_INFO(ClassName) 
  421.     BEGIN_NAMED_ABSTRACT_CLASS_INFO(#ClassName, ClassName)
  422. #define BEGIN_NAMED_ABSTRACT_BASE_CLASS_INFO(ClassAlias,ClassName) 
  423.     BEGIN_BASE_TYPE_INFO(ClassName, NCBI_NAME2(ClassName,_Base), 
  424.         NCBI_NAME2(ClassName,_Base)::GetTypeInfo, 
  425.         NCBI_NS_NCBI::CClassTypeInfo, 
  426.         NCBI_NS_NCBI::CClassInfoHelper<CClass>::CreateAbstractClassInfo(ClassAlias))
  428. #define END_ABSTRACT_CLASS_INFO END_TYPE_INFO
  430. #define BEGIN_NAMED_DERIVED_CLASS_INFO(ClassAlias,ClassName,ParentClassName) 
  431.     BEGIN_NAMED_CLASS_INFO(ClassAlias,ClassName) 
  432.     SET_PARENT_CLASS(ParentClassName);
  433. #define BEGIN_DERIVED_CLASS_INFO(ClassName,ParentClassName) 
  434.     BEGIN_NAMED_DERIVED_CLASS_INFO(#ClassName, ClassName, ParentClassName)
  436. #define END_DERIVED_CLASS_INFO END_TYPE_INFO
  438. #define BEGIN_NAMED_CHOICE_INFO(ClassAlias,ClassName) 
  439.     BEGIN_TYPE_INFO(ClassName, 
  440.         ClassName::GetTypeInfo, 
  441.         NCBI_NS_NCBI::CChoiceTypeInfo, 
  442.         NCBI_NS_NCBI::CClassInfoHelper<CClass>::CreateChoiceInfo(ClassAlias))
  443. #define BEGIN_CHOICE_INFO(ClassName) 
  444.     BEGIN_NAMED_CHOICE_INFO(#ClassName, ClassName)
  445. #define BEGIN_NAMED_BASE_CHOICE_INFO(ClassAlias,ClassName) 
  446.     BEGIN_BASE_TYPE_INFO(ClassName, NCBI_NAME2(ClassName,_Base), 
  447.         NCBI_NAME2(ClassName,_Base)::GetTypeInfo, 
  448.         NCBI_NS_NCBI::CChoiceTypeInfo, 
  449.         NCBI_NS_NCBI::CClassInfoHelper<CClass>::CreateChoiceInfo(ClassAlias))
  450. #define BEGIN_BASE_CHOICE_INFO(ClassName) 
  451.     BEGIN_NAMED_BASE_CHOICE_INFO(#ClassName, ClassName)
  453. #define SET_CHOICE_MODULE(ModuleName) 
  454.     NCBI_NS_NCBI::SetModuleName(info, ModuleName)
  456. #define SET_CHOICE_DELAYED() 
  457.     info->SetSelectDelay(&NCBI_NS_NCBI::CClassInfoHelper<CClass>::SelectDelayBuffer)
  459. #define END_CHOICE_INFO END_TYPE_INFO
  461. // sub class definition
  462. #define SET_PARENT_CLASS(ParentClassName) 
  463.     info->SetParentClass(ParentClassName::GetTypeInfo())
  464. #define ADD_NAMED_SUB_CLASS(SubClassAlias, SubClassName) 
  465.     info->AddSubClass(SubClassAlias, &SubClassName::GetTypeInfo)
  466. #define ADD_SUB_CLASS(SubClassName) 
  467.     ADD_NAMED_SUB_CLASS(#SubClassName, SubClassName)
  468. #define ADD_NAMED_NULL_SUB_CLASS(ClassAlias) 
  469.     info->AddSubClassNull(ClassAlias)
  470. #define ADD_NULL_SUB_CLASS(ClassAlias) 
  471.     ADD_NAMED_NULL_SUB_CLASS("NULL")
  473. // enum definition macros
  474. #define BEGIN_ENUM_INFO_METHOD(MethodName, EnumAlias, EnumName, IsInteger) 
  475. const NCBI_NS_NCBI::CEnumeratedTypeValues* MethodName(void) 
  476. { 
  477.     static NCBI_NS_NCBI::CEnumeratedTypeValues* volatile s_enumInfo = 0; 
  478.     NCBI_NS_NCBI::CEnumeratedTypeValues* enumInfo = s_enumInfo; 
  479.     if ( !enumInfo ) { 
  480.         NCBI_NS_NCBI::CMutexGuard GUARD(NCBI_NS_NCBI::GetTypeInfoMutex()); 
  481.         enumInfo = s_enumInfo; 
  482.         if ( !enumInfo ) { 
  483.             enumInfo = new NCBI_NS_NCBI::CEnumeratedTypeValues(EnumAlias, IsInteger); 
  484.             NCBI_NS_NCBI::RegisterEnumTypeValuesObject(enumInfo); 
  485.             EnumName enumValue;
  486. #define END_ENUM_INFO_METHOD 
  487.             s_enumInfo = enumInfo; 
  488.         } 
  489.     } 
  490.     return enumInfo; 
  491. }
  493. #define BEGIN_NAMED_ENUM_IN_INFO(EnumAlias, CppContext, EnumName, IsInteger) 
  494.     BEGIN_ENUM_INFO_METHOD(CppContext ENUM_METHOD_NAME(EnumName), EnumAlias, EnumName, IsInteger)
  495. #define BEGIN_NAMED_ENUM_INFO(EnumAlias, EnumName, IsInteger) 
  496.     BEGIN_ENUM_INFO_METHOD(ENUM_METHOD_NAME(EnumName), EnumAlias, EnumName, IsInteger)
  498. #define BEGIN_ENUM_IN_INFO(CppContext, EnumName, IsInteger) 
  499.     BEGIN_NAMED_ENUM_IN_INFO(#EnumName, CppContext, EnumName, IsInteger)
  500. #define BEGIN_ENUM_INFO(EnumName, IsInteger) 
  501.     BEGIN_NAMED_ENUM_INFO(#EnumName, EnumName, IsInteger)
  503. #define SET_ENUM_MODULE(ModuleName) 
  504.     NCBI_NS_NCBI::SetModuleName(enumInfo, ModuleName)
  506. #define ADD_ENUM_VALUE(EnumValueName, EnumValueValue) 
  507.     enumInfo->AddValue(EnumValueName, enumValue = EnumValueValue)
  509. #define END_ENUM_IN_INFO END_ENUM_INFO_METHOD
  510. #define END_ENUM_INFO END_ENUM_INFO_METHOD
  512. // alias definition macros
  513. #define SERIAL_ALIAS(RefType) 
  514.     NCBI_NAME2(SERIAL_REF_, RefType)
  515. #define ALIASED_TYPE_INFO(RefType, RefCode) 
  516.     NCBI_NAME2(RefType, RefCode)
  517. #define BEGIN_ALIAS_INFO_METHOD(AliasName,ClassName,BaseClassName,SerialRef,Code) 
  518. const NCBI_NS_NCBI::CTypeInfo* BaseClassName::GetTypeInfo(void) 
  519. { 
  520.     static NCBI_NS_NCBI::CAliasTypeInfo* volatile s_info = 0; 
  521.     NCBI_NS_NCBI::CAliasTypeInfo* info = s_info; 
  522.     if ( !info ) { 
  523.         NCBI_NS_NCBI::CMutexGuard GUARD(NCBI_NS_NCBI::GetTypeInfoMutex()); 
  524.         info = s_info; 
  525.         if ( !info ) { 
  526.             typedef ClassName CClass; 
  527.             typedef BaseClassName CClass_Base; 
  528.             DECLARE_BASE_OBJECT(ClassName); 
  529.             typedef NCBI_NS_NCBI::TTypeInfo (*TGetter)(void); 
  530.             TGetter getter = SerialRef Code; 
  531.             info = new NCBI_NS_NCBI::CAliasTypeInfo(AliasName, getter()); 
  532.             NCBI_NS_NCBI::RegisterTypeInfoObject(info);
  533. #define BEGIN_ALIAS_INFO(AliasName,ClassName,RefType,RefCode) 
  534.     BEGIN_ALIAS_INFO_METHOD(AliasName, ClassName, 
  535.     NCBI_NAME2(ClassName,_Base), 
  536.     SERIAL_ALIAS(RefType), RefCode)
  537. #define SET_STD_ALIAS_DATA_PTR 
  538.     info->SetDataOffset(GetDataPtr(BASE_OBJECT()))
  539. #define SET_CLASS_ALIAS_DATA_PTR 
  540.     info->SetDataOffset(NCBI_NS_NCBI::TPointerOffsetType(BASE_OBJECT()))
  541. #define END_ALIAS_INFO 
  542.             s_info = info; 
  543.         } 
  544.     } 
  545.     return info; 
  546. }
  547. #define SET_ALIAS_MODULE(ModuleName) 
  548.     NCBI_NS_NCBI::SetModuleName(info, ModuleName)
  552. NCBI_XSERIAL_EXPORT
  553. void SetModuleName(CTypeInfo* info, const char* name);
  555. NCBI_XSERIAL_EXPORT
  556. void SetModuleName(CEnumeratedTypeValues* info, const char* name);
  558. // internal methods
  559. // add member
  560. NCBI_XSERIAL_EXPORT
  561. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  562.                        const void* member,
  563.                        TTypeInfo t);
  564. NCBI_XSERIAL_EXPORT
  565. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  566.                        const void* member,
  567.                        TTypeInfoGetter f);
  568. NCBI_XSERIAL_EXPORT
  569. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  570.                        const void* member,
  571.                        const CTypeRef& r);
  572. NCBI_XSERIAL_EXPORT
  573. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  574.                        const void* member,
  575.                        TTypeInfoGetter1 f1,
  576.                        TTypeInfo t);
  577. NCBI_XSERIAL_EXPORT
  578. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  579.                        const void* member,
  580.                        TTypeInfoGetter1 f1,
  581.                        TTypeInfoGetter f);
  582. NCBI_XSERIAL_EXPORT
  583. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  584.                        const void* member,
  585.                        TTypeInfoGetter1 f1,
  586.                        const CTypeRef& r);
  587. NCBI_XSERIAL_EXPORT
  588. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  589.                        const void* member,
  590.                        TTypeInfoGetter1 f2,
  591.                        TTypeInfoGetter1 f1,
  592.                        TTypeInfo t);
  593. NCBI_XSERIAL_EXPORT
  594. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  595.                        const void* member,
  596.                        TTypeInfoGetter1 f2,
  597.                        TTypeInfoGetter1 f1,
  598.                        TTypeInfoGetter f);
  599. NCBI_XSERIAL_EXPORT
  600. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  601.                        const void* member,
  602.                        TTypeInfoGetter1 f2,
  603.                        TTypeInfoGetter1 f1,
  604.                        const CTypeRef& r);
  605. NCBI_XSERIAL_EXPORT
  606. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  607.                        const void* member,
  608.                        TTypeInfoGetter1 f3,
  609.                        TTypeInfoGetter1 f2,
  610.                        TTypeInfoGetter1 f1,
  611.                        TTypeInfo t);
  612. NCBI_XSERIAL_EXPORT
  613. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  614.                        const void* member,
  615.                        TTypeInfoGetter1 f3,
  616.                        TTypeInfoGetter1 f2,
  617.                        TTypeInfoGetter1 f1,
  618.                        TTypeInfoGetter f);
  619. NCBI_XSERIAL_EXPORT
  620. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  621.                        const void* member,
  622.                        TTypeInfoGetter1 f3,
  623.                        TTypeInfoGetter1 f2,
  624.                        TTypeInfoGetter1 f1,
  625.                        const CTypeRef& r);
  626. NCBI_XSERIAL_EXPORT
  627. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  628.                        const void* member,
  629.                        TTypeInfoGetter1 f4,
  630.                        TTypeInfoGetter1 f3,
  631.                        TTypeInfoGetter1 f2,
  632.                        TTypeInfoGetter1 f1,
  633.                        TTypeInfo t);
  634. NCBI_XSERIAL_EXPORT
  635. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  636.                        const void* member,
  637.                        TTypeInfoGetter1 f4,
  638.                        TTypeInfoGetter1 f3,
  639.                        TTypeInfoGetter1 f2,
  640.                        TTypeInfoGetter1 f1,
  641.                        TTypeInfoGetter f);
  642. NCBI_XSERIAL_EXPORT
  643. CMemberInfo* AddMember(CClassTypeInfoBase* info, const char* name,
  644.                        const void* member,
  645.                        TTypeInfoGetter1 f4,
  646.                        TTypeInfoGetter1 f3,
  647.                        TTypeInfoGetter1 f2,
  648.                        TTypeInfoGetter1 f1,
  649.                        const CTypeRef& r);
  650. // add variant
  651. NCBI_XSERIAL_EXPORT
  652. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  653.                        const void* member,
  654.                        TTypeInfo t);
  655. NCBI_XSERIAL_EXPORT
  656. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  657.                        const void* member,
  658.                        TTypeInfoGetter f);
  659. NCBI_XSERIAL_EXPORT
  660. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  661.                        const void* member,
  662.                        const CTypeRef& r);
  663. NCBI_XSERIAL_EXPORT
  664. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  665.                        const void* member,
  666.                        TTypeInfoGetter1 f1,
  667.                        TTypeInfo t);
  668. NCBI_XSERIAL_EXPORT
  669. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  670.                        const void* member,
  671.                        TTypeInfoGetter1 f1,
  672.                        TTypeInfoGetter f);
  673. NCBI_XSERIAL_EXPORT
  674. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  675.                        const void* member,
  676.                        TTypeInfoGetter1 f1,
  677.                        const CTypeRef& r);
  678. NCBI_XSERIAL_EXPORT
  679. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  680.                        const void* member,
  681.                        TTypeInfoGetter1 f2,
  682.                        TTypeInfoGetter1 f1,
  683.                        TTypeInfo t);
  684. NCBI_XSERIAL_EXPORT
  685. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  686.                        const void* member,
  687.                        TTypeInfoGetter1 f2,
  688.                        TTypeInfoGetter1 f1,
  689.                        TTypeInfoGetter f);
  690. NCBI_XSERIAL_EXPORT
  691. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  692.                        const void* member,
  693.                        TTypeInfoGetter1 f2,
  694.                        TTypeInfoGetter1 f1,
  695.                        const CTypeRef& r);
  696. NCBI_XSERIAL_EXPORT
  697. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  698.                        const void* member,
  699.                        TTypeInfoGetter1 f3,
  700.                        TTypeInfoGetter1 f2,
  701.                        TTypeInfoGetter1 f1,
  702.                        TTypeInfo t);
  703. NCBI_XSERIAL_EXPORT
  704. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  705.                        const void* member,
  706.                        TTypeInfoGetter1 f3,
  707.                        TTypeInfoGetter1 f2,
  708.                        TTypeInfoGetter1 f1,
  709.                        TTypeInfoGetter f);
  710. NCBI_XSERIAL_EXPORT
  711. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  712.                        const void* member,
  713.                        TTypeInfoGetter1 f3,
  714.                        TTypeInfoGetter1 f2,
  715.                        TTypeInfoGetter1 f1,
  716.                        const CTypeRef& r);
  717. NCBI_XSERIAL_EXPORT
  718. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  719.                        const void* member,
  720.                        TTypeInfoGetter1 f4,
  721.                        TTypeInfoGetter1 f3,
  722.                        TTypeInfoGetter1 f2,
  723.                        TTypeInfoGetter1 f1,
  724.                        TTypeInfo t);
  725. NCBI_XSERIAL_EXPORT
  726. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  727.                        const void* member,
  728.                        TTypeInfoGetter1 f4,
  729.                        TTypeInfoGetter1 f3,
  730.                        TTypeInfoGetter1 f2,
  731.                        TTypeInfoGetter1 f1,
  732.                        TTypeInfoGetter f);
  733. NCBI_XSERIAL_EXPORT
  734. CVariantInfo* AddVariant(CChoiceTypeInfo* info, const char* name,
  735.                        const void* member,
  736.                        TTypeInfoGetter1 f4,
  737.                        TTypeInfoGetter1 f3,
  738.                        TTypeInfoGetter1 f2,
  739.                        TTypeInfoGetter1 f1,
  740.                        const CTypeRef& r);
  741. // end of internal methods
  743. END_NCBI_SCOPE
  746. /* @} */
  749. #endif