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

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

生物技术

开发平台：

C/C++

member.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: member.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:40:26  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.38
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: member.cpp,v 1000.3 2004/06/01 19:40:26 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. */
  43. #include <ncbi_pch.hpp>
  44. #include <corelib/ncbistd.hpp>
  45. #include <corelib/ncbimtx.hpp>
  47. #include <serial/member.hpp>
  48. #include <serial/objectinfo.hpp>
  49. #include <serial/objectiter.hpp>
  50. #include <serial/objistr.hpp>
  51. #include <serial/objostr.hpp>
  52. #include <serial/objcopy.hpp>
  53. #include <serial/delaybuf.hpp>
  54. #include <serial/serialimpl.hpp>
  55. #ifdef _DEBUG
  56. #include <serial/serialbase.hpp>
  57. #endif
  58. #include <memory>
  60. BEGIN_NCBI_SCOPE
  62. class CMemberInfoFunctions
  63. {
  64. public:
  65.     static TConstObjectPtr GetConstSimpleMember(const CMemberInfo* memberInfo,
  66.                                                 TConstObjectPtr classPtr);
  67.     static TConstObjectPtr GetConstDelayedMember(const CMemberInfo* memberInfo,
  68.                                                  TConstObjectPtr classPtr);
  69.     static TObjectPtr GetSimpleMember(const CMemberInfo* memberInfo,
  70.                                       TObjectPtr classPtr);
  71.     static TObjectPtr GetWithSetFlagMember(const CMemberInfo* memberInfo,
  72.                                            TObjectPtr classPtr);
  73.     static TObjectPtr GetDelayedMember(const CMemberInfo* memberInfo,
  74.                                        TObjectPtr classPtr);
  75.     
  77.     static void ReadSimpleMember(CObjectIStream& in,
  78.                                  const CMemberInfo* memberInfo,
  79.                                  TObjectPtr classPtr);
  80.     static void ReadWithSetFlagMember(CObjectIStream& in,
  81.                                         const CMemberInfo* memberInfo,
  82.                                         TObjectPtr classPtr);
  83.     static void ReadLongMember(CObjectIStream& in,
  84.                                  const CMemberInfo* memberInfo,
  85.                                  TObjectPtr classPtr);
  86.     static void ReadHookedMember(CObjectIStream& in,
  87.                                  const CMemberInfo* memberInfo,
  88.                                  TObjectPtr classPtr);
  89.     static void ReadMissingSimpleMember(CObjectIStream& in,
  90.                                         const CMemberInfo* memberInfo,
  91.                                         TObjectPtr classPtr);
  92.     static void ReadMissingWithSetFlagMember(CObjectIStream& in,
  93.                                              const CMemberInfo* memberInfo,
  94.                                              TObjectPtr classPtr);
  95.     static void ReadMissingOptionalMember(CObjectIStream& in,
  96.                                             const CMemberInfo* memberInfo,
  97.                                             TObjectPtr classPtr);
  98.     static void ReadMissingHookedMember(CObjectIStream& in,
  99.                                         const CMemberInfo* memberInfo,
  100.                                         TObjectPtr classPtr);
  101.     static void WriteSimpleMember(CObjectOStream& out,
  102.                                   const CMemberInfo* memberInfo,
  103.                                   TConstObjectPtr classPtr);
  104.     static void WriteOptionalMember(CObjectOStream& out,
  105.                                       const CMemberInfo* memberInfo,
  106.                                       TConstObjectPtr classPtr);
  107.     static void WriteWithDefaultMember(CObjectOStream& out,
  108.                                          const CMemberInfo* memberInfo,
  109.                                          TConstObjectPtr classPtr);
  110.     static void WriteWithSetFlagMember(CObjectOStream& out,
  111.                                          const CMemberInfo* memberInfo,
  112.                                          TConstObjectPtr classPtr);
  113.     static void WriteLongMember(CObjectOStream& out,
  114.                                   const CMemberInfo* memberInfo,
  115.                                   TConstObjectPtr classPtr);
  116.     static void WriteHookedMember(CObjectOStream& out,
  117.                                   const CMemberInfo* memberInfo,
  118.                                   TConstObjectPtr classPtr);
  119.     static void SkipSimpleMember(CObjectIStream& in,
  120.                                  const CMemberInfo* memberInfo);
  121.     static void SkipMissingSimpleMember(CObjectIStream& in,
  122.                                         const CMemberInfo* memberInfo);
  123.     static void SkipMissingOptionalMember(CObjectIStream& in,
  124.                                           const CMemberInfo* memberInfo);
  125.     static void SkipHookedMember(CObjectIStream& in,
  126.                                  const CMemberInfo* memberInfo);
  127.     static void SkipMissingHookedMember(CObjectIStream& in,
  128.                                         const CMemberInfo* memberInfo);
  129.     static void CopySimpleMember(CObjectStreamCopier& copier,
  130.                                  const CMemberInfo* memberInfo);
  131.     static void CopyHookedMember(CObjectStreamCopier& copier,
  132.                                  const CMemberInfo* memberInfo);
  133.     static void CopyMissingSimpleMember(CObjectStreamCopier& copier,
  134.                                         const CMemberInfo* memberInfo);
  135.     static void CopyMissingOptionalMember(CObjectStreamCopier& copier,
  136.                                             const CMemberInfo* memberInfo);
  137.     static void CopyMissingHookedMember(CObjectStreamCopier& copier,
  138.                                         const CMemberInfo* memberInfo);
  141.     static void ReadParentClass(CObjectIStream& in,
  142.                                 const CMemberInfo* memberInfo,
  143.                                 TObjectPtr objectPtr);
  144.     static void ReadMissingParentClass(CObjectIStream& in,
  145.                                        const CMemberInfo* memberInfo,
  146.                                        TObjectPtr objectPtr);
  147.     static void WriteParentClass(CObjectOStream& out,
  148.                                  const CMemberInfo* memberInfo,
  149.                                  TConstObjectPtr objectPtr);
  150.     static void CopyParentClass(CObjectStreamCopier& copier,
  151.                                 const CMemberInfo* memberInfo);
  152.     static void CopyMissingParentClass(CObjectStreamCopier& copier,
  153.                                        const CMemberInfo* memberInfo);
  154.     static void SkipParentClass(CObjectIStream& in,
  155.                                 const CMemberInfo* memberInfo);
  156.     static void SkipMissingParentClass(CObjectIStream& in,
  157.                                        const CMemberInfo* memberInfo);
  158. };
  160. typedef CMemberInfoFunctions TFunc;
  162. CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
  163.                          const CMemberId& id, TPointerOffsetType offset,
  164.                          const CTypeRef& type)
  165.     : CParent(id, offset, type),
  166.       m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
  167.       m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
  168.       m_DelayOffset(eNoOffset),
  169.       m_GetConstFunction(&TFunc::GetConstSimpleMember),
  170.       m_GetFunction(&TFunc::GetSimpleMember),
  171.       m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
  172.                                           &TFunc::ReadMissingSimpleMember),
  173.                      SMemberReadFunctions(&TFunc::ReadHookedMember,
  174.                                           &TFunc::ReadMissingHookedMember)),
  175.       m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
  176.       m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
  177.                                           &TFunc::SkipMissingSimpleMember),
  178.                      SMemberSkipFunctions(&TFunc::SkipHookedMember,
  179.                                           &TFunc::SkipMissingHookedMember)),
  180.       m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
  181.                                           &TFunc::CopyMissingSimpleMember),
  182.                      SMemberCopyFunctions(&TFunc::CopyHookedMember,
  183.                                           &TFunc::CopyMissingHookedMember))
  184. {
  185. }
  187. CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
  188.                          const CMemberId& id, TPointerOffsetType offset,
  189.                          TTypeInfo type)
  190.     : CParent(id, offset, type),
  191.       m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
  192.       m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
  193.       m_DelayOffset(eNoOffset),
  194.       m_GetConstFunction(&TFunc::GetConstSimpleMember),
  195.       m_GetFunction(&TFunc::GetSimpleMember),
  196.       m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
  197.                                           &TFunc::ReadMissingSimpleMember),
  198.                      SMemberReadFunctions(&TFunc::ReadHookedMember,
  199.                                           &TFunc::ReadMissingHookedMember)),
  200.       m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
  201.       m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
  202.                                           &TFunc::SkipMissingSimpleMember),
  203.                      SMemberSkipFunctions(&TFunc::SkipHookedMember,
  204.                                           &TFunc::SkipMissingHookedMember)),
  205.       m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
  206.                                           &TFunc::CopyMissingSimpleMember),
  207.                      SMemberCopyFunctions(&TFunc::CopyHookedMember,
  208.                                           &TFunc::CopyMissingHookedMember))
  209. {
  210. }
  212. CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
  213.                          const char* id, TPointerOffsetType offset,
  214.                          const CTypeRef& type)
  215.     : CParent(id, offset, type),
  216.       m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
  217.       m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
  218.       m_DelayOffset(eNoOffset),
  219.       m_GetConstFunction(&TFunc::GetConstSimpleMember),
  220.       m_GetFunction(&TFunc::GetSimpleMember),
  221.       m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
  222.                                           &TFunc::ReadMissingSimpleMember),
  223.                      SMemberReadFunctions(&TFunc::ReadHookedMember,
  224.                                           &TFunc::ReadMissingHookedMember)),
  225.       m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
  226.       m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
  227.                                           &TFunc::SkipMissingSimpleMember),
  228.                      SMemberSkipFunctions(&TFunc::SkipHookedMember,
  229.                                           &TFunc::SkipMissingHookedMember)),
  230.       m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
  231.                                           &TFunc::CopyMissingSimpleMember),
  232.                      SMemberCopyFunctions(&TFunc::CopyHookedMember,
  233.                                           &TFunc::CopyMissingHookedMember))
  234. {
  235. }
  237. CMemberInfo::CMemberInfo(const CClassTypeInfoBase* classType,
  238.                          const char* id, TPointerOffsetType offset,
  239.                          TTypeInfo type)
  240.     : CParent(id, offset, type),
  241.       m_ClassType(classType), m_Optional(false), m_NonEmpty(false), m_Default(0),
  242.       m_SetFlagOffset(eNoOffset), m_BitSetFlag(false),
  243.       m_DelayOffset(eNoOffset),
  244.       m_GetConstFunction(&TFunc::GetConstSimpleMember),
  245.       m_GetFunction(&TFunc::GetSimpleMember),
  246.       m_ReadHookData(SMemberReadFunctions(&TFunc::ReadSimpleMember,
  247.                                           &TFunc::ReadMissingSimpleMember),
  248.                      SMemberReadFunctions(&TFunc::ReadHookedMember,
  249.                                           &TFunc::ReadMissingHookedMember)),
  250.       m_WriteHookData(&TFunc::WriteSimpleMember, &TFunc::WriteHookedMember),
  251.       m_SkipHookData(SMemberSkipFunctions(&TFunc::SkipSimpleMember,
  252.                                           &TFunc::SkipMissingSimpleMember),
  253.                      SMemberSkipFunctions(&TFunc::SkipHookedMember,
  254.                                           &TFunc::SkipMissingHookedMember)),
  255.       m_CopyHookData(SMemberCopyFunctions(&TFunc::CopySimpleMember,
  256.                                           &TFunc::CopyMissingSimpleMember),
  257.                      SMemberCopyFunctions(&TFunc::CopyHookedMember,
  258.                                           &TFunc::CopyMissingHookedMember))
  259. {
  260. }
  262. void CMemberInfo::SetParentClass(void)
  263. {
  264.     GetId().SetParentTag();
  265.     m_ReadHookData.SetDefaultFunction(
  266.         SMemberReadFunctions(&TFunc::ReadParentClass,
  267.                              &TFunc::ReadMissingParentClass));
  268.     m_WriteHookData.SetDefaultFunction(&TFunc::WriteParentClass);
  269.     m_SkipHookData.SetDefaultFunction(
  270.         SMemberSkipFunctions(&TFunc::SkipParentClass,
  271.                              &TFunc::SkipMissingParentClass));
  272.     m_CopyHookData.SetDefaultFunction(
  273.         SMemberCopyFunctions(&TFunc::CopyParentClass,
  274.                              &TFunc::CopyMissingParentClass));
  275. }
  277. CMemberInfo* CMemberInfo::SetDelayBuffer(CDelayBuffer* buffer)
  278. {
  279.     m_DelayOffset = TPointerOffsetType(buffer);
  280.     UpdateFunctions();
  281.     return this;
  282. }
  284. CMemberInfo* CMemberInfo::SetOptional(void)
  285. {
  286.     m_Optional = true;
  287.     UpdateFunctions();
  288.     return this;
  289. }
  291. CMemberInfo* CMemberInfo::SetNonEmpty(void)
  292. {
  293.     m_NonEmpty = true;
  294.     return this;
  295. }
  297. CMemberInfo* CMemberInfo::SetNoPrefix(void)
  298. {
  299.     GetId().SetNoPrefix();
  300.     return this;
  301. }
  303. CMemberInfo* CMemberInfo::SetAttlist(void)
  304. {
  305.     GetId().SetAttlist();
  306.     return this;
  307. }
  309. CMemberInfo* CMemberInfo::SetNotag(void)
  310. {
  311.     GetId().SetNotag();
  312.     return this;
  313. }
  315. CMemberInfo* CMemberInfo::SetAnyContent(void)
  316. {
  317.     GetId().SetAnyContent();
  318.     return this;
  319. }
  321. CMemberInfo* CMemberInfo::SetDefault(TConstObjectPtr def)
  322. {
  323.     m_Optional = true;
  324.     m_Default = def;
  325.     UpdateFunctions();
  326.     return this;
  327. }
  329. CMemberInfo* CMemberInfo::SetSetFlag(const bool* setFlag)
  330. {
  331.     _ASSERT(Optional());
  332.     m_SetFlagOffset = TPointerOffsetType(setFlag);
  333.     m_BitSetFlag = false;
  334.     UpdateFunctions();
  335.     return this;
  336. }
  338. CMemberInfo* CMemberInfo::SetSetFlag(const Uint4* setFlag)
  339. {
  340.     m_SetFlagOffset = TPointerOffsetType(setFlag);
  341.     m_BitSetFlag = true;
  342.     UpdateFunctions();
  343.     return this;
  344. }
  346. bool CMemberInfo::CompareSetFlags(TConstObjectPtr object1,
  347.                                   TConstObjectPtr object2) const
  348. {
  349.     return GetSetFlagNo(object1) == GetSetFlagNo(object2);
  350. }
  352. CMemberInfo* CMemberInfo::SetOptional(const bool* setFlag)
  353. {
  354.     m_Optional = true;
  355.     return SetSetFlag(setFlag);
  356. }
  358. void CMemberInfo::UpdateFunctions(void)
  359. {
  360.     // determine function pointers
  361.     TMemberGetConst getConstFunc;
  362.     TMemberGet getFunc;
  363.     SMemberReadFunctions readFuncs;
  364.     TMemberWriteFunction writeFunc;
  365.     SMemberSkipFunctions skipFuncs;
  366.     SMemberCopyFunctions copyFuncs;
  368.     // get/readmain/write
  369.     if ( CanBeDelayed() ) {
  370.         getConstFunc = &TFunc::GetConstDelayedMember;
  371.         getFunc = &TFunc::GetDelayedMember;
  372.         readFuncs.m_Main = &TFunc::ReadLongMember;
  373.         writeFunc = &TFunc::WriteLongMember;
  374.     }
  375.     else if ( !HaveSetFlag() ) {
  376.         getConstFunc = &TFunc::GetConstSimpleMember;
  377.         getFunc = &TFunc::GetSimpleMember;
  378.         readFuncs.m_Main = &TFunc::ReadSimpleMember;
  380.         if ( GetDefault() )
  381.             writeFunc = &TFunc::WriteWithDefaultMember;
  382.         else if ( Optional() )
  383.             writeFunc = &TFunc::WriteOptionalMember;
  384.         else
  385.             writeFunc = &TFunc::WriteSimpleMember;
  386.     }
  387.     else {
  388.         // have set flag
  389.         getConstFunc = &TFunc::GetConstSimpleMember;
  390.         getFunc = &TFunc::GetWithSetFlagMember;
  391.         readFuncs.m_Main = &TFunc::ReadWithSetFlagMember;
  392.         writeFunc = &TFunc::WriteWithSetFlagMember;
  393.     }
  395.     // copymain/skipmain
  396.     copyFuncs.m_Main = &TFunc::CopySimpleMember;
  397.     skipFuncs.m_Main = &TFunc::SkipSimpleMember;
  399.     // readmissing/copymissing/skipmissing
  400.     if ( Optional() ) {
  401.         if ( HaveSetFlag() ) {
  402.             readFuncs.m_Missing = &TFunc::ReadMissingWithSetFlagMember;
  403.         }
  404.         else {
  405.             readFuncs.m_Missing = &TFunc::ReadMissingOptionalMember;
  406.         }
  407.         copyFuncs.m_Missing = &TFunc::CopyMissingOptionalMember;
  408.         skipFuncs.m_Missing = &TFunc::SkipMissingOptionalMember;
  409.     }
  410.     else {
  411.         readFuncs.m_Missing = &TFunc::ReadMissingSimpleMember;
  412.         copyFuncs.m_Missing = &TFunc::CopyMissingSimpleMember;
  413.         skipFuncs.m_Missing = &TFunc::SkipMissingSimpleMember;
  414.     }
  416.     // update function pointers
  417.     m_GetConstFunction = getConstFunc;
  418.     m_GetFunction = getFunc;
  419.     m_ReadHookData.SetDefaultFunction(readFuncs);
  420.     m_WriteHookData.SetDefaultFunction(writeFunc);
  421.     m_SkipHookData.SetDefaultFunction(skipFuncs);
  422.     m_CopyHookData.SetDefaultFunction(copyFuncs);
  423. }
  425. void CMemberInfo::UpdateDelayedBuffer(CObjectIStream& in,
  426.                                       TObjectPtr classPtr) const
  427. {
  428.     _ASSERT(CanBeDelayed());
  429.     _ASSERT(GetDelayBuffer(classPtr).GetIndex() == GetIndex());
  431.     GetTypeInfo()->ReadData(in, GetItemPtr(classPtr));
  432. }
  434. void CMemberInfo::SetReadFunction(TMemberReadFunction func)
  435. {
  436.     SMemberReadFunctions funcs = m_ReadHookData.GetDefaultFunction();
  437.     funcs.m_Main = func;
  438.     m_ReadHookData.SetDefaultFunction(funcs);
  439. }
  441. void CMemberInfo::SetReadMissingFunction(TMemberReadFunction func)
  442. {
  443.     SMemberReadFunctions funcs = m_ReadHookData.GetDefaultFunction();
  444.     funcs.m_Missing = func;
  445.     m_ReadHookData.SetDefaultFunction(funcs);
  446. }
  448. void CMemberInfo::SetWriteFunction(TMemberWriteFunction func)
  449. {
  450.     m_WriteHookData.SetDefaultFunction(func);
  451. }
  453. void CMemberInfo::SetSkipFunction(TMemberSkipFunction func)
  454. {
  455.     SMemberSkipFunctions funcs = m_SkipHookData.GetDefaultFunction();
  456.     funcs.m_Main = func;
  457.     m_SkipHookData.SetDefaultFunction(funcs);
  458. }
  460. void CMemberInfo::SetSkipMissingFunction(TMemberSkipFunction func)
  461. {
  462.     SMemberSkipFunctions funcs = m_SkipHookData.GetDefaultFunction();
  463.     funcs.m_Missing = func;
  464.     m_SkipHookData.SetDefaultFunction(funcs);
  465. }
  467. void CMemberInfo::SetCopyFunction(TMemberCopyFunction func)
  468. {
  469.     SMemberCopyFunctions funcs = m_CopyHookData.GetDefaultFunction();
  470.     funcs.m_Main = func;
  471.     m_CopyHookData.SetDefaultFunction(funcs);
  472. }
  474. void CMemberInfo::SetCopyMissingFunction(TMemberCopyFunction func)
  475. {
  476.     SMemberCopyFunctions funcs = m_CopyHookData.GetDefaultFunction();
  477.     funcs.m_Missing = func;
  478.     m_CopyHookData.SetDefaultFunction(funcs);
  479. }
  481. void CMemberInfo::SetGlobalReadHook(CReadClassMemberHook* hook)
  482. {
  483.     CMutexGuard guard(GetTypeInfoMutex());
  484.     m_ReadHookData.SetGlobalHook(hook);
  485. }
  487. void CMemberInfo::SetLocalReadHook(CObjectIStream& stream,
  488.                                    CReadClassMemberHook* hook)
  489. {
  490.     CMutexGuard guard(GetTypeInfoMutex());
  491.     m_ReadHookData.SetLocalHook(stream.m_ClassMemberHookKey, hook);
  492. }
  494. void CMemberInfo::ResetGlobalReadHook(void)
  495. {
  496.     CMutexGuard guard(GetTypeInfoMutex());
  497.     m_ReadHookData.ResetGlobalHook();
  498. }
  500. void CMemberInfo::ResetLocalReadHook(CObjectIStream& stream)
  501. {
  502.     CMutexGuard guard(GetTypeInfoMutex());
  503.     m_ReadHookData.ResetLocalHook(stream.m_ClassMemberHookKey);
  504. }
  506. void CMemberInfo::SetPathReadHook(CObjectIStream* in, const string& path,
  507.                                   CReadClassMemberHook* hook)
  508. {
  509.     CMutexGuard guard(GetTypeInfoMutex());
  510.     m_ReadHookData.SetPathHook(in,path,hook);
  511. }
  513. void CMemberInfo::SetGlobalWriteHook(CWriteClassMemberHook* hook)
  514. {
  515.     CMutexGuard guard(GetTypeInfoMutex());
  516.     m_WriteHookData.SetGlobalHook(hook);
  517. }
  519. void CMemberInfo::SetLocalWriteHook(CObjectOStream& stream,
  520.                                     CWriteClassMemberHook* hook)
  521. {
  522.     CMutexGuard guard(GetTypeInfoMutex());
  523.     m_WriteHookData.SetLocalHook(stream.m_ClassMemberHookKey, hook);
  524. }
  526. void CMemberInfo::ResetGlobalWriteHook(void)
  527. {
  528.     CMutexGuard guard(GetTypeInfoMutex());
  529.     m_WriteHookData.ResetGlobalHook();
  530. }
  532. void CMemberInfo::ResetLocalWriteHook(CObjectOStream& stream)
  533. {
  534.     CMutexGuard guard(GetTypeInfoMutex());
  535.     m_WriteHookData.ResetLocalHook(stream.m_ClassMemberHookKey);
  536. }
  538. void CMemberInfo::SetPathWriteHook(CObjectOStream* out, const string& path,
  539.                                    CWriteClassMemberHook* hook)
  540. {
  541.     CMutexGuard guard(GetTypeInfoMutex());
  542.     m_WriteHookData.SetPathHook(out,path,hook);
  543. }
  545. void CMemberInfo::SetGlobalSkipHook(CSkipClassMemberHook* hook)
  546. {
  547.     CMutexGuard guard(GetTypeInfoMutex());
  548.     m_SkipHookData.SetGlobalHook(hook);
  549. }
  551. void CMemberInfo::SetLocalSkipHook(CObjectIStream& stream,
  552.                                    CSkipClassMemberHook* hook)
  553. {
  554.     CMutexGuard guard(GetTypeInfoMutex());
  555.     m_SkipHookData.SetLocalHook(stream.m_ClassMemberSkipHookKey, hook);
  556. }
  558. void CMemberInfo::ResetGlobalSkipHook(void)
  559. {
  560.     CMutexGuard guard(GetTypeInfoMutex());
  561.     m_SkipHookData.ResetGlobalHook();
  562. }
  564. void CMemberInfo::ResetLocalSkipHook(CObjectIStream& stream)
  565. {
  566.     CMutexGuard guard(GetTypeInfoMutex());
  567.     m_SkipHookData.ResetLocalHook(stream.m_ClassMemberSkipHookKey);
  568. }
  570. void CMemberInfo::SetPathSkipHook(CObjectIStream* in, const string& path,
  571.                                   CSkipClassMemberHook* hook)
  572. {
  573.     CMutexGuard guard(GetTypeInfoMutex());
  574.     m_SkipHookData.SetPathHook(in,path,hook);
  575. }
  577. void CMemberInfo::SetGlobalCopyHook(CCopyClassMemberHook* hook)
  578. {
  579.     CMutexGuard guard(GetTypeInfoMutex());
  580.     m_CopyHookData.SetGlobalHook(hook);
  581. }
  583. void CMemberInfo::SetLocalCopyHook(CObjectStreamCopier& stream,
  584.                                    CCopyClassMemberHook* hook)
  585. {
  586.     CMutexGuard guard(GetTypeInfoMutex());
  587.     m_CopyHookData.SetLocalHook(stream.m_ClassMemberHookKey, hook);
  588. }
  590. void CMemberInfo::ResetGlobalCopyHook(void)
  591. {
  592.     CMutexGuard guard(GetTypeInfoMutex());
  593.     m_CopyHookData.ResetGlobalHook();
  594. }
  596. void CMemberInfo::ResetLocalCopyHook(CObjectStreamCopier& stream)
  597. {
  598.     CMutexGuard guard(GetTypeInfoMutex());
  599.     m_CopyHookData.ResetLocalHook(stream.m_ClassMemberHookKey);
  600. }
  602. void CMemberInfo::SetPathCopyHook(CObjectStreamCopier* stream, const string& path,
  603.                                   CCopyClassMemberHook* hook)
  604. {
  605.     CMutexGuard guard(GetTypeInfoMutex());
  606.     m_CopyHookData.SetPathHook(stream ? &(stream->In()) : 0,path,hook);
  607. }
  609. TObjectPtr CMemberInfo::CreateClass(void) const
  610. {
  611.     return GetClassType()->Create();
  612. }
  614. TConstObjectPtr
  615. CMemberInfoFunctions::GetConstSimpleMember(const CMemberInfo* memberInfo,
  616.                                            TConstObjectPtr classPtr)
  617. {
  618.     _ASSERT(!memberInfo->CanBeDelayed());
  619.     return memberInfo->GetItemPtr(classPtr);
  620. }
  622. TConstObjectPtr
  623. CMemberInfoFunctions::GetConstDelayedMember(const CMemberInfo* memberInfo,
  624.                                             TConstObjectPtr classPtr)
  625. {
  626.     _ASSERT(memberInfo->CanBeDelayed());
  627.     const_cast<CDelayBuffer&>(memberInfo->GetDelayBuffer(classPtr)).Update();
  628.     return memberInfo->GetItemPtr(classPtr);
  629. }
  631. TObjectPtr CMemberInfoFunctions::GetSimpleMember(const CMemberInfo* memberInfo,
  632.                                                  TObjectPtr classPtr)
  633. {
  634.     _ASSERT(!memberInfo->CanBeDelayed());
  635.     _ASSERT(!memberInfo->HaveSetFlag());
  636.     return memberInfo->GetItemPtr(classPtr);
  637. }
  639. TObjectPtr CMemberInfoFunctions::GetWithSetFlagMember(const CMemberInfo* memberInfo,
  640.                                                       TObjectPtr classPtr)
  641. {
  642.     _ASSERT(!memberInfo->CanBeDelayed());
  643.     _ASSERT(memberInfo->HaveSetFlag());
  644.     return memberInfo->GetItemPtr(classPtr);
  645. }
  647. TObjectPtr CMemberInfoFunctions::GetDelayedMember(const CMemberInfo* memberInfo,
  648.                                                   TObjectPtr classPtr)
  649. {
  650.     _ASSERT(memberInfo->CanBeDelayed());
  651.     memberInfo->GetDelayBuffer(classPtr).Update();
  652.     memberInfo->UpdateSetFlagYes(classPtr);
  653.     return memberInfo->GetItemPtr(classPtr);
  654. }
  656. void CMemberInfoFunctions::ReadSimpleMember(CObjectIStream& in,
  657.                                             const CMemberInfo* memberInfo,
  658.                                             TObjectPtr classPtr)
  659. {
  660.     _ASSERT(!memberInfo->CanBeDelayed());
  661.     _ASSERT(!memberInfo->HaveSetFlag());
  662.     in.ReadObject(memberInfo->GetItemPtr(classPtr),
  663.                   memberInfo->GetTypeInfo());
  664. }
  666. void CMemberInfoFunctions::ReadWithSetFlagMember(CObjectIStream& in,
  667.                                                  const CMemberInfo* memberInfo,
  668.                                                  TObjectPtr classPtr)
  669. {
  670.     _ASSERT(!memberInfo->CanBeDelayed());
  671.     _ASSERT(memberInfo->HaveSetFlag());
  672.     memberInfo->UpdateSetFlagYes(classPtr);
  673.     try {
  674.         in.ReadObject(memberInfo->GetItemPtr(classPtr),
  675.                       memberInfo->GetTypeInfo());
  676.     }
  677.     catch (CSerialException& e) {
  678.         if (e.GetErrCode() == CSerialException::eMissingValue) {
  679.             if ( memberInfo->Optional() && memberInfo->HaveSetFlag() ) {
  680.                 in.SetFailFlags(CObjectIStream::fNoError,0);
  681.                 if ( memberInfo->UpdateSetFlagNo(classPtr) ) {
  682.                     memberInfo->GetTypeInfo()->SetDefault(
  683.                         memberInfo->GetItemPtr(classPtr));
  684.                 }
  685.             } else {
  686.                 NCBI_RETHROW(e, CSerialException, eFormatError,
  687.                     "error while reading " + memberInfo->GetId().GetName());
  688.             }
  689.         } else {
  690.             NCBI_RETHROW_SAME(e,
  691.                 "error while reading " + memberInfo->GetId().GetName());
  692.         }
  693.     }
  694. }
  696. void CMemberInfoFunctions::ReadLongMember(CObjectIStream& in,
  697.                                           const CMemberInfo* memberInfo,
  698.                                           TObjectPtr classPtr)
  699. {
  700.     if ( memberInfo->CanBeDelayed() ) {
  701.         CDelayBuffer& buffer = memberInfo->GetDelayBuffer(classPtr);
  702.         if ( !buffer ) {
  703.             memberInfo->UpdateSetFlagYes(classPtr);
  704.             in.StartDelayBuffer();
  705.             memberInfo->GetTypeInfo()->SkipData(in);
  706.             in.EndDelayBuffer(buffer, memberInfo, classPtr);
  707.             return;
  708.         }
  709.         buffer.Update();
  710.     }
  711.     
  712.     memberInfo->UpdateSetFlagYes(classPtr);
  713.     in.ReadObject(memberInfo->GetItemPtr(classPtr),
  714.                   memberInfo->GetTypeInfo());
  715. }
  717. void CMemberInfoFunctions::ReadMissingSimpleMember(CObjectIStream& in,
  718.                                                    const CMemberInfo* memberInfo,
  719.                                                    TObjectPtr classPtr)
  720. {
  721.     _ASSERT(!memberInfo->Optional());
  722.     in.ExpectedMember(memberInfo);
  724.     if (memberInfo->HaveSetFlag()) {
  725.         memberInfo->UpdateSetFlagNo(classPtr);
  726.     }
  727.     memberInfo->GetTypeInfo()->SetDefault(memberInfo->GetItemPtr(classPtr));
  728. #ifdef _DEBUG
  729.     if (in.GetVerifyData() == eSerialVerifyData_No) {
  730.         if (memberInfo->GetTypeInfo()->GetTypeFamily() == eTypeFamilyPrimitive) {
  731.             CObjectInfo objinfo(memberInfo->GetItemPtr(classPtr),
  732.                                 memberInfo->GetTypeInfo());
  733.             if (objinfo.GetPrimitiveValueType() == ePrimitiveValueString) {
  734.                 objinfo.SetPrimitiveValueString(CSerialObject::ms_UnassignedStr);
  735.             } else {
  736.                 size_t size = memberInfo->GetTypeInfo()->GetSize();
  737.                 if (size <= sizeof(long)) {
  738.                     char* tmp = static_cast<char*>(
  739.                         memberInfo->GetItemPtr(classPtr));
  740.                     for (; size != 0; --size, ++tmp) {
  741.                         *tmp = CSerialObject::ms_UnassignedByte;
  742.                     }
  743.                 }
  744.             }
  745.         }
  746.     }
  747. #endif
  748. }
  750. void
  751. CMemberInfoFunctions::ReadMissingOptionalMember(CObjectIStream& /*in*/,
  752.                                                 const CMemberInfo* memberInfo,
  753.                                                 TObjectPtr classPtr)
  754. {
  755.     _ASSERT(memberInfo->Optional());
  756.     memberInfo->GetTypeInfo()->SetDefault(memberInfo->GetItemPtr(classPtr));
  757. }
  759. void
  760. CMemberInfoFunctions::ReadMissingWithSetFlagMember(CObjectIStream& /*in*/,
  761.                                                    const CMemberInfo* memberInfo,
  762.                                                    TObjectPtr classPtr)
  763. {
  764.     _ASSERT(!memberInfo->CanBeDelayed());
  765.     _ASSERT(memberInfo->HaveSetFlag());
  766.     if ( memberInfo->UpdateSetFlagNo(classPtr) ) {
  767.         memberInfo->GetTypeInfo()->SetDefault(memberInfo->GetItemPtr(classPtr));
  768.     }
  769. }
  771. void CMemberInfoFunctions::WriteSimpleMember(CObjectOStream& out,
  772.                                              const CMemberInfo* memberInfo,
  773.                                              TConstObjectPtr classPtr)
  774. {
  775.     _ASSERT(!memberInfo->CanBeDelayed());
  776.     _ASSERT(!memberInfo->Optional());
  777.     out.WriteClassMember(memberInfo->GetId(),
  778.                          memberInfo->GetTypeInfo(),
  779.                          memberInfo->GetItemPtr(classPtr));
  780. }
  782. void CMemberInfoFunctions::WriteOptionalMember(CObjectOStream& out,
  783.                                                const CMemberInfo* memberInfo,
  784.                                                TConstObjectPtr classPtr)
  785. {
  786.     _ASSERT(!memberInfo->CanBeDelayed());
  787.     _ASSERT(memberInfo->Optional());
  788.     TTypeInfo memberType = memberInfo->GetTypeInfo();
  789.     TConstObjectPtr memberPtr = memberInfo->GetItemPtr(classPtr);
  790.     if ( memberType->IsDefault(memberPtr) )
  791.         return;
  793.     out.WriteClassMember(memberInfo->GetId(), memberType, memberPtr);
  794. }
  796. void CMemberInfoFunctions::WriteWithDefaultMember(CObjectOStream& out,
  797.                                                   const CMemberInfo* memberInfo,
  798.                                                   TConstObjectPtr classPtr)
  799. {
  800.     _ASSERT(!memberInfo->CanBeDelayed());
  801.     _ASSERT(memberInfo->GetDefault());
  802.     TTypeInfo memberType = memberInfo->GetTypeInfo();
  803.     TConstObjectPtr memberPtr = memberInfo->GetItemPtr(classPtr);
  804.     if ( memberType->Equals(memberPtr, memberInfo->GetDefault()) )
  805.         return;
  807.     out.WriteClassMember(memberInfo->GetId(), memberType, memberPtr);
  808. }
  810. void CMemberInfoFunctions::WriteWithSetFlagMember(CObjectOStream& out,
  811.                                                   const CMemberInfo* memberInfo,
  812.                                                   TConstObjectPtr classPtr)
  813. {
  814.     _ASSERT(!memberInfo->CanBeDelayed());
  815.     _ASSERT(memberInfo->HaveSetFlag());
  816.     if ( memberInfo->GetSetFlagNo(classPtr) ) {
  817.         if (memberInfo->Optional()) {
  818.             return;
  819.         }
  820.         ESerialVerifyData verify = out.GetVerifyData();
  821.         if (verify == eSerialVerifyData_Yes) {
  822.             out.ThrowError(CObjectOStream::fUnassigned,
  823.                 string("Unassigned member: ")+memberInfo->GetId().GetName());
  824.         } else if (verify == eSerialVerifyData_No) {
  825.             return;
  826.         }
  827.     }
  828. #ifdef _DEBUG
  829.     if (memberInfo->GetSetFlag(classPtr) == CMemberInfo::eSetMaybe &&
  830.         memberInfo->GetTypeInfo()->GetTypeFamily() == eTypeFamilyPrimitive) {
  831.         bool do_err_post = false;
  832.         CConstObjectInfo objinfo(memberInfo->GetItemPtr(classPtr),
  833.                                  memberInfo->GetTypeInfo());
  834.         if (objinfo.GetPrimitiveValueType() == ePrimitiveValueString) {
  835.             string tmp;
  836.             objinfo.GetPrimitiveValueString(tmp);
  837.             do_err_post = (tmp == CSerialObject::ms_UnassignedStr);
  838.         } else {
  839.             size_t size = memberInfo->GetTypeInfo()->GetSize();
  840.             const char* tmp = static_cast<const char*>(
  841.                 memberInfo->GetItemPtr(classPtr));
  842.             for (; size != 0 && *tmp == CSerialObject::ms_UnassignedByte; --size, ++tmp)
  843.                 ;
  844.             do_err_post = (size == 0);
  845.         }
  846.         if (do_err_post) {
  847.             ERR_POST(Error << "CObjectOStream: at "<< out.GetPosition()<<
  848.                      ": Member ""<< memberInfo->GetId().GetName()<<
  849.                      "" seems to be unassigned");
  850.         }
  851.     }
  852. #endif
  853.     out.WriteClassMember(memberInfo->GetId(),
  854.                          memberInfo->GetTypeInfo(),
  855.                          memberInfo->GetItemPtr(classPtr));
  856. }
  858. void CMemberInfoFunctions::WriteLongMember(CObjectOStream& out,
  859.                                            const CMemberInfo* memberInfo,
  860.                                            TConstObjectPtr classPtr)
  861. {
  862.     bool haveSetFlag = memberInfo->HaveSetFlag();
  863.     if ( haveSetFlag && memberInfo->GetSetFlagNo(classPtr) ) {
  864.         // not set -> skip this member
  865.         return;
  866.     }
  867.     
  868.     if ( memberInfo->CanBeDelayed() ) {
  869.         const CDelayBuffer& buffer = memberInfo->GetDelayBuffer(classPtr);
  870.         if ( buffer ) {
  871.             if ( out.WriteClassMember(memberInfo->GetId(), buffer) )
  872.                 return;
  874.             // cannot write delayed buffer -> proceed after update
  875.             const_cast<CDelayBuffer&>(buffer).Update();
  876.         }
  877.     }
  878.     
  879.     TTypeInfo memberType = memberInfo->GetTypeInfo();
  880.     TConstObjectPtr memberPtr = memberInfo->GetItemPtr(classPtr);
  881.     if ( !haveSetFlag && memberInfo->Optional() ) {
  882.         TConstObjectPtr defaultPtr = memberInfo->GetDefault();
  883.         if ( !defaultPtr ) {
  884.             if ( memberType->IsDefault(memberPtr) )
  885.                 return; // DEFAULT
  886.         }
  887.         else {
  888.             if ( memberType->Equals(memberPtr, defaultPtr) )
  889.                 return; // OPTIONAL
  890.         }
  891.     }
  892.     
  893.     out.WriteClassMember(memberInfo->GetId(), memberType, memberPtr);
  894. }
  896. void CMemberInfoFunctions::CopySimpleMember(CObjectStreamCopier& copier,
  897.                                             const CMemberInfo* memberInfo)
  898. {
  899.     copier.CopyObject(memberInfo->GetTypeInfo());
  900. }
  902. void CMemberInfoFunctions::CopyMissingSimpleMember(CObjectStreamCopier& copier,
  903.                                                    const CMemberInfo* memberInfo)
  904. {
  905.     _ASSERT(!memberInfo->Optional());
  906.     copier.ExpectedMember(memberInfo);
  907. }
  909. void CMemberInfoFunctions::CopyMissingOptionalMember(CObjectStreamCopier& /*copier*/,
  910.                                                      const CMemberInfo* _DEBUG_ARG(memberInfo))
  911. {
  912.     _ASSERT(memberInfo->Optional());
  913. }
  915. void CMemberInfoFunctions::SkipSimpleMember(CObjectIStream& in,
  916.                                             const CMemberInfo* memberInfo)
  917. {
  918.     in.SkipObject(memberInfo->GetTypeInfo());
  919. }
  921. void CMemberInfoFunctions::SkipMissingSimpleMember(CObjectIStream& in,
  922.                                                    const CMemberInfo* memberInfo)
  923. {
  924.     _ASSERT(!memberInfo->Optional());
  925.     in.ExpectedMember(memberInfo);
  926. }
  928. void CMemberInfoFunctions::SkipMissingOptionalMember(CObjectIStream& /*in*/,
  929.                                                      const CMemberInfo* _DEBUG_ARG(memberInfo))
  930. {
  931.     _ASSERT(memberInfo->Optional());
  932. }
  934. void CMemberInfoFunctions::ReadHookedMember(CObjectIStream& stream,
  935.                                             const CMemberInfo* memberInfo,
  936.                                             TObjectPtr classPtr)
  937. {
  938.     CReadClassMemberHook* hook =
  939.         memberInfo->m_ReadHookData.GetHook(stream.m_ClassMemberHookKey);
  940.     if ( !hook ) {
  941.         hook = memberInfo->m_ReadHookData.GetPathHook(stream);
  942.     }
  943.     if ( hook ) {
  944.         CObjectInfo object(classPtr, memberInfo->GetClassType());
  945.         TMemberIndex index = memberInfo->GetIndex();
  946.         CObjectInfo::CMemberIterator member(object, index);
  947.         _ASSERT(member.Valid());
  948.         if (memberInfo->HaveSetFlag()) {
  949.             memberInfo->UpdateSetFlagYes(classPtr);
  950.         }
  951.         hook->ReadClassMember(stream, member);
  952.     }
  953.     else
  954.         memberInfo->DefaultReadMember(stream, classPtr);
  955. }
  957. void CMemberInfoFunctions::ReadMissingHookedMember(CObjectIStream& stream,
  958.                                                    const CMemberInfo* memberInfo,
  959.                                                    TObjectPtr classPtr)
  960. {
  961.     CReadClassMemberHook* hook =
  962.         memberInfo->m_ReadHookData.GetHook(stream.m_ClassMemberHookKey);
  963.     if ( !hook ) {
  964.         hook = memberInfo->m_ReadHookData.GetPathHook(stream);
  965.     }
  966.     if ( hook ) {
  967.         memberInfo->GetTypeInfo()->
  968.             SetDefault(memberInfo->GetItemPtr(classPtr));
  969.         CObjectInfo object(classPtr, memberInfo->GetClassType());
  970.         TMemberIndex index = memberInfo->GetIndex();
  971.         CObjectInfo::CMemberIterator member(object, index);
  972.         _ASSERT(member.Valid());
  973.         hook->ReadMissingClassMember(stream, member);
  974.     }
  975.     else
  976.         memberInfo->DefaultReadMissingMember(stream, classPtr);
  977. }
  979. void CMemberInfoFunctions::WriteHookedMember(CObjectOStream& stream,
  980.                                              const CMemberInfo* memberInfo,
  981.                                              TConstObjectPtr classPtr)
  982. {
  983.     CWriteClassMemberHook* hook =
  984.         memberInfo->m_WriteHookData.GetHook(stream.m_ClassMemberHookKey);
  985.     if ( !hook ) {
  986.         hook = memberInfo->m_WriteHookData.GetPathHook(stream);
  987.     }
  988.     if ( hook ) {
  989.         CConstObjectInfo object(classPtr, memberInfo->GetClassType());
  990.         TMemberIndex index = memberInfo->GetIndex();
  991.         CConstObjectInfo::CMemberIterator member(object, index);
  992.         _ASSERT(member.Valid());
  993.         hook->WriteClassMember(stream, member);
  994.     }
  995.     else
  996.         memberInfo->DefaultWriteMember(stream, classPtr);
  997. }
  999. void CMemberInfoFunctions::SkipHookedMember(CObjectIStream& stream,
  1000.                                             const CMemberInfo* memberInfo)
  1001. {
  1002.     CSkipClassMemberHook* hook =
  1003.         memberInfo->m_SkipHookData.GetHook(stream.m_ClassMemberSkipHookKey);
  1004.     if ( !hook ) {
  1005.         hook = memberInfo->m_SkipHookData.GetPathHook(stream);
  1006.     }
  1007.     if ( hook ) {
  1008.         CObjectTypeInfo type(memberInfo->GetClassType());
  1009.         TMemberIndex index = memberInfo->GetIndex();
  1010.         CObjectTypeInfo::CMemberIterator member(type, index);
  1011.         _ASSERT(member.Valid());
  1012.         hook->SkipClassMember(stream, member);
  1013.     }
  1014.     else
  1015.         memberInfo->DefaultSkipMember(stream);
  1016. }
  1018. void CMemberInfoFunctions::SkipMissingHookedMember(CObjectIStream& stream,
  1019.                                                    const CMemberInfo* memberInfo)
  1020. {
  1021.     CSkipClassMemberHook* hook =
  1022.         memberInfo->m_SkipHookData.GetHook(stream.m_ClassMemberSkipHookKey);
  1023.     if ( !hook ) {
  1024.         hook = memberInfo->m_SkipHookData.GetPathHook(stream);
  1025.     }
  1026.     if ( hook ) {
  1027.         CObjectTypeInfo type(memberInfo->GetClassType());
  1028.         TMemberIndex index = memberInfo->GetIndex();
  1029.         CObjectTypeInfo::CMemberIterator member(type, index);
  1030.         _ASSERT(member.Valid());
  1031.         hook->SkipMissingClassMember(stream, member);
  1032.     }
  1033.     else
  1034.         memberInfo->DefaultSkipMissingMember(stream);
  1035. }
  1037. void CMemberInfoFunctions::CopyHookedMember(CObjectStreamCopier& stream,
  1038.                                             const CMemberInfo* memberInfo)
  1039. {
  1040.     CCopyClassMemberHook* hook =
  1041.         memberInfo->m_CopyHookData.GetHook(stream.m_ClassMemberHookKey);
  1042.     if ( !hook ) {
  1043.         hook = memberInfo->m_CopyHookData.GetPathHook(stream.In());
  1044.     }
  1045.     if ( hook ) {
  1046.         CObjectTypeInfo type(memberInfo->GetClassType());
  1047.         TMemberIndex index = memberInfo->GetIndex();
  1048.         CObjectTypeInfo::CMemberIterator member(type, index);
  1049.         _ASSERT(member.Valid());
  1050.         hook->CopyClassMember(stream, member);
  1051.     }
  1052.     else
  1053.         memberInfo->DefaultCopyMember(stream);
  1054. }
  1056. void CMemberInfoFunctions::CopyMissingHookedMember(CObjectStreamCopier& stream,
  1057.                                                    const CMemberInfo* memberInfo)
  1058. {
  1059.     CCopyClassMemberHook* hook =
  1060.         memberInfo->m_CopyHookData.GetHook(stream.m_ClassMemberHookKey);
  1061.     if ( !hook ) {
  1062.         hook = memberInfo->m_CopyHookData.GetPathHook(stream.In());
  1063.     }
  1064.     if ( hook ) {
  1065.         CObjectTypeInfo type(memberInfo->GetClassType());
  1066.         TMemberIndex index = memberInfo->GetIndex();
  1067.         CObjectTypeInfo::CMemberIterator member(type, index);
  1068.         _ASSERT(member.Valid());
  1069.         hook->CopyMissingClassMember(stream, member);
  1070.     }
  1071.     else
  1072.         memberInfo->DefaultCopyMissingMember(stream);
  1073. }
  1075. void CMemberInfoFunctions::ReadParentClass(CObjectIStream& in,
  1076.                                            const CMemberInfo* memberInfo,
  1077.                                            TObjectPtr objectPtr)
  1078. {
  1079.     _ASSERT(!memberInfo->CanBeDelayed());
  1080.     _ASSERT(!memberInfo->HaveSetFlag());
  1081.     in.ReadObject(memberInfo->GetItemPtr(objectPtr),
  1082.                   memberInfo->GetTypeInfo());
  1083. }
  1085. void CMemberInfoFunctions::ReadMissingParentClass(CObjectIStream& in,
  1086.                                                   const CMemberInfo* memberInfo,
  1087.                                                   TObjectPtr /*objectPtr*/)
  1088. {
  1089.     _ASSERT(!memberInfo->Optional());
  1090.     in.ExpectedMember(memberInfo);
  1091. }
  1093. void CMemberInfoFunctions::WriteParentClass(CObjectOStream& out,
  1094.                                             const CMemberInfo* memberInfo,
  1095.                                             TConstObjectPtr objectPtr)
  1096. {
  1097.     _ASSERT(!memberInfo->CanBeDelayed());
  1098.     _ASSERT(!memberInfo->Optional());
  1099.     out.WriteClassMember(memberInfo->GetId(),
  1100.                          memberInfo->GetTypeInfo(),
  1101.                          memberInfo->GetItemPtr(objectPtr));
  1102. }
  1104. void CMemberInfoFunctions::CopyParentClass(CObjectStreamCopier& copier,
  1105.                                            const CMemberInfo* memberInfo)
  1106. {
  1107.     copier.CopyObject(memberInfo->GetTypeInfo());
  1108. }
  1110. void CMemberInfoFunctions::CopyMissingParentClass(CObjectStreamCopier& copier,
  1111.                                                   const CMemberInfo* memberInfo)
  1112. {
  1113.     _ASSERT(!memberInfo->Optional());
  1114.     copier.ExpectedMember(memberInfo);
  1115. }
  1117. void CMemberInfoFunctions::SkipParentClass(CObjectIStream& in,
  1118.                                            const CMemberInfo* memberInfo)
  1119. {
  1120.     in.SkipObject(memberInfo->GetTypeInfo());
  1121. }
  1123. void CMemberInfoFunctions::SkipMissingParentClass(CObjectIStream& in,
  1124.                                                   const CMemberInfo* memberInfo)
  1125. {
  1126.     _ASSERT(!memberInfo->Optional());
  1127.     in.ExpectedMember(memberInfo);
  1128. }
  1131. END_NCBI_SCOPE
  1133. /*
  1134. * $Log: member.cpp,v $
  1135. * Revision 1000.3  2004/06/01 19:40:26  gouriano
  1136. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.38
  1137. *
  1138. * Revision 1.38  2004/05/17 21:03:02  gorelenk
  1139. * Added include of PCH ncbi_pch.hpp
  1140. *
  1141. * Revision 1.37  2004/01/22 20:45:41  gouriano
  1142. * Corrected reading of class members with possibly empty contents (bool,enum)
  1143. *
  1144. * Revision 1.36  2004/01/05 14:25:20  gouriano
  1145. * Added possibility to set serialization hooks by stack path
  1146. *
  1147. * Revision 1.35  2003/11/13 14:07:37  gouriano
  1148. * Elaborated data verification on read/write/get to enable skipping mandatory class data members
  1149. *
  1150. * Revision 1.34  2003/10/01 14:40:12  vasilche
  1151. * Fixed CanGet() for members wihout 'set' flag.
  1152. *
  1153. * Revision 1.33  2003/09/16 14:48:35  gouriano
  1154. * Enhanced AnyContent objects to support XML namespaces and attribute info items.
  1155. *
  1156. * Revision 1.32  2003/08/26 19:25:58  gouriano
  1157. * added possibility to discard a member of an STL container
  1158. * (from a read hook)
  1159. *
  1160. * Revision 1.31  2003/08/14 20:03:58  vasilche
  1161. * Avoid memory reallocation when reading over preallocated object.
  1162. * Simplified CContainerTypeInfo iterators interface.
  1163. *
  1164. * Revision 1.30  2003/07/29 18:47:47  vasilche
  1165. * Fixed thread safeness of object stream hooks.
  1166. *
  1167. * Revision 1.29  2003/06/24 20:57:36  gouriano
  1168. * corrected code generation and serialization of non-empty unnamed containers (XML)
  1169. *
  1170. * Revision 1.28  2003/05/06 16:23:42  gouriano
  1171. * write unassigned mandatory member when assignment verification is off
  1172. *
  1173. * Revision 1.27  2003/04/29 18:30:36  gouriano
  1174. * object data member initialization verification
  1175. *
  1176. * Revision 1.26  2003/04/10 20:13:39  vakatov
  1177. * Rollback the "uninitialized member" verification -- it still needs to
  1178. * be worked upon...
  1179. *
  1180. * Revision 1.24  2002/11/14 20:57:22  gouriano
  1181. * modified constructor to use CClassTypeInfoBase,
  1182. * added Attlist and Notag flags
  1183. *
  1184. * Revision 1.23  2002/09/25 19:37:36  gouriano
  1185. * added the possibility of having no tag prefix in XML I/O streams
  1186. *
  1187. * Revision 1.22  2002/09/09 18:14:02  grichenk
  1188. * Added CObjectHookGuard class.
  1189. * Added methods to be used by hooks for data
  1190. * reading and skipping.
  1191. *
  1192. * Revision 1.21  2001/07/25 19:14:24  grichenk
  1193. * Implemented functions for reading/writing parent classes
  1194. *
  1195. * Revision 1.20  2001/05/22 13:44:47  grichenk
  1196. * CMemberInfoFunctions::GetWithSetFlagMember() -- do not change SetFlag
  1197. *
  1198. * Revision 1.19  2001/05/17 15:07:06  lavr
  1199. * Typos corrected
  1200. *
  1201. * Revision 1.18  2000/10/20 15:51:38  vasilche
  1202. * Fixed data error processing.
  1203. * Added interface for constructing container objects directly into output stream.
  1204. * object.hpp, object.inl and object.cpp were split to
  1205. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  1206. *
  1207. * Revision 1.17  2000/10/17 18:45:33  vasilche
  1208. * Added possibility to turn off object cross reference detection in
  1209. * CObjectIStream and CObjectOStream.
  1210. *
  1211. * Revision 1.16  2000/10/13 20:22:55  vasilche
  1212. * Fixed warnings on 64 bit compilers.
  1213. * Fixed missing typename in templates.
  1214. *
  1215. * Revision 1.15  2000/10/03 17:22:42  vasilche
  1216. * Reduced header dependency.
  1217. * Reduced size of debug libraries on WorkShop by 3 times.
  1218. * Fixed tag allocation for parent classes.
  1219. * Fixed CObject allocation/deallocation in streams.
  1220. * Moved instantiation of several templates in separate source file.
  1221. *
  1222. * Revision 1.14  2000/09/29 16:18:22  vasilche
  1223. * Fixed binary format encoding/decoding on 64 bit compulers.
  1224. * Implemented CWeakMap<> for automatic cleaning map entries.
  1225. * Added cleaning local hooks via CWeakMap<>.
  1226. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  1227. * Added some user interface methods to CObjectIStream, CObjectOStream and
  1228. * CObjectStreamCopier.
  1229. *
  1230. * Revision 1.13  2000/09/26 18:09:48  vasilche
  1231. * Fixed some warnings.
  1232. *
  1233. * Revision 1.12  2000/09/26 17:38:21  vasilche
  1234. * Fixed incomplete choiceptr implementation.
  1235. * Removed temporary comments.
  1236. *
  1237. * Revision 1.11  2000/09/22 20:01:19  vasilche
  1238. * Forgot to uncomment some code.
  1239. *
  1240. * Revision 1.10  2000/09/19 14:10:25  vasilche
  1241. * Added files to MSVC project
  1242. * Updated shell scripts to use new datattool path on MSVC
  1243. * Fixed internal compiler error on MSVC
  1244. *
  1245. * Revision 1.9  2000/09/18 20:00:22  vasilche
  1246. * Separated CVariantInfo and CMemberInfo.
  1247. * Implemented copy hooks.
  1248. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  1249. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  1250. *
  1251. * Revision 1.8  2000/06/07 19:45:58  vasilche
  1252. * Some code cleaning.
  1253. * Macros renaming in more clear way.
  1254. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  1255. *
  1256. * Revision 1.7  2000/02/01 21:47:22  vasilche
  1257. * Added CGeneratedChoiceTypeInfo for generated choice classes.
  1258. * Added buffering to CObjectIStreamAsn.
  1259. * Removed CMemberInfo subclasses.
  1260. * Added support for DEFAULT/OPTIONAL members.
  1261. *
  1262. * Revision 1.6  1999/09/14 18:54:17  vasilche
  1263. * Fixed bugs detected by gcc & egcs.
  1264. * Removed unneeded includes.
  1265. *
  1266. * Revision 1.5  1999/09/01 17:38:12  vasilche
  1267. * Fixed vector<char> implementation.
  1268. * Added explicit naming of class info.
  1269. * Moved IMPLICIT attribute from member info to class info.
  1270. *
  1271. * Revision 1.4  1999/08/31 17:50:08  vasilche
  1272. * Implemented several macros for specific data types.
  1273. * Added implicit members.
  1274. * Added multimap and set.
  1275. *
  1276. * Revision 1.3  1999/08/13 15:53:50  vasilche
  1277. * C++ analog of asntool: datatool
  1278. *
  1279. * Revision 1.2  1999/07/01 17:55:28  vasilche
  1280. * Implemented ASN.1 binary write.
  1281. *
  1282. * Revision 1.1  1999/06/30 16:04:50  vasilche
  1283. * Added support for old ASN.1 structures.
  1284. *
  1285. * ===========================================================================
  1286. */