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

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

生物技术

开发平台：

C/C++

variant.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: variant.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:42:08  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: variant.cpp,v 1000.2 2004/06/01 19:42:08 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/variant.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/choiceptr.hpp>
  55. #include <serial/ptrinfo.hpp>
  56. #include <serial/serialimpl.hpp>
  58. BEGIN_NCBI_SCOPE
  60. class CVariantInfoFunctions
  61. {
  62. public:
  64.     static
  65.     TConstObjectPtr GetConstInlineVariant(const CVariantInfo* variantInfo,
  66.                                           TConstObjectPtr choicePtr);
  67.     static
  68.     TConstObjectPtr GetConstPointerVariant(const CVariantInfo* variantInfo,
  69.                                            TConstObjectPtr choicePtr);
  70.     static
  71.     TConstObjectPtr GetConstDelayedVariant(const CVariantInfo* variantInfo,
  72.                                            TConstObjectPtr choicePtr);
  73.     static
  74.     TConstObjectPtr GetConstSubclassVariant(const CVariantInfo* variantInfo,
  75.                                             TConstObjectPtr choicePtr);
  76.     static TObjectPtr GetInlineVariant(const CVariantInfo* variantInfo,
  77.                                        TObjectPtr choicePtr);
  78.     static TObjectPtr GetPointerVariant(const CVariantInfo* variantInfo,
  79.                                         TObjectPtr choicePtr);
  80.     static TObjectPtr GetDelayedVariant(const CVariantInfo* variantInfo,
  81.                                         TObjectPtr choicePtr);
  82.     static TObjectPtr GetSubclassVariant(const CVariantInfo* variantInfo,
  83.                                          TObjectPtr choicePtr);
  85.     static void ReadInlineVariant(CObjectIStream& in,
  86.                                   const CVariantInfo* variantInfo,
  87.                                   TObjectPtr choicePtr);
  88.     static void ReadPointerVariant(CObjectIStream& in,
  89.                                    const CVariantInfo* variantInfo,
  90.                                    TObjectPtr choicePtr);
  91.     static void ReadObjectPointerVariant(CObjectIStream& in,
  92.                                          const CVariantInfo* variantInfo,
  93.                                          TObjectPtr choicePtr);
  94.     static void ReadDelayedVariant(CObjectIStream& in,
  95.                                    const CVariantInfo* variantInfo,
  96.                                    TObjectPtr choicePtr);
  97.     static void ReadSubclassVariant(CObjectIStream& in,
  98.                                     const CVariantInfo* variantInfo,
  99.                                     TObjectPtr choicePtr);
  100.     static void ReadHookedVariant(CObjectIStream& in,
  101.                                   const CVariantInfo* variantInfo,
  102.                                   TObjectPtr choicePtr);
  103.     static void WriteInlineVariant(CObjectOStream& out,
  104.                                    const CVariantInfo* variantInfo,
  105.                                    TConstObjectPtr choicePtr);
  106.     static void WritePointerVariant(CObjectOStream& out,
  107.                                     const CVariantInfo* variantInfo,
  108.                                     TConstObjectPtr choicePtr);
  109.     static void WriteObjectPointerVariant(CObjectOStream& out,
  110.                                           const CVariantInfo* variantInfo,
  111.                                           TConstObjectPtr choicePtr);
  112.     static void WriteSubclassVariant(CObjectOStream& out,
  113.                                      const CVariantInfo* variantInfo,
  114.                                      TConstObjectPtr choicePtr);
  115.     static void WriteDelayedVariant(CObjectOStream& out,
  116.                                     const CVariantInfo* variantInfo,
  117.                                     TConstObjectPtr choicePtr);
  118.     static void WriteHookedVariant(CObjectOStream& out,
  119.                                    const CVariantInfo* variantInfo,
  120.                                    TConstObjectPtr choicePtr);
  121.     static void SkipNonObjectVariant(CObjectIStream& in,
  122.                                      const CVariantInfo* variantInfo);
  123.     static void SkipObjectPointerVariant(CObjectIStream& in,
  124.                                          const CVariantInfo* variantInfo);
  125.     static void SkipHookedVariant(CObjectIStream& in,
  126.                                   const CVariantInfo* variantInfo);
  127.     static void CopyNonObjectVariant(CObjectStreamCopier& copier,
  128.                                      const CVariantInfo* variantInfo);
  129.     static void CopyObjectPointerVariant(CObjectStreamCopier& copier,
  130.                                          const CVariantInfo* variantInfo);
  131.     static void CopyHookedVariant(CObjectStreamCopier& copier,
  132.                                   const CVariantInfo* variantInfo);
  133. };
  135. typedef CVariantInfoFunctions TFunc;
  137. CVariantInfo::CVariantInfo(const CChoiceTypeInfo* choiceType,
  138.                            const CMemberId& id, TPointerOffsetType offset,
  139.                            const CTypeRef& type)
  140.     : CParent(id, offset, type), m_ChoiceType(choiceType),
  141.       m_VariantType(eInlineVariant), m_DelayOffset(eNoOffset),
  142.       m_GetConstFunction(&TFunc::GetConstInlineVariant),
  143.       m_GetFunction(&TFunc::GetInlineVariant),
  144.       m_ReadHookData(&TFunc::ReadInlineVariant, &TFunc::ReadHookedVariant),
  145.       m_WriteHookData(&TFunc::WriteInlineVariant, &TFunc::WriteHookedVariant),
  146.       m_SkipHookData(&TFunc::SkipNonObjectVariant, &TFunc::SkipHookedVariant),
  147.       m_CopyHookData(&TFunc::CopyNonObjectVariant, &TFunc::CopyHookedVariant)
  148. {
  149. }
  151. CVariantInfo::CVariantInfo(const CChoiceTypeInfo* choiceType,
  152.                            const CMemberId& id, TPointerOffsetType offset,
  153.                            TTypeInfo type)
  154.     : CParent(id, offset, type), m_ChoiceType(choiceType),
  155.       m_VariantType(eInlineVariant), m_DelayOffset(eNoOffset),
  156.       m_GetConstFunction(&TFunc::GetConstInlineVariant),
  157.       m_GetFunction(&TFunc::GetInlineVariant),
  158.       m_ReadHookData(&TFunc::ReadInlineVariant, &TFunc::ReadHookedVariant),
  159.       m_WriteHookData(&TFunc::WriteInlineVariant, &TFunc::WriteHookedVariant),
  160.       m_SkipHookData(&TFunc::SkipNonObjectVariant, &TFunc::SkipHookedVariant),
  161.       m_CopyHookData(&TFunc::CopyNonObjectVariant, &TFunc::CopyHookedVariant)
  162. {
  163. }
  165. CVariantInfo::CVariantInfo(const CChoiceTypeInfo* choiceType,
  166.                            const char* id, TPointerOffsetType offset,
  167.                            const CTypeRef& type)
  168.     : CParent(id, offset, type), m_ChoiceType(choiceType),
  169.       m_VariantType(eInlineVariant), m_DelayOffset(eNoOffset),
  170.       m_GetConstFunction(&TFunc::GetConstInlineVariant),
  171.       m_GetFunction(&TFunc::GetInlineVariant),
  172.       m_ReadHookData(&TFunc::ReadInlineVariant, &TFunc::ReadHookedVariant),
  173.       m_WriteHookData(&TFunc::WriteInlineVariant, &TFunc::WriteHookedVariant),
  174.       m_SkipHookData(&TFunc::SkipNonObjectVariant, &TFunc::SkipHookedVariant),
  175.       m_CopyHookData(&TFunc::CopyNonObjectVariant, &TFunc::CopyHookedVariant)
  176. {
  177. }
  179. CVariantInfo::CVariantInfo(const CChoiceTypeInfo* choiceType,
  180.                            const char* id, TPointerOffsetType offset,
  181.                            TTypeInfo type)
  182.     : CParent(id, offset, type), m_ChoiceType(choiceType),
  183.       m_VariantType(eInlineVariant), m_DelayOffset(eNoOffset),
  184.       m_GetConstFunction(&TFunc::GetConstInlineVariant),
  185.       m_GetFunction(&TFunc::GetInlineVariant),
  186.       m_ReadHookData(&TFunc::ReadInlineVariant, &TFunc::ReadHookedVariant),
  187.       m_WriteHookData(&TFunc::WriteInlineVariant, &TFunc::WriteHookedVariant),
  188.       m_SkipHookData(&TFunc::SkipNonObjectVariant, &TFunc::SkipHookedVariant),
  189.       m_CopyHookData(&TFunc::CopyNonObjectVariant, &TFunc::CopyHookedVariant)
  190. {
  191. }
  193. CVariantInfo* CVariantInfo::SetPointer(void)
  194. {
  195.     if ( !IsInline() ) {
  196.         NCBI_THROW(CSerialException,eIllegalCall,
  197.                    "SetPointer() is not first call");
  198.     }
  199.     m_VariantType = eNonObjectPointerVariant;
  200.     UpdateFunctions();
  201.     return this;
  202. }
  204. CVariantInfo* CVariantInfo::SetObjectPointer(void)
  205. {
  206.     if ( !IsInline() ) {
  207.         NCBI_THROW(CSerialException,eIllegalCall,
  208.                    "SetObjectPointer() is not first call");
  209.     }
  210.     m_VariantType = eObjectPointerVariant;
  211.     UpdateFunctions();
  212.     return this;
  213. }
  215. CVariantInfo* CVariantInfo::SetSubClass(void)
  216. {
  217.     if ( !IsInline() ) {
  218.         NCBI_THROW(CSerialException,eIllegalCall,
  219.                    "SetSubClass() is not first call");
  220.     }
  221.     if ( CanBeDelayed() ) {
  222.         NCBI_THROW(CSerialException,eIllegalCall,
  223.                   "sub class cannot be delayed");
  224.     }
  225.     m_VariantType = eSubClassVariant;
  226.     UpdateFunctions();
  227.     return this;
  228. }
  230. CVariantInfo* CVariantInfo::SetDelayBuffer(CDelayBuffer* buffer)
  231. {
  232.     if ( IsSubClass() ) {
  233.         NCBI_THROW(CSerialException,eIllegalCall,
  234.                    "sub class cannot be delayed");
  235.     }
  236.     m_DelayOffset = TPointerOffsetType(buffer);
  237.     UpdateFunctions();
  238.     return this;
  239. }
  241. void CVariantInfo::UpdateFunctions(void)
  242. {
  243.     // determine function pointers
  244.     TVariantGetConst getConstFunc;
  245.     TVariantGet getFunc;
  246.     TVariantReadFunction readFunc;
  247.     TVariantWriteFunction writeFunc;
  248.     TVariantSkipFunction skipFunc;
  249.     TVariantCopyFunction copyFunc;
  251.     // read/write/get
  252.     if ( CanBeDelayed() ) {
  253.         _ASSERT(!IsSubClass());
  254.         getConstFunc = &TFunc::GetConstDelayedVariant;
  255.         getFunc = &TFunc::GetDelayedVariant;
  256.         readFunc = &TFunc::ReadDelayedVariant;
  257.         writeFunc = &TFunc::WriteDelayedVariant;
  258.     }
  259.     else if ( IsInline() ) {
  260.         getConstFunc = &TFunc::GetConstInlineVariant;
  261.         getFunc = &TFunc::GetInlineVariant;
  262.         readFunc = &TFunc::ReadInlineVariant;
  263.         writeFunc = &TFunc::WriteInlineVariant;
  264.     }
  265.     else if ( IsObjectPointer() ) {
  266.         getConstFunc = &TFunc::GetConstPointerVariant;
  267.         getFunc = &TFunc::GetPointerVariant;
  268.         readFunc = &TFunc::ReadObjectPointerVariant;
  269.         writeFunc = &TFunc::WriteObjectPointerVariant;
  270.     }
  271.     else if ( IsNonObjectPointer() ) {
  272.         getConstFunc = &TFunc::GetConstPointerVariant;
  273.         getFunc = &TFunc::GetPointerVariant;
  274.         readFunc = &TFunc::ReadPointerVariant;
  275.         writeFunc = &TFunc::WritePointerVariant;
  276.     }
  277.     else { // subclass
  278.         getConstFunc = &TFunc::GetConstSubclassVariant;
  279.         getFunc = &TFunc::GetSubclassVariant;
  280.         readFunc = &TFunc::ReadSubclassVariant;
  281.         writeFunc = &TFunc::WriteSubclassVariant;
  282.     }
  284.     // copy/skip
  285.     if ( IsObject() ) {
  286.         copyFunc = &TFunc::CopyObjectPointerVariant;
  287.         skipFunc = &TFunc::SkipObjectPointerVariant;
  288.     }
  289.     else {
  290.         copyFunc = &TFunc::CopyNonObjectVariant;
  291.         skipFunc = &TFunc::SkipNonObjectVariant;
  292.     }
  294.     // update function pointers
  295.     m_GetConstFunction = getConstFunc;
  296.     m_GetFunction = getFunc;
  297.     m_ReadHookData.SetDefaultFunction(readFunc);
  298.     m_WriteHookData.SetDefaultFunction(writeFunc);
  299.     m_SkipHookData.SetDefaultFunction(skipFunc);
  300.     m_CopyHookData.SetDefaultFunction(copyFunc);
  301. }
  303. void CVariantInfo::UpdateDelayedBuffer(CObjectIStream& in,
  304.                                        TObjectPtr choicePtr) const
  305. {
  306.     _ASSERT(CanBeDelayed());
  307.     _ASSERT(GetDelayBuffer(choicePtr).GetIndex() == GetIndex());
  309.     TObjectPtr variantPtr = GetItemPtr(choicePtr);
  310.     TTypeInfo variantType = GetTypeInfo();
  311.     if ( IsPointer() ) {
  312.         // create object itself
  313.         variantPtr = CTypeConverter<TObjectPtr>::Get(variantPtr) =
  314.             variantType->Create();
  315.         if ( IsObjectPointer() ) {
  316.             _TRACE("Should check for real pointer type (CRef...)");
  317.             CTypeConverter<CObject>::Get(variantPtr).AddReference();
  318.         }
  319.     }
  321.     variantType->ReadData(in, variantPtr);
  322. }
  324. void CVariantInfo::SetReadFunction(TVariantReadFunction func)
  325. {
  326.     m_ReadHookData.SetDefaultFunction(func);
  327. }
  329. void CVariantInfo::SetWriteFunction(TVariantWriteFunction func)
  330. {
  331.     m_WriteHookData.SetDefaultFunction(func);
  332. }
  334. void CVariantInfo::SetCopyFunction(TVariantCopyFunction func)
  335. {
  336.     m_CopyHookData.SetDefaultFunction(func);
  337. }
  339. void CVariantInfo::SetSkipFunction(TVariantSkipFunction func)
  340. {
  341.     m_SkipHookData.SetDefaultFunction(func);
  342. }
  344. TObjectPtr CVariantInfo::CreateChoice(void) const
  345. {
  346.     return GetChoiceType()->Create();
  347. }
  349. TConstObjectPtr
  350. CVariantInfoFunctions::GetConstInlineVariant(const CVariantInfo* variantInfo,
  351.                                              TConstObjectPtr choicePtr)
  352. {
  353.     _ASSERT(!variantInfo->CanBeDelayed());
  354.     _ASSERT(variantInfo->IsInline());
  355.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  356.             variantInfo->GetIndex());
  357.     return variantInfo->GetItemPtr(choicePtr);
  358. }
  360. TConstObjectPtr
  361. CVariantInfoFunctions::GetConstPointerVariant(const CVariantInfo* variantInfo,
  362.                                               TConstObjectPtr choicePtr)
  363. {
  364.     _ASSERT(!variantInfo->CanBeDelayed());
  365.     _ASSERT(variantInfo->IsPointer());
  366.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  367.             variantInfo->GetIndex());
  368.     TConstObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  369.     variantPtr = CTypeConverter<TConstObjectPtr>::Get(variantPtr);
  370.     _ASSERT(variantPtr);
  371.     return variantPtr;
  372. }
  374. TConstObjectPtr
  375. CVariantInfoFunctions::GetConstDelayedVariant(const CVariantInfo* variantInfo,
  376.                                               TConstObjectPtr choicePtr)
  377. {
  378.     _ASSERT(variantInfo->CanBeDelayed());
  379.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  380.             variantInfo->GetIndex());
  381.     const_cast<CDelayBuffer&>(variantInfo->GetDelayBuffer(choicePtr)).Update();
  382.     TConstObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  383.     if ( variantInfo->IsPointer() ) {
  384.         variantPtr = CTypeConverter<TConstObjectPtr>::Get(variantPtr);
  385.         _ASSERT(variantPtr);
  386.     }
  387.     return variantPtr;
  388. }
  390. TConstObjectPtr
  391. CVariantInfoFunctions::GetConstSubclassVariant(const CVariantInfo* variantInfo,
  392.                                                TConstObjectPtr choicePtr)
  393. {
  394.     _ASSERT(variantInfo->IsSubClass());
  395.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  396.             variantInfo->GetIndex());
  397.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  398.     const CChoicePointerTypeInfo* choicePtrType =
  399.         CTypeConverter<CChoicePointerTypeInfo>::SafeCast(choiceType);
  400.     TConstObjectPtr variantPtr =
  401.         choicePtrType->GetPointerTypeInfo()->GetObjectPointer(choicePtr);
  402.     _ASSERT(variantPtr);
  403.     return variantPtr;
  404. }
  406. TObjectPtr
  407. CVariantInfoFunctions::GetInlineVariant(const CVariantInfo* variantInfo,
  408.                                         TObjectPtr choicePtr)
  409. {
  410.     _ASSERT(!variantInfo->CanBeDelayed());
  411.     _ASSERT(variantInfo->IsInline());
  412.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  413.             variantInfo->GetIndex());
  414.     return variantInfo->GetItemPtr(choicePtr);
  415. }
  417. TObjectPtr
  418. CVariantInfoFunctions::GetPointerVariant(const CVariantInfo* variantInfo,
  419.                                          TObjectPtr choicePtr)
  420. {
  421.     _ASSERT(!variantInfo->CanBeDelayed());
  422.     _ASSERT(variantInfo->IsPointer());
  423.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  424.             variantInfo->GetIndex());
  425.     TObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  426.     variantPtr = CTypeConverter<TObjectPtr>::Get(variantPtr);
  427.     _ASSERT(variantPtr);
  428.     return variantPtr;
  429. }
  431. TObjectPtr
  432. CVariantInfoFunctions::GetDelayedVariant(const CVariantInfo* variantInfo,
  433.                                          TObjectPtr choicePtr)
  434. {
  435.     _ASSERT(variantInfo->CanBeDelayed());
  436.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  437.             variantInfo->GetIndex());
  438.     variantInfo->GetDelayBuffer(choicePtr).Update();
  439.     TObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  440.     if ( variantInfo->IsPointer() ) {
  441.         variantPtr = CTypeConverter<TObjectPtr>::Get(variantPtr);
  442.         _ASSERT(variantPtr);
  443.     }
  444.     return variantPtr;
  445. }
  447. TObjectPtr
  448. CVariantInfoFunctions::GetSubclassVariant(const CVariantInfo* variantInfo,
  449.                                           TObjectPtr choicePtr)
  450. {
  451.     _ASSERT(variantInfo->IsSubClass());
  452.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  453.             variantInfo->GetIndex());
  454.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  455.     const CChoicePointerTypeInfo* choicePtrType =
  456.         CTypeConverter<CChoicePointerTypeInfo>::SafeCast(choiceType);
  457.     TObjectPtr variantPtr =
  458.         choicePtrType->GetPointerTypeInfo()->GetObjectPointer(choicePtr);
  459.     _ASSERT(variantPtr);
  460.     return variantPtr;
  461. }
  463. void CVariantInfoFunctions::ReadInlineVariant(CObjectIStream& in,
  464.                                               const CVariantInfo* variantInfo,
  465.                                               TObjectPtr choicePtr)
  466. {
  467.     _ASSERT(!variantInfo->CanBeDelayed());
  468.     _ASSERT(variantInfo->IsInline());
  469.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  470.     TMemberIndex index = variantInfo->GetIndex();
  471.     choiceType->SetIndex(choicePtr, index);
  472.     in.ReadObject(variantInfo->GetItemPtr(choicePtr),
  473.                   variantInfo->GetTypeInfo());
  474. }
  476. void CVariantInfoFunctions::ReadPointerVariant(CObjectIStream& in,
  477.                                                const CVariantInfo* variantInfo,
  478.                                                TObjectPtr choicePtr)
  479. {
  480.     _ASSERT(!variantInfo->CanBeDelayed());
  481.     _ASSERT(variantInfo->IsNonObjectPointer());
  482.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  483.     TMemberIndex index = variantInfo->GetIndex();
  484.     choiceType->SetIndex(choicePtr, index);
  485.     TObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  486.     variantPtr = CTypeConverter<TObjectPtr>::Get(variantPtr);
  487.     _ASSERT(variantPtr != 0 );
  488.     in.ReadObject(variantPtr, variantInfo->GetTypeInfo());
  489. }
  491. void CVariantInfoFunctions::ReadObjectPointerVariant(CObjectIStream& in,
  492.                                                      const CVariantInfo* variantInfo,
  493.                                                      TObjectPtr choicePtr)
  494. {
  495.     _ASSERT(!variantInfo->CanBeDelayed());
  496.     _ASSERT(variantInfo->IsObjectPointer());
  497.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  498.     TMemberIndex index = variantInfo->GetIndex();
  499.     choiceType->SetIndex(choicePtr, index);
  500.     TObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  501.     variantPtr = CTypeConverter<TObjectPtr>::Get(variantPtr);
  502.     _ASSERT(variantPtr != 0 );
  503.     in.ReadExternalObject(variantPtr, variantInfo->GetTypeInfo());
  504. }
  506. void CVariantInfoFunctions::ReadSubclassVariant(CObjectIStream& in,
  507.                                                 const CVariantInfo* variantInfo,
  508.                                                 TObjectPtr choicePtr)
  509. {
  510.     _ASSERT(!variantInfo->CanBeDelayed());
  511.     _ASSERT(variantInfo->IsSubClass());
  512.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  513.     TMemberIndex index = variantInfo->GetIndex();
  514.     choiceType->SetIndex(choicePtr, index);
  515.     const CChoicePointerTypeInfo* choicePtrType =
  516.         CTypeConverter<CChoicePointerTypeInfo>::SafeCast(choiceType);
  517.     TObjectPtr variantPtr =
  518.         choicePtrType->GetPointerTypeInfo()->GetObjectPointer(choicePtr);
  519.     _ASSERT(variantPtr);
  520.     in.ReadExternalObject(variantPtr, variantInfo->GetTypeInfo());
  521. }
  523. void CVariantInfoFunctions::ReadDelayedVariant(CObjectIStream& in,
  524.                                                const CVariantInfo* variantInfo,
  525.                                                TObjectPtr choicePtr)
  526. {
  527.     _ASSERT(variantInfo->CanBeDelayed());
  528.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  529.     TMemberIndex index = variantInfo->GetIndex();
  530.     TTypeInfo variantType = variantInfo->GetTypeInfo();
  531.     if ( index != choiceType->GetIndex(choicePtr) ) {
  532.         // index is differnet from current -> first, reset choice
  533.         choiceType->ResetIndex(choicePtr);
  534.         CDelayBuffer& buffer = variantInfo->GetDelayBuffer(choicePtr);
  535.         if ( !buffer ) {
  536.             in.StartDelayBuffer();
  537.             if ( variantInfo->IsObjectPointer() )
  538.                 in.SkipExternalObject(variantType);
  539.             else
  540.                 in.SkipObject(variantType);
  541.             in.EndDelayBuffer(buffer, variantInfo, choicePtr);
  542.             // update index
  543.             choiceType->SetDelayIndex(choicePtr, index);
  544.             return;
  545.         }
  546.         buffer.Update();
  547.         _ASSERT(!variantInfo->GetDelayBuffer(choicePtr));
  548.     }
  549.     // select for reading
  550.     choiceType->SetIndex(choicePtr, index);
  552.     TObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  553.     if ( variantInfo->IsPointer() ) {
  554.         variantPtr = CTypeConverter<TObjectPtr>::Get(variantPtr);
  555.         _ASSERT(variantPtr != 0 );
  556.         if ( variantInfo->IsObjectPointer() ) {
  557.             in.ReadExternalObject(variantPtr, variantType);
  558.             return;
  559.         }
  560.     }
  561.     in.ReadObject(variantPtr, variantType);
  562. }
  564. void CVariantInfoFunctions::WriteInlineVariant(CObjectOStream& out,
  565.                                                const CVariantInfo* variantInfo,
  566.                                                TConstObjectPtr choicePtr)
  567. {
  568.     _ASSERT(!variantInfo->CanBeDelayed());
  569.     _ASSERT(variantInfo->IsInline());
  570.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  571.             variantInfo->GetIndex());
  572.     out.WriteObject(variantInfo->GetItemPtr(choicePtr),
  573.                     variantInfo->GetTypeInfo());
  574. }
  576. void CVariantInfoFunctions::WritePointerVariant(CObjectOStream& out,
  577.                                                 const CVariantInfo* variantInfo,
  578.                                                 TConstObjectPtr choicePtr)
  579. {
  580.     _ASSERT(!variantInfo->CanBeDelayed());
  581.     _ASSERT(variantInfo->IsNonObjectPointer());
  582.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  583.             variantInfo->GetIndex());
  584.     TConstObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  585.     variantPtr = CTypeConverter<TConstObjectPtr>::Get(variantPtr);
  586.     _ASSERT(variantPtr != 0 );
  587.     out.WriteObject(variantPtr, variantInfo->GetTypeInfo());
  588. }
  590. void CVariantInfoFunctions::WriteObjectPointerVariant(CObjectOStream& out,
  591.                                                       const CVariantInfo* variantInfo,
  592.                                                       TConstObjectPtr choicePtr)
  593. {
  594.     _ASSERT(!variantInfo->CanBeDelayed());
  595.     _ASSERT(variantInfo->IsObjectPointer());
  596.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  597.             variantInfo->GetIndex());
  598.     TConstObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  599.     variantPtr = CTypeConverter<TConstObjectPtr>::Get(variantPtr);
  600.     _ASSERT(variantPtr != 0 );
  601.     out.WriteExternalObject(variantPtr, variantInfo->GetTypeInfo());
  602. }
  604. void CVariantInfoFunctions::WriteSubclassVariant(CObjectOStream& out,
  605.                                                  const CVariantInfo* variantInfo,
  606.                                                  TConstObjectPtr choicePtr)
  607. {
  608.     _ASSERT(!variantInfo->CanBeDelayed());
  609.     _ASSERT(variantInfo->IsSubClass());
  610.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  611.             variantInfo->GetIndex());
  612.     const CChoiceTypeInfo* choiceType = variantInfo->GetChoiceType();
  613.     const CChoicePointerTypeInfo* choicePtrType =
  614.         CTypeConverter<CChoicePointerTypeInfo>::SafeCast(choiceType);
  615.     TConstObjectPtr variantPtr =
  616.         choicePtrType->GetPointerTypeInfo()->GetObjectPointer(choicePtr);
  617.     _ASSERT(variantPtr);
  618.     out.WriteExternalObject(variantPtr, variantInfo->GetTypeInfo());
  619. }
  621. void CVariantInfoFunctions::WriteDelayedVariant(CObjectOStream& out,
  622.                                                 const CVariantInfo* variantInfo,
  623.                                                 TConstObjectPtr choicePtr)
  624. {
  625.     _ASSERT(variantInfo->CanBeDelayed());
  626.     _ASSERT(variantInfo->GetChoiceType()->GetIndex(choicePtr) ==
  627.             variantInfo->GetIndex());
  628.     const CDelayBuffer& buffer = variantInfo->GetDelayBuffer(choicePtr);
  629.     if ( buffer.GetIndex() == variantInfo->GetIndex() ) {
  630.         if ( buffer.HaveFormat(out.GetDataFormat()) ) {
  631.             out.Write(buffer.GetSource());
  632.             return;
  633.         }
  634.         const_cast<CDelayBuffer&>(buffer).Update();
  635.         _ASSERT(!variantInfo->GetDelayBuffer(choicePtr));
  636.     }
  637.     TConstObjectPtr variantPtr = variantInfo->GetItemPtr(choicePtr);
  638.     if ( variantInfo->IsPointer() ) {
  639.         variantPtr = CTypeConverter<TConstObjectPtr>::Get(variantPtr);
  640.         _ASSERT(variantPtr != 0 );
  641.         if ( variantInfo->IsObjectPointer() ) {
  642.             out.WriteExternalObject(variantPtr, variantInfo->GetTypeInfo());
  643.             return;
  644.         }
  645.     }
  646.     out.WriteObject(variantPtr, variantInfo->GetTypeInfo());
  647. }
  649. void CVariantInfoFunctions::CopyNonObjectVariant(CObjectStreamCopier& copier,
  650.                                                  const CVariantInfo* variantInfo)
  651. {
  652.     _ASSERT(variantInfo->IsNotObject());
  653.     copier.CopyObject(variantInfo->GetTypeInfo());
  654. }
  656. void CVariantInfoFunctions::CopyObjectPointerVariant(CObjectStreamCopier& copier,
  657.                                                      const CVariantInfo* variantInfo)
  658. {
  659.     _ASSERT(variantInfo->IsObjectPointer());
  660.     copier.CopyExternalObject(variantInfo->GetTypeInfo());
  661. }
  663. void CVariantInfoFunctions::SkipNonObjectVariant(CObjectIStream& in,
  664.                                                  const CVariantInfo* variantInfo)
  665. {
  666.     _ASSERT(variantInfo->IsNotObject());
  667.     in.SkipObject(variantInfo->GetTypeInfo());
  668. }
  670. void CVariantInfoFunctions::SkipObjectPointerVariant(CObjectIStream& in,
  671.                                                      const CVariantInfo* variantInfo)
  672. {
  673.     _ASSERT(variantInfo->IsObjectPointer());
  674.     in.SkipExternalObject(variantInfo->GetTypeInfo());
  675. }
  677. void CVariantInfoFunctions::ReadHookedVariant(CObjectIStream& stream,
  678.                                               const CVariantInfo* variantInfo,
  679.                                               TObjectPtr choicePtr)
  680. {
  681.     CReadChoiceVariantHook* hook =
  682.         variantInfo->m_ReadHookData.GetHook(stream.m_ChoiceVariantHookKey);
  683.     if (!hook) {
  684.         hook = variantInfo->m_ReadHookData.GetPathHook(stream);
  685.     }
  686.     if ( hook ) {
  687.         CObjectInfo choice(choicePtr, variantInfo->GetChoiceType());
  688.         TMemberIndex index = variantInfo->GetIndex();
  689.         CObjectInfo::CChoiceVariant variant(choice, index);
  690.         _ASSERT(variant.Valid());
  691.         hook->ReadChoiceVariant(stream, variant);
  692.     }
  693.     else
  694.         variantInfo->DefaultReadVariant(stream, choicePtr);
  695. }
  697. void CVariantInfoFunctions::WriteHookedVariant(CObjectOStream& stream,
  698.                                                const CVariantInfo* variantInfo,
  699.                                                TConstObjectPtr choicePtr)
  700. {
  701.     CWriteChoiceVariantHook* hook =
  702.         variantInfo->m_WriteHookData.GetHook(stream.m_ChoiceVariantHookKey);
  703.     if (!hook) {
  704.         hook = variantInfo->m_WriteHookData.GetPathHook(stream);
  705.     }
  706.     if ( hook ) {
  707.         CConstObjectInfo choice(choicePtr, variantInfo->GetChoiceType());
  708.         TMemberIndex index = variantInfo->GetIndex();
  709.         CConstObjectInfo::CChoiceVariant variant(choice, index);
  710.         _ASSERT(variant.Valid());
  711.         hook->WriteChoiceVariant(stream, variant);
  712.     }
  713.     else
  714.         variantInfo->DefaultWriteVariant(stream, choicePtr);
  715. }
  717. void CVariantInfoFunctions::SkipHookedVariant(CObjectIStream& stream,
  718.                                               const CVariantInfo* variantInfo)
  719. {
  720.     CSkipChoiceVariantHook* hook =
  721.         variantInfo->m_SkipHookData.GetHook(stream.m_ChoiceVariantSkipHookKey);
  722.     if (!hook) {
  723.         hook = variantInfo->m_SkipHookData.GetPathHook(stream);
  724.     }
  725.     if ( hook ) {
  726.         CObjectTypeInfo type(variantInfo->GetChoiceType());
  727.         TMemberIndex index = variantInfo->GetIndex();
  728.         CObjectTypeInfo::CChoiceVariant variant(type, index);
  729.         _ASSERT(variant.Valid());
  730.         hook->SkipChoiceVariant(stream, variant);
  731.     }
  732.     else
  733.         variantInfo->DefaultSkipVariant(stream);
  734. }
  736. void CVariantInfoFunctions::CopyHookedVariant(CObjectStreamCopier& stream,
  737.                                               const CVariantInfo* variantInfo)
  738. {
  739.     CCopyChoiceVariantHook* hook =
  740.         variantInfo->m_CopyHookData.GetHook(stream.m_ChoiceVariantHookKey);
  741.     if (!hook) {
  742.         hook = variantInfo->m_CopyHookData.GetPathHook(stream.In());
  743.     }
  744.     if ( hook ) {
  745.         CObjectTypeInfo type(variantInfo->GetChoiceType());
  746.         TMemberIndex index = variantInfo->GetIndex();
  747.         CObjectTypeInfo::CChoiceVariant variant(type, index);
  748.         _ASSERT(variant.Valid());
  749.         hook->CopyChoiceVariant(stream, variant);
  750.     }
  751.     else
  752.         variantInfo->DefaultCopyVariant(stream);
  753. }
  755. void CVariantInfo::SetGlobalReadHook(CReadChoiceVariantHook* hook)
  756. {
  757.     CMutexGuard guard(GetTypeInfoMutex());
  758.     m_ReadHookData.SetGlobalHook(hook);
  759. }
  761. void CVariantInfo::SetLocalReadHook(CObjectIStream& stream,
  762.                                     CReadChoiceVariantHook* hook)
  763. {
  764.     CMutexGuard guard(GetTypeInfoMutex());
  765.     m_ReadHookData.SetLocalHook(stream.m_ChoiceVariantHookKey, hook);
  766. }
  768. void CVariantInfo::ResetGlobalReadHook(void)
  769. {
  770.     CMutexGuard guard(GetTypeInfoMutex());
  771.     m_ReadHookData.ResetGlobalHook();
  772. }
  774. void CVariantInfo::ResetLocalReadHook(CObjectIStream& stream)
  775. {
  776.     CMutexGuard guard(GetTypeInfoMutex());
  777.     m_ReadHookData.ResetLocalHook(stream.m_ChoiceVariantHookKey);
  778. }
  780. void CVariantInfo::SetPathReadHook(CObjectIStream* in, const string& path,
  781.                                    CReadChoiceVariantHook* hook)
  782. {
  783.     CMutexGuard guard(GetTypeInfoMutex());
  784.     m_ReadHookData.SetPathHook(in,path,hook);
  785. }
  787. void CVariantInfo::SetGlobalWriteHook(CWriteChoiceVariantHook* hook)
  788. {
  789.     CMutexGuard guard(GetTypeInfoMutex());
  790.     m_WriteHookData.SetGlobalHook(hook);
  791. }
  793. void CVariantInfo::SetLocalWriteHook(CObjectOStream& stream,
  794.                                      CWriteChoiceVariantHook* hook)
  795. {
  796.     CMutexGuard guard(GetTypeInfoMutex());
  797.     m_WriteHookData.SetLocalHook(stream.m_ChoiceVariantHookKey, hook);
  798. }
  800. void CVariantInfo::ResetGlobalWriteHook(void)
  801. {
  802.     CMutexGuard guard(GetTypeInfoMutex());
  803.     m_WriteHookData.ResetGlobalHook();
  804. }
  806. void CVariantInfo::ResetLocalWriteHook(CObjectOStream& stream)
  807. {
  808.     CMutexGuard guard(GetTypeInfoMutex());
  809.     m_WriteHookData.ResetLocalHook(stream.m_ChoiceVariantHookKey);
  810. }
  812. void CVariantInfo::SetPathWriteHook(CObjectOStream* out, const string& path,
  813.                                     CWriteChoiceVariantHook* hook)
  814. {
  815.     CMutexGuard guard(GetTypeInfoMutex());
  816.     m_WriteHookData.SetPathHook(out,path,hook);
  817. }
  819. void CVariantInfo::SetGlobalSkipHook(CSkipChoiceVariantHook* hook)
  820. {
  821.     CMutexGuard guard(GetTypeInfoMutex());
  822.     m_SkipHookData.SetGlobalHook(hook);
  823. }
  825. void CVariantInfo::SetLocalSkipHook(CObjectIStream& stream,
  826.                                     CSkipChoiceVariantHook* hook)
  827. {
  828.     CMutexGuard guard(GetTypeInfoMutex());
  829.     m_SkipHookData.SetLocalHook(stream.m_ChoiceVariantSkipHookKey, hook);
  830. }
  832. void CVariantInfo::ResetGlobalSkipHook(void)
  833. {
  834.     CMutexGuard guard(GetTypeInfoMutex());
  835.     m_SkipHookData.ResetGlobalHook();
  836. }
  838. void CVariantInfo::ResetLocalSkipHook(CObjectIStream& stream)
  839. {
  840.     CMutexGuard guard(GetTypeInfoMutex());
  841.     m_SkipHookData.ResetLocalHook(stream.m_ChoiceVariantSkipHookKey);
  842. }
  844. void CVariantInfo::SetPathSkipHook(CObjectIStream* in, const string& path,
  845.                                    CSkipChoiceVariantHook* hook)
  846. {
  847.     CMutexGuard guard(GetTypeInfoMutex());
  848.     m_SkipHookData.SetPathHook(in,path,hook);
  849. }
  851. void CVariantInfo::SetGlobalCopyHook(CCopyChoiceVariantHook* hook)
  852. {
  853.     CMutexGuard guard(GetTypeInfoMutex());
  854.     m_CopyHookData.SetGlobalHook(hook);
  855. }
  857. void CVariantInfo::SetLocalCopyHook(CObjectStreamCopier& stream,
  858.                                     CCopyChoiceVariantHook* hook)
  859. {
  860.     CMutexGuard guard(GetTypeInfoMutex());
  861.     m_CopyHookData.SetLocalHook(stream.m_ChoiceVariantHookKey, hook);
  862. }
  864. void CVariantInfo::ResetGlobalCopyHook(void)
  865. {
  866.     CMutexGuard guard(GetTypeInfoMutex());
  867.     m_CopyHookData.ResetGlobalHook();
  868. }
  870. void CVariantInfo::ResetLocalCopyHook(CObjectStreamCopier& stream)
  871. {
  872.     CMutexGuard guard(GetTypeInfoMutex());
  873.     m_CopyHookData.ResetLocalHook(stream.m_ChoiceVariantHookKey);
  874. }
  876. void CVariantInfo::SetPathCopyHook(CObjectStreamCopier* stream, const string& path,
  877.                                    CCopyChoiceVariantHook* hook)
  878. {
  879.     CMutexGuard guard(GetTypeInfoMutex());
  880.     m_CopyHookData.SetPathHook(stream ? &(stream->In()) : 0,path,hook);
  881. }
  883. END_NCBI_SCOPE
  885. /*
  886. * ===========================================================================
  887. * $Log: variant.cpp,v $
  888. * Revision 1000.2  2004/06/01 19:42:08  gouriano
  889. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.14
  890. *
  891. * Revision 1.14  2004/05/17 21:03:04  gorelenk
  892. * Added include of PCH ncbi_pch.hpp
  893. *
  894. * Revision 1.13  2004/01/05 14:25:23  gouriano
  895. * Added possibility to set serialization hooks by stack path
  896. *
  897. * Revision 1.12  2003/07/29 18:47:48  vasilche
  898. * Fixed thread safeness of object stream hooks.
  899. *
  900. * Revision 1.11  2003/03/10 18:54:26  gouriano
  901. * use new structured exceptions (based on CException)
  902. *
  903. * Revision 1.10  2002/09/09 18:14:02  grichenk
  904. * Added CObjectHookGuard class.
  905. * Added methods to be used by hooks for data
  906. * reading and skipping.
  907. *
  908. * Revision 1.9  2001/05/17 15:07:09  lavr
  909. * Typos corrected
  910. *
  911. * Revision 1.8  2000/10/20 15:51:44  vasilche
  912. * Fixed data error processing.
  913. * Added interface for constructing container objects directly into output stream.
  914. * object.hpp, object.inl and object.cpp were split to
  915. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  916. *
  917. * Revision 1.7  2000/10/17 18:45:36  vasilche
  918. * Added possibility to turn off object cross reference detection in
  919. * CObjectIStream and CObjectOStream.
  920. *
  921. * Revision 1.6  2000/10/13 20:22:57  vasilche
  922. * Fixed warnings on 64 bit compilers.
  923. * Fixed missing typename in templates.
  924. *
  925. * Revision 1.5  2000/10/03 17:22:45  vasilche
  926. * Reduced header dependency.
  927. * Reduced size of debug libraries on WorkShop by 3 times.
  928. * Fixed tag allocation for parent classes.
  929. * Fixed CObject allocation/deallocation in streams.
  930. * Moved instantiation of several templates in separate source file.
  931. *
  932. * Revision 1.4  2000/09/29 16:18:25  vasilche
  933. * Fixed binary format encoding/decoding on 64 bit compulers.
  934. * Implemented CWeakMap<> for automatic cleaning map entries.
  935. * Added cleaning local hooks via CWeakMap<>.
  936. * Renamed ReadTypeName -> ReadFileHeader, ENoTypeName -> ENoFileHeader.
  937. * Added some user interface methods to CObjectIStream, CObjectOStream and
  938. * CObjectStreamCopier.
  939. *
  940. * Revision 1.3  2000/09/26 19:24:58  vasilche
  941. * Added user interface for setting read/write/copy hooks.
  942. *
  943. * Revision 1.2  2000/09/26 17:38:23  vasilche
  944. * Fixed incomplete choiceptr implementation.
  945. * Removed temporary comments.
  946. *
  947. * Revision 1.1  2000/09/18 20:00:26  vasilche
  948. * Separated CVariantInfo and CMemberInfo.
  949. * Implemented copy hooks.
  950. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  951. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  952. *
  953. * ===========================================================================
  954. */