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

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

生物技术

开发平台：

C/C++

stdtypes.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: stdtypes.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 19:41:52  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.44
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: stdtypes.cpp,v 1000.3 2004/06/01 19:41:52 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. *   CTypeInfo classes for primitive leaf types.
  39. */
  41. #include <ncbi_pch.hpp>
  42. #include <serial/serialdef.hpp>
  43. #include <serial/stdtypesimpl.hpp>
  44. #include <serial/typeinfoimpl.hpp>
  45. #include <serial/objistr.hpp>
  46. #include <serial/objostr.hpp>
  47. #include <serial/objcopy.hpp>
  49. #include <limits.h>
  50. #if HAVE_WINDOWS_H
  51. // In MSVC limits.h doesn't define FLT_MIN & FLT_MAX
  52. # include <float.h>
  53. #endif
  54. #include <math.h>
  56. BEGIN_NCBI_SCOPE
  59. class CPrimitiveTypeFunctionsBase
  60. {
  61. public:
  62.     static bool IsNegative(Int4 value)
  63.         {
  64.             return value < 0;
  65.         }
  66.     static bool IsNegative(Uint4 /*value*/)
  67.         {
  68.             return false;
  69.         }
  70. #if SIZEOF_LONG == 4
  71.     // add variants with long to avoid ambiguity
  72.     static bool IsNegative(long value)
  73.         {
  74.             return value < 0;
  75.         }
  76.     static bool IsNegative(unsigned long /*value*/)
  77.         {
  78.             return false;
  79.         }
  80. #endif
  81.     static bool IsNegative(Int8 value)
  82.         {
  83.             return value < 0;
  84.         }
  85.     static bool IsNegative(Uint8 /*value*/)
  86.         {
  87.             return false;
  88.         }
  89. };
  91. template<typename T>
  92. class CPrimitiveTypeFunctions : public CPrimitiveTypeFunctionsBase
  93. {
  94. public:
  95.     typedef T TObjectType;
  97.     static TObjectType& Get(TObjectPtr object)
  98.         {
  99.             return CTypeConverter<TObjectType>::Get(object);
  100.         }
  101.     static const TObjectType& Get(TConstObjectPtr object)
  102.         {
  103.             return CTypeConverter<TObjectType>::Get(object);
  104.         }
  106.     static void SetIOFunctions(CPrimitiveTypeInfo* info)
  107.         {
  108.             info->SetIOFunctions(&Read, &Write, &Copy, &Skip);
  109.         }
  111.     static void SetMemFunctions(CPrimitiveTypeInfo* info)
  112.         {
  113.             info->SetMemFunctions(&Create,
  114.                                   &IsDefault, &SetDefault,
  115.                                   &Equals, &Assign);
  116.         }
  118.     static TObjectPtr Create(TTypeInfo )
  119.         {
  120.             return new TObjectType(0);
  121.         }
  122.     static bool IsDefault(TConstObjectPtr objectPtr)
  123.         {
  124.             return Get(objectPtr) == TObjectType(0);
  125.         }
  126.     static void SetDefault(TObjectPtr objectPtr)
  127.         {
  128.             Get(objectPtr) = TObjectType(0);
  129.         }
  131.     static bool Equals(TConstObjectPtr obj1, TConstObjectPtr obj2,
  132.                        ESerialRecursionMode)
  133.         {
  134.             return Get(obj1) == Get(obj2);
  135.         }
  136.     static void Assign(TObjectPtr dst, TConstObjectPtr src,
  137.                        ESerialRecursionMode)
  138.         {
  139.             Get(dst) = Get(src);
  140.         }
  142.     static void Read(CObjectIStream& in,
  143.                      TTypeInfo , TObjectPtr objectPtr)
  144.         {
  145.             in.ReadStd(Get(objectPtr));
  146.         }
  147.     static void Write(CObjectOStream& out,
  148.                       TTypeInfo , TConstObjectPtr objectPtr)
  149.         {
  150.             out.WriteStd(Get(objectPtr));
  151.         }
  152.     static void Skip(CObjectIStream& in, TTypeInfo )
  153.         {
  154.             TObjectType data;
  155.             in.ReadStd(data);
  156.         }
  157.     static void Copy(CObjectStreamCopier& copier, TTypeInfo )
  158.         {
  159.             TObjectType data;
  160.             copier.In().ReadStd(data);
  161.             copier.Out().WriteStd(data);
  162.         }
  163. };
  165. #define EPSILON_(n) 1e-##n
  166. #define EPSILON(n) EPSILON_(n)
  168. #ifndef DBL_EPSILON
  169. #  define DBL_EPSILON EPSILON(DBL_DIG)
  170. #endif
  172. EMPTY_TEMPLATE
  173. bool CPrimitiveTypeFunctions<double>::Equals(TConstObjectPtr obj1,
  174.                                              TConstObjectPtr obj2,
  175.                                              ESerialRecursionMode)
  176. {
  177.     const double& x = Get(obj1);
  178.     const double& y = Get(obj2);
  179.     return (x == y  ||  fabs(x - y) < fabs(x + y) * DBL_EPSILON);
  180. }
  182. #ifndef FLT_EPSILON
  183. #  define FLT_EPSILON EPSILON(FLT_DIG)
  184. #endif
  186. EMPTY_TEMPLATE
  187. bool CPrimitiveTypeFunctions<float>::Equals(TConstObjectPtr obj1,
  188.                                             TConstObjectPtr obj2,
  189.                                             ESerialRecursionMode)
  190. {
  191.     const float& x = Get(obj1);
  192.     const float& y = Get(obj2);
  193.     return (x == y  ||  fabs(x - y) < fabs(x + y) * FLT_EPSILON);
  194. }
  196. #if SIZEOF_LONG_DOUBLE != 0
  198. EMPTY_TEMPLATE
  199. bool CPrimitiveTypeFunctions<long double>::Equals(TConstObjectPtr obj1,
  200.                                                   TConstObjectPtr obj2,
  201.                                                   ESerialRecursionMode)
  202. {
  203.     const long double& x = Get(obj1);
  204.     const long double& y = Get(obj2);
  205.     // We use DBL_EPSILON because I/O is double-based anyway.
  206.     return (x == y  ||  fabs(x - y) < fabs(x + y) * DBL_EPSILON);
  207. }
  208. #endif
  210. void CVoidTypeFunctions::ThrowException(const char* operation,
  211.                                         TTypeInfo objectType)
  212. {
  213.     string message("cannot ");
  214.     message += operation;
  215.     message += " object of type: ";
  216.     message += objectType->GetName();
  217.     NCBI_THROW(CSerialException,eIllegalCall, message);
  218. }
  220. bool CVoidTypeFunctions::IsDefault(TConstObjectPtr )
  221. {
  222.     return true;
  223. }
  225. bool CVoidTypeFunctions::Equals(TConstObjectPtr , TConstObjectPtr,
  226.                                 ESerialRecursionMode )
  227. {
  228.     ThrowIllegalCall();
  229.     return false;
  230. }
  232. void CVoidTypeFunctions::SetDefault(TObjectPtr )
  233. {
  234. }
  236. void CVoidTypeFunctions::Assign(TObjectPtr , TConstObjectPtr, ESerialRecursionMode )
  237. {
  238.     ThrowIllegalCall();
  239. }
  241. void CVoidTypeFunctions::Read(CObjectIStream& in, TTypeInfo ,
  242.                               TObjectPtr )
  243. {
  244.     in.ThrowError(in.fIllegalCall,
  245.                   "CVoidTypeFunctions::Read cannot read");
  246. }
  248. void CVoidTypeFunctions::Write(CObjectOStream& out, TTypeInfo ,
  249.                                TConstObjectPtr )
  250. {
  251.     out.ThrowError(out.fIllegalCall,
  252.                    "CVoidTypeFunctions::Write cannot write");
  253. }
  255. void CVoidTypeFunctions::Copy(CObjectStreamCopier& copier, TTypeInfo )
  256. {
  257.     copier.ThrowError(CObjectIStream::fIllegalCall,
  258.                       "CVoidTypeFunctions::Copy cannot copy");
  259. }
  261. void CVoidTypeFunctions::Skip(CObjectIStream& in, TTypeInfo )
  262. {
  263.     in.ThrowError(in.fIllegalCall,
  264.                   "CVoidTypeFunctions::Skip cannot skip");
  265. }
  267. TObjectPtr CVoidTypeFunctions::Create(TTypeInfo objectType)
  268. {
  269.     ThrowException("CVoidTypeFunctions::Create cannot create", objectType);
  270.     return 0;
  271. }
  273. CVoidTypeInfo::CVoidTypeInfo(void)
  274.     : CParent(0, ePrimitiveValueSpecial)
  275. {
  276. }
  278. CPrimitiveTypeInfo::CPrimitiveTypeInfo(size_t size,
  279.                                        EPrimitiveValueType valueType,
  280.                                        bool isSigned)
  281.     : CParent(eTypeFamilyPrimitive, size),
  282.       m_ValueType(valueType), m_Signed(isSigned)
  283. {
  284.     typedef CVoidTypeFunctions TFunctions;
  285.     SetMemFunctions(&TFunctions::Create,
  286.                     &TFunctions::IsDefault, &TFunctions::SetDefault,
  287.                     &TFunctions::Equals, &TFunctions::Assign);
  288. }
  290. CPrimitiveTypeInfo::CPrimitiveTypeInfo(size_t size, const char* name,
  291.                                        EPrimitiveValueType valueType,
  292.                                        bool isSigned)
  293.     : CParent(eTypeFamilyPrimitive, size, name),
  294.       m_ValueType(valueType), m_Signed(isSigned)
  295. {
  296.     typedef CVoidTypeFunctions TFunctions;
  297.     SetMemFunctions(&TFunctions::Create,
  298.                     &TFunctions::IsDefault, &TFunctions::SetDefault,
  299.                     &TFunctions::Equals, &TFunctions::Assign);
  300. }
  302. CPrimitiveTypeInfo::CPrimitiveTypeInfo(size_t size, const string& name,
  303.                                        EPrimitiveValueType valueType,
  304.                                        bool isSigned)
  305.     : CParent(eTypeFamilyPrimitive, size, name),
  306.       m_ValueType(valueType), m_Signed(isSigned)
  307. {
  308.     typedef CVoidTypeFunctions TFunctions;
  309.     SetMemFunctions(&TFunctions::Create,
  310.                     &TFunctions::IsDefault, &TFunctions::SetDefault,
  311.                     &TFunctions::Equals, &TFunctions::Assign);
  312. }
  314. void CPrimitiveTypeInfo::SetMemFunctions(TTypeCreate create,
  315.                                          TIsDefaultFunction isDefault,
  316.                                          TSetDefaultFunction setDefault,
  317.                                          TEqualsFunction equals,
  318.                                          TAssignFunction assign)
  319. {
  320.     SetCreateFunction(create);
  321.     m_IsDefault = isDefault;
  322.     m_SetDefault = setDefault;
  323.     m_Equals = equals;
  324.     m_Assign = assign;
  325. }
  327. void CPrimitiveTypeInfo::SetIOFunctions(TTypeReadFunction read,
  328.                                         TTypeWriteFunction write,
  329.                                         TTypeCopyFunction copy,
  330.                                         TTypeSkipFunction skip)
  331. {
  332.     SetReadFunction(read);
  333.     SetWriteFunction(write);
  334.     SetCopyFunction(copy);
  335.     SetSkipFunction(skip);
  336. }
  338. bool CPrimitiveTypeInfo::GetValueBool(TConstObjectPtr /*objectPtr*/) const
  339. {
  340.     ThrowIncompatibleValue();
  341.     return false;
  342. }
  344. bool CPrimitiveTypeInfo::IsDefault(TConstObjectPtr objectPtr) const
  345. {
  346.     return m_IsDefault(objectPtr);
  347. }
  349. void CPrimitiveTypeInfo::SetDefault(TObjectPtr objectPtr) const
  350. {
  351.     m_SetDefault(objectPtr);
  352. }
  354. bool CPrimitiveTypeInfo::Equals(TConstObjectPtr obj1, TConstObjectPtr obj2,
  355.                                 ESerialRecursionMode how) const
  356. {
  357.     return m_Equals(obj1, obj2, how);
  358. }
  360. void CPrimitiveTypeInfo::Assign(TObjectPtr dst, TConstObjectPtr src,
  361.                                 ESerialRecursionMode how) const
  362. {
  363.     m_Assign(dst, src, how);
  364. }
  366. void CPrimitiveTypeInfo::SetValueBool(TObjectPtr /*objectPtr*/, bool /*value*/) const
  367. {
  368.     ThrowIncompatibleValue();
  369. }
  371. char CPrimitiveTypeInfo::GetValueChar(TConstObjectPtr /*objectPtr*/) const
  372. {
  373.     ThrowIncompatibleValue();
  374.     return 0;
  375. }
  377. void CPrimitiveTypeInfo::SetValueChar(TObjectPtr /*objectPtr*/, char /*value*/) const
  378. {
  379.     ThrowIncompatibleValue();
  380. }
  382. Int4 CPrimitiveTypeInfo::GetValueInt4(TConstObjectPtr /*objectPtr*/) const
  383. {
  384.     ThrowIncompatibleValue();
  385.     return 0;
  386. }
  388. void CPrimitiveTypeInfo::SetValueInt4(TObjectPtr /*objectPtr*/,
  389.                                       Int4 /*value*/) const
  390. {
  391.     ThrowIncompatibleValue();
  392. }
  394. Uint4 CPrimitiveTypeInfo::GetValueUint4(TConstObjectPtr /*objectPtr*/) const
  395. {
  396.     ThrowIncompatibleValue();
  397.     return 0;
  398. }
  400. void CPrimitiveTypeInfo::SetValueUint4(TObjectPtr /*objectPtr*/,
  401.                                        Uint4 /*value*/) const
  402. {
  403.     ThrowIncompatibleValue();
  404. }
  406. Int8 CPrimitiveTypeInfo::GetValueInt8(TConstObjectPtr /*objectPtr*/) const
  407. {
  408.     ThrowIncompatibleValue();
  409.     return 0;
  410. }
  412. void CPrimitiveTypeInfo::SetValueInt8(TObjectPtr /*objectPtr*/,
  413.                                       Int8 /*value*/) const
  414. {
  415.     ThrowIncompatibleValue();
  416. }
  418. Uint8 CPrimitiveTypeInfo::GetValueUint8(TConstObjectPtr /*objectPtr*/) const
  419. {
  420.     ThrowIncompatibleValue();
  421.     return 0;
  422. }
  424. void CPrimitiveTypeInfo::SetValueUint8(TObjectPtr /*objectPtr*/,
  425.                                        Uint8 /*value*/) const
  426. {
  427.     ThrowIncompatibleValue();
  428. }
  430. double CPrimitiveTypeInfo::GetValueDouble(TConstObjectPtr /*objectPtr*/) const
  431. {
  432.     ThrowIncompatibleValue();
  433.     return 0;
  434. }
  436. void CPrimitiveTypeInfo::SetValueDouble(TObjectPtr /*objectPtr*/,
  437.                                         double /*value*/) const
  438. {
  439.     ThrowIncompatibleValue();
  440. }
  442. #if SIZEOF_LONG_DOUBLE != 0
  443. long double CPrimitiveTypeInfo::GetValueLDouble(TConstObjectPtr objectPtr) const
  444. {
  445.     return GetValueDouble(objectPtr);
  446. }
  448. void CPrimitiveTypeInfo::SetValueLDouble(TObjectPtr objectPtr,
  449.                                          long double value) const
  450. {
  451.     SetValueDouble(objectPtr, value);
  452. }
  453. #endif
  455. void CPrimitiveTypeInfo::GetValueString(TConstObjectPtr /*objectPtr*/,
  456.                                         string& /*value*/) const
  457. {
  458.     ThrowIncompatibleValue();
  459. }
  461. void CPrimitiveTypeInfo::SetValueString(TObjectPtr /*objectPtr*/,
  462.                                         const string& /*value*/) const
  463. {
  464.     ThrowIncompatibleValue();
  465. }
  467. void CPrimitiveTypeInfo::GetValueOctetString(TConstObjectPtr /*objectPtr*/,
  468.                                              vector<char>& /*value*/) const
  469. {
  470.     ThrowIncompatibleValue();
  471. }
  473. void CPrimitiveTypeInfo::SetValueOctetString(TObjectPtr /*objectPtr*/,
  474.                                              const vector<char>& /*value*/) const
  475. {
  476.     ThrowIncompatibleValue();
  477. }
  480. CPrimitiveTypeInfoBool::CPrimitiveTypeInfoBool(void)
  481.     : CParent(sizeof(TObjectType), ePrimitiveValueBool)
  482. {
  483.     CPrimitiveTypeFunctions<TObjectType>::SetMemFunctions(this);
  484.     CPrimitiveTypeFunctions<TObjectType>::SetIOFunctions(this);
  485. }
  487. bool CPrimitiveTypeInfoBool::GetValueBool(TConstObjectPtr object) const
  488. {
  489.     return CPrimitiveTypeFunctions<TObjectType>::Get(object);
  490. }
  492. void CPrimitiveTypeInfoBool::SetValueBool(TObjectPtr object, bool value) const
  493. {
  494.     CPrimitiveTypeFunctions<TObjectType>::Get(object) = value;
  495. }
  497. TTypeInfo CStdTypeInfo<bool>::GetTypeInfo(void)
  498. {
  499.     static TTypeInfo info = CreateTypeInfo();
  500.     return info;
  501. }
  503. CTypeInfo* CStdTypeInfo<bool>::CreateTypeInfo(void)
  504. {
  505.     return new CPrimitiveTypeInfoBool();
  506. }
  508. class CNullBoolFunctions : public CPrimitiveTypeFunctions<bool>
  509. {
  510. public:
  511.     static TObjectPtr Create(TTypeInfo type)
  512.         {
  513.             NCBI_THROW(CSerialException,eIllegalCall, "Cannot create NULL object");
  514.             return 0;
  515.         }
  516.     static bool IsDefault(TConstObjectPtr)
  517.         {
  518.             return false;
  519.         }
  520.     static void SetDefault(TObjectPtr)
  521.         {
  522.         }
  524.     static bool Equals(TConstObjectPtr, TConstObjectPtr,
  525.                        ESerialRecursionMode)
  526.         {
  527.             return true;
  528.         }
  529.     static void Assign(TObjectPtr, TConstObjectPtr,
  530.                        ESerialRecursionMode)
  531.         {
  532.         }
  534.     static void Read(CObjectIStream& in, TTypeInfo ,
  535.                      TObjectPtr object)
  536.         {
  537.             in.ReadNull();
  538.         }
  539.     static void Write(CObjectOStream& out, TTypeInfo ,
  540.                       TConstObjectPtr /*object*/)
  541.         {
  542.             out.WriteNull();
  543.         }
  544.     static void Copy(CObjectStreamCopier& copier, TTypeInfo )
  545.         {
  546.             copier.In().ReadNull();
  547.             copier.Out().WriteNull();
  548.         }
  549.     static void Skip(CObjectIStream& in, TTypeInfo )
  550.         {
  551.             in.SkipNull();
  552.         }
  553. };
  555. TTypeInfo CStdTypeInfo<bool>::GetTypeInfoNullBool(void)
  556. {
  557.     static TTypeInfo info = CreateTypeInfoNullBool();
  558.     return info;
  559. }
  561. CTypeInfo* CStdTypeInfo<bool>::CreateTypeInfoNullBool(void)
  562. {
  563.     CPrimitiveTypeInfo* info = new CPrimitiveTypeInfoBool;
  564.     typedef CNullBoolFunctions TFunctions;
  565.     info->SetMemFunctions(&TFunctions::Create, &TFunctions::IsDefault,
  566.                           &TFunctions::SetDefault,&TFunctions::Equals,
  567.                           &TFunctions::Assign);
  568.     info->SetIOFunctions(&TFunctions::Read, &TFunctions::Write,
  569.                          &TFunctions::Copy, &TFunctions::Skip);
  570.     return info;
  571. }
  573. CPrimitiveTypeInfoChar::CPrimitiveTypeInfoChar(void)
  574.     : CParent(sizeof(TObjectType), ePrimitiveValueChar)
  575. {
  576.     CPrimitiveTypeFunctions<TObjectType>::SetMemFunctions(this);
  577.     CPrimitiveTypeFunctions<TObjectType>::SetIOFunctions(this);
  578. }
  580. char CPrimitiveTypeInfoChar::GetValueChar(TConstObjectPtr object) const
  581. {
  582.     return CPrimitiveTypeFunctions<TObjectType>::Get(object);
  583. }
  585. void CPrimitiveTypeInfoChar::SetValueChar(TObjectPtr object, char value) const
  586. {
  587.     CPrimitiveTypeFunctions<TObjectType>::Get(object) = value;
  588. }
  590. void CPrimitiveTypeInfoChar::GetValueString(TConstObjectPtr object,
  591.                                             string& value) const
  592. {
  593.     value.assign(1, CPrimitiveTypeFunctions<TObjectType>::Get(object));
  594. }
  596. void CPrimitiveTypeInfoChar::SetValueString(TObjectPtr object,
  597.                                             const string& value) const
  598. {
  599.     if ( value.size() != 1 )
  600.         ThrowIncompatibleValue();
  601.     CPrimitiveTypeFunctions<TObjectType>::Get(object) = value[0];
  602. }
  604. TTypeInfo CStdTypeInfo<char>::GetTypeInfo(void)
  605. {
  606.     static TTypeInfo info = CreateTypeInfo();
  607.     return info;
  608. }
  610. CTypeInfo* CStdTypeInfo<char>::CreateTypeInfo(void)
  611. {
  612.     return new CPrimitiveTypeInfoChar();
  613. }
  615. template<typename T>
  616. class CPrimitiveTypeInfoIntFunctions : public CPrimitiveTypeFunctions<T>
  617. {
  618.     typedef CPrimitiveTypeFunctions<T> CParent;
  619. public:
  620.     typedef T TObjectType;
  621.     
  622.     static CPrimitiveTypeInfoInt* CreateTypeInfo(void)
  623.         {
  624.             CPrimitiveTypeInfoInt* info =
  625.                 new CPrimitiveTypeInfoInt(sizeof(TObjectType), IsSigned());
  627.             info->SetMemFunctions(&CParent::Create,
  628.                                   &IsDefault, &SetDefault, &Equals, &Assign);
  630.             info->SetIOFunctions(&CParent::Read, &CParent::Write,
  631.                                  &CParent::Copy, &CParent::Skip);
  633.             SetInt4Functions(info);
  634.             SetInt8Functions(info);
  635.             return info;
  636.         }
  638.     static void SetInt4Functions(CPrimitiveTypeInfoInt* info)
  639.         {
  640.             info->SetInt4Functions(&GetValueInt4, &SetValueInt4,
  641.                                   &GetValueUint4, &SetValueUint4);
  642.         }
  644.     static void SetInt8Functions(CPrimitiveTypeInfoInt* info)
  645.         {
  646.             info->SetInt8Functions(&GetValueInt8, &SetValueInt8,
  647.                                   &GetValueUint8, &SetValueUint8);
  648.         }
  650.     static bool IsDefault(TConstObjectPtr objectPtr)
  651.         {
  652.             return CParent::Get(objectPtr) == 0;
  653.         }
  654.     static void SetDefault(TObjectPtr objectPtr)
  655.         {
  656.             CParent::Get(objectPtr) = 0;
  657.         }
  658.     static bool Equals(TConstObjectPtr obj1, TConstObjectPtr obj2,
  659.                        ESerialRecursionMode)
  660.         {
  661.             return CParent::Get(obj1) == CParent::Get(obj2);
  662.         }
  663.     static void Assign(TObjectPtr dst, TConstObjectPtr src,
  664.                        ESerialRecursionMode)
  665.         {
  666.             CParent::Get(dst) = CParent::Get(src);
  667.         }
  669.     static bool IsSigned(void)
  670.         {
  671.             return TObjectType(-1) < 0;
  672.         }
  673.     static bool IsUnsigned(void)
  674.         {
  675.             return TObjectType(-1) > 0;
  676.         }
  678.     static Int4 GetValueInt4(TConstObjectPtr objectPtr)
  679.         {
  680.             TObjectType value = CParent::Get(objectPtr);
  681.             Int4 result = Int4(value);
  682.             if ( IsUnsigned() ) {
  683.                 // unsigned -> signed
  684.                 if ( sizeof(value) == sizeof(result) ) {
  685.                     // same size - check for sign change only
  686.                     if ( CParent::IsNegative(result) )
  687.                         ThrowIntegerOverflow();
  688.                 }
  689.             }
  690.             if ( sizeof(value) > sizeof(result) ) {
  691.                 if ( value != TObjectType(result) )
  692.                     ThrowIntegerOverflow();
  693.             }
  694.             return result;
  695.         }
  696.     static Uint4 GetValueUint4(TConstObjectPtr objectPtr)
  697.         {
  698.             TObjectType value = CParent::Get(objectPtr);
  699.             Uint4 result = Uint4(value);
  700.             if ( IsSigned() ) {
  701.                 // signed -> unsigned
  702.                 // check for negative value
  703.                 if ( IsNegative(value) )
  704.                     ThrowIntegerOverflow();
  705.             }
  706.             if ( sizeof(value) > sizeof(result) ) {
  707.                 if ( value != TObjectType(result) )
  708.                     ThrowIntegerOverflow();
  709.             }
  710.             return result;
  711.         }
  712.     static void SetValueInt4(TObjectPtr objectPtr, Int4 value)
  713.         {
  714.             TObjectType result = TObjectType(value);
  715.             if ( IsUnsigned() ) {
  716.                 // signed -> unsigned
  717.                 // check for negative value
  718.                 if ( CParent::IsNegative(value) )
  719.                     ThrowIntegerOverflow();
  720.             }
  721.             if ( sizeof(value) > sizeof(result) ) {
  722.                 if ( value != Int4(result) )
  723.                     ThrowIntegerOverflow();
  724.             }
  725.             CParent::Get(objectPtr) = result;
  726.         }
  727.     static void SetValueUint4(TObjectPtr objectPtr, Uint4 value)
  728.         {
  729.             TObjectType result = TObjectType(value);
  730.             if ( IsSigned() ) {
  731.                 // unsigned -> signed
  732.                 if ( sizeof(value) == sizeof(result) ) {
  733.                     // same size - check for sign change only
  734.                     if ( IsNegative(result) )
  735.                         ThrowIntegerOverflow();
  736.                 }
  737.             }
  738.             if ( sizeof(value) > sizeof(result) ) {
  739.                 if ( value != Uint4(result) )
  740.                     ThrowIntegerOverflow();
  741.             }
  742.             CParent::Get(objectPtr) = result;
  743.         }
  744.     static Int8 GetValueInt8(TConstObjectPtr objectPtr)
  745.         {
  746.             TObjectType value = CParent::Get(objectPtr);
  747.             Int8 result = Int8(value);
  748.             if ( IsUnsigned() ) {
  749.                 // unsigned -> signed
  750.                 if ( sizeof(value) == sizeof(result) ) {
  751.                     // same size - check for sign change only
  752.                     if ( CParent::IsNegative(result) )
  753.                         ThrowIntegerOverflow();
  754.                 }
  755.             }
  756.             if ( sizeof(value) > sizeof(result) ) {
  757.                 if ( value != TObjectType(result) )
  758.                     ThrowIntegerOverflow();
  759.             }
  760.             return result;
  761.         }
  762.     static Uint8 GetValueUint8(TConstObjectPtr objectPtr)
  763.         {
  764.             TObjectType value = CParent::Get(objectPtr);
  765.             Uint8 result = Uint8(value);
  766.             if ( IsSigned() ) {
  767.                 // signed -> unsigned
  768.                 // check for negative value
  769.                 if ( IsNegative(value) )
  770.                     ThrowIntegerOverflow();
  771.             }
  772.             if ( sizeof(value) > sizeof(result) ) {
  773.                 if ( value != TObjectType(result) )
  774.                     ThrowIntegerOverflow();
  775.             }
  776.             return result;
  777.         }
  778.     static void SetValueInt8(TObjectPtr objectPtr, Int8 value)
  779.         {
  780.             TObjectType result = TObjectType(value);
  781.             if ( IsUnsigned() ) {
  782.                 // signed -> unsigned
  783.                 // check for negative value
  784.                 if ( CParent::IsNegative(value) )
  785.                     ThrowIntegerOverflow();
  786.             }
  787.             if ( sizeof(value) > sizeof(result) ) {
  788.                 if ( value != Int8(result) )
  789.                     ThrowIntegerOverflow();
  790.             }
  791.             CParent::Get(objectPtr) = result;
  792.         }
  793.     static void SetValueUint8(TObjectPtr objectPtr, Uint8 value)
  794.         {
  795.             TObjectType result = TObjectType(value);
  796.             if ( IsSigned() ) {
  797.                 // unsigned -> signed
  798.                 if ( sizeof(value) == sizeof(result) ) {
  799.                     // same size - check for sign change only
  800.                     if ( IsNegative(result) )
  801.                         ThrowIntegerOverflow();
  802.                 }
  803.             }
  804.             if ( sizeof(value) > sizeof(result) ) {
  805.                 if ( value != Uint8(result) )
  806.                     ThrowIntegerOverflow();
  807.             }
  808.             CParent::Get(objectPtr) = result;
  809.         }
  810. };
  812. CPrimitiveTypeInfoInt::CPrimitiveTypeInfoInt(size_t size, bool isSigned)
  813.     : CParent(size, ePrimitiveValueInteger, isSigned)
  814. {
  815. }
  817. void CPrimitiveTypeInfoInt::SetInt4Functions(TGetInt4Function getInt4,
  818.                                              TSetInt4Function setInt4,
  819.                                              TGetUint4Function getUint4,
  820.                                              TSetUint4Function setUint4)
  821. {
  822.     m_GetInt4 = getInt4;
  823.     m_SetInt4 = setInt4;
  824.     m_GetUint4 = getUint4;
  825.     m_SetUint4 = setUint4;
  826. }
  828. void CPrimitiveTypeInfoInt::SetInt8Functions(TGetInt8Function getInt8,
  829.                                              TSetInt8Function setInt8,
  830.                                              TGetUint8Function getUint8,
  831.                                              TSetUint8Function setUint8)
  832. {
  833.     m_GetInt8 = getInt8;
  834.     m_SetInt8 = setInt8;
  835.     m_GetUint8 = getUint8;
  836.     m_SetUint8 = setUint8;
  837. }
  839. Int4 CPrimitiveTypeInfoInt::GetValueInt4(TConstObjectPtr objectPtr) const
  840. {
  841.     return m_GetInt4(objectPtr);
  842. }
  844. Uint4 CPrimitiveTypeInfoInt::GetValueUint4(TConstObjectPtr objectPtr) const
  845. {
  846.     return m_GetUint4(objectPtr);
  847. }
  849. void CPrimitiveTypeInfoInt::SetValueInt4(TObjectPtr objectPtr,
  850.                                          Int4 value) const
  851. {
  852.     m_SetInt4(objectPtr, value);
  853. }
  855. void CPrimitiveTypeInfoInt::SetValueUint4(TObjectPtr objectPtr,
  856.                                           Uint4 value) const
  857. {
  858.     m_SetUint4(objectPtr, value);
  859. }
  861. Int8 CPrimitiveTypeInfoInt::GetValueInt8(TConstObjectPtr objectPtr) const
  862. {
  863.     return m_GetInt8(objectPtr);
  864. }
  866. Uint8 CPrimitiveTypeInfoInt::GetValueUint8(TConstObjectPtr objectPtr) const
  867. {
  868.     return m_GetUint8(objectPtr);
  869. }
  871. void CPrimitiveTypeInfoInt::SetValueInt8(TObjectPtr objectPtr,
  872.                                          Int8 value) const
  873. {
  874.     m_SetInt8(objectPtr, value);
  875. }
  877. void CPrimitiveTypeInfoInt::SetValueUint8(TObjectPtr objectPtr,
  878.                                           Uint8 value) const
  879. {
  880.     m_SetUint8(objectPtr, value);
  881. }
  883. #define DECLARE_STD_INT_TYPE(Type) 
  884. TTypeInfo CStdTypeInfo<Type>::GetTypeInfo(void) 
  885. { 
  886.     static TTypeInfo info = CreateTypeInfo(); 
  887.     return info; 
  888. } 
  889. CTypeInfo* CStdTypeInfo<Type>::CreateTypeInfo(void) 
  890. { 
  891.     return CPrimitiveTypeInfoIntFunctions<Type>::CreateTypeInfo(); 
  892. }
  894. DECLARE_STD_INT_TYPE(signed char)
  895. DECLARE_STD_INT_TYPE(unsigned char)
  896. DECLARE_STD_INT_TYPE(short)
  897. DECLARE_STD_INT_TYPE(unsigned short)
  898. DECLARE_STD_INT_TYPE(int)
  899. DECLARE_STD_INT_TYPE(unsigned)
  900. #if SIZEOF_LONG == 4
  901. DECLARE_STD_INT_TYPE(long)
  902. DECLARE_STD_INT_TYPE(unsigned long)
  903. #endif
  904. DECLARE_STD_INT_TYPE(Int8)
  905. DECLARE_STD_INT_TYPE(Uint8)
  907. const CPrimitiveTypeInfo* CPrimitiveTypeInfo::GetIntegerTypeInfo(size_t size,
  908.                                                                  bool sign)
  909. {
  910.     TTypeInfo info;
  911.     if ( size == sizeof(int) ) {
  912.         if ( sign )
  913.             info = CStdTypeInfo<int>::GetTypeInfo();
  914.         else
  915.             info = CStdTypeInfo<unsigned>::GetTypeInfo();
  916.     }
  917.     else if ( size == sizeof(short) ) {
  918.         if ( sign )
  919.             info = CStdTypeInfo<short>::GetTypeInfo();
  920.         else
  921.             info = CStdTypeInfo<unsigned short>::GetTypeInfo();
  922.     }
  923.     else if ( size == sizeof(signed char) ) {
  924.         if ( sign )
  925.             info = CStdTypeInfo<signed char>::GetTypeInfo();
  926.         else
  927.             info = CStdTypeInfo<unsigned char>::GetTypeInfo();
  928.     }
  929.     else if ( size == sizeof(Int8) ) {
  930.         if ( sign )
  931.             info = CStdTypeInfo<Int8>::GetTypeInfo();
  932.         else
  933.             info = CStdTypeInfo<Uint8>::GetTypeInfo();
  934.     }
  935.     else {
  936.         string message("Illegal enum size: ");
  937.         message += NStr::UIntToString(size);
  938.         NCBI_THROW(CSerialException,eInvalidData, message);
  939.     }
  940.     _ASSERT(info->GetSize() == size);
  941.     _ASSERT(info->GetTypeFamily() == eTypeFamilyPrimitive);
  942.     _ASSERT(CTypeConverter<CPrimitiveTypeInfo>::SafeCast(info)->GetPrimitiveValueType() == ePrimitiveValueInteger);
  943.     return CTypeConverter<CPrimitiveTypeInfo>::SafeCast(info);
  944. }
  946. CPrimitiveTypeInfoDouble::CPrimitiveTypeInfoDouble(void)
  947.     : CParent(sizeof(TObjectType), ePrimitiveValueReal, true)
  948. {
  949.     CPrimitiveTypeFunctions<TObjectType>::SetMemFunctions(this);
  950.     CPrimitiveTypeFunctions<TObjectType>::SetIOFunctions(this);
  951. }
  953. double CPrimitiveTypeInfoDouble::GetValueDouble(TConstObjectPtr objectPtr) const
  954. {
  955.     return CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr);
  956. }
  958. void CPrimitiveTypeInfoDouble::SetValueDouble(TObjectPtr objectPtr,
  959.                                               double value) const
  960. {
  961.     CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr) = value;
  962. }
  964. TTypeInfo CStdTypeInfo<double>::GetTypeInfo(void)
  965. {
  966.     static TTypeInfo info = CreateTypeInfo();
  967.     return info;
  968. }
  970. CTypeInfo* CStdTypeInfo<double>::CreateTypeInfo(void)
  971. {
  972.     return new CPrimitiveTypeInfoDouble();
  973. }
  975. CPrimitiveTypeInfoFloat::CPrimitiveTypeInfoFloat(void)
  976.     : CParent(sizeof(TObjectType), ePrimitiveValueReal, true)
  977. {
  978.     CPrimitiveTypeFunctions<TObjectType>::SetMemFunctions(this);
  979.     CPrimitiveTypeFunctions<TObjectType>::SetIOFunctions(this);
  980. }
  982. double CPrimitiveTypeInfoFloat::GetValueDouble(TConstObjectPtr objectPtr) const
  983. {
  984.     return CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr);
  985. }
  987. void CPrimitiveTypeInfoFloat::SetValueDouble(TObjectPtr objectPtr,
  988.                                              double value) const
  989. {
  990. #if defined(FLT_MIN) && defined(FLT_MAX)
  991.     if ( value < FLT_MIN || value > FLT_MAX )
  992.         ThrowIncompatibleValue();
  993. #endif
  994.     CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr) = TObjectType(value);
  995. }
  997. TTypeInfo CStdTypeInfo<float>::GetTypeInfo(void)
  998. {
  999.     static TTypeInfo info = CreateTypeInfo();
  1000.     return info;
  1001. }
  1003. CTypeInfo* CStdTypeInfo<float>::CreateTypeInfo(void)
  1004. {
  1005.     return new CPrimitiveTypeInfoFloat();
  1006. }
  1008. #if SIZEOF_LONG_DOUBLE != 0
  1009. CPrimitiveTypeInfoLongDouble::CPrimitiveTypeInfoLongDouble(void)
  1010.     : CParent(sizeof(TObjectType), ePrimitiveValueReal, true)
  1011. {
  1012.     CPrimitiveTypeFunctions<TObjectType>::SetMemFunctions(this);
  1013.     CPrimitiveTypeFunctions<TObjectType>::SetIOFunctions(this);
  1014. }
  1016. double CPrimitiveTypeInfoLongDouble::GetValueDouble(TConstObjectPtr objectPtr) const
  1017. {
  1018.     return CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr);
  1019. }
  1021. void CPrimitiveTypeInfoLongDouble::SetValueDouble(TObjectPtr objectPtr,
  1022.                                                double value) const
  1023. {
  1024.     CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr) = TObjectType(value);
  1025. }
  1027. long double CPrimitiveTypeInfoLongDouble::GetValueLDouble(TConstObjectPtr objectPtr) const
  1028. {
  1029.     return CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr);
  1030. }
  1032. void CPrimitiveTypeInfoLongDouble::SetValueLDouble(TObjectPtr objectPtr,
  1033.                                                    long double value) const
  1034. {
  1035.     CPrimitiveTypeFunctions<TObjectType>::Get(objectPtr) = TObjectType(value);
  1036. }
  1038. TTypeInfo CStdTypeInfo<long double>::GetTypeInfo(void)
  1039. {
  1040.     static TTypeInfo info = CreateTypeInfo();
  1041.     return info;
  1042. }
  1044. CTypeInfo* CStdTypeInfo<long double>::CreateTypeInfo(void)
  1045. {
  1046.     return new CPrimitiveTypeInfoLongDouble();
  1047. }
  1048. #endif
  1050. template<typename T>
  1051. class CStringFunctions : public CPrimitiveTypeFunctions<T>
  1052. {
  1053.     typedef CPrimitiveTypeFunctions<T> CParent;
  1054. public:
  1055.     static TObjectPtr Create(TTypeInfo )
  1056.         {
  1057.             return new T();
  1058.         }
  1059.     static bool IsDefault(TConstObjectPtr objectPtr)
  1060.         {
  1061.             return CParent::Get(objectPtr).empty();
  1062.         }
  1063.     static void SetDefault(TObjectPtr objectPtr)
  1064.         {
  1065.             CParent::Get(objectPtr).erase();
  1066.         }
  1067.     static void Copy(CObjectStreamCopier& copier, TTypeInfo )
  1068.         {
  1069.             copier.CopyString();
  1070.         }
  1071.     static void Skip(CObjectIStream& in, TTypeInfo )
  1072.         {
  1073.             in.SkipString();
  1074.         }
  1075. };
  1077. CPrimitiveTypeInfoString::CPrimitiveTypeInfoString(EType type)
  1078.     : CParent(sizeof(string), ePrimitiveValueString), m_Type(type)
  1079. {
  1080.     if (type == eStringTypeUTF8) {
  1081.         SetMemFunctions(&CStringFunctions<CStringUTF8>::Create,
  1082.                         &CStringFunctions<CStringUTF8>::IsDefault,
  1083.                         &CStringFunctions<CStringUTF8>::SetDefault,
  1084.                         &CStringFunctions<CStringUTF8>::Equals,
  1085.                         &CStringFunctions<CStringUTF8>::Assign);
  1086.         SetIOFunctions(&CStringFunctions<CStringUTF8>::Read,
  1087.                        &CStringFunctions<CStringUTF8>::Write,
  1088.                        &CStringFunctions<CStringUTF8>::Copy,
  1089.                        &CStringFunctions<CStringUTF8>::Skip);
  1090.     } else {
  1091.         SetMemFunctions(&CStringFunctions<string>::Create,
  1092.                         &CStringFunctions<string>::IsDefault,
  1093.                         &CStringFunctions<string>::SetDefault,
  1094.                         &CStringFunctions<string>::Equals,
  1095.                         &CStringFunctions<string>::Assign);
  1096.         SetIOFunctions(&CStringFunctions<string>::Read,
  1097.                        &CStringFunctions<string>::Write,
  1098.                        &CStringFunctions<string>::Copy,
  1099.                        &CStringFunctions<string>::Skip);
  1100.     }
  1101. }
  1103. void CPrimitiveTypeInfoString::GetValueString(TConstObjectPtr object,
  1104.                                               string& value) const
  1105. {
  1106.     value = CPrimitiveTypeFunctions<TObjectType>::Get(object);
  1107. }
  1109. void CPrimitiveTypeInfoString::SetValueString(TObjectPtr object,
  1110.                                               const string& value) const
  1111. {
  1112.     CPrimitiveTypeFunctions<TObjectType>::Get(object) = value;
  1113. }
  1115. char CPrimitiveTypeInfoString::GetValueChar(TConstObjectPtr object) const
  1116. {
  1117.     if ( CPrimitiveTypeFunctions<TObjectType>::Get(object).size() != 1 )
  1118.         ThrowIncompatibleValue();
  1119.     return CPrimitiveTypeFunctions<TObjectType>::Get(object)[0];
  1120. }
  1122. void CPrimitiveTypeInfoString::SetValueChar(TObjectPtr object,
  1123.                                             char value) const
  1124. {
  1125.     CPrimitiveTypeFunctions<TObjectType>::Get(object).assign(1, value);
  1126. }
  1128. TTypeInfo CStdTypeInfo<string>::GetTypeInfo(void)
  1129. {
  1130.     static TTypeInfo info = CreateTypeInfo();
  1131.     return info;
  1132. }
  1134. CTypeInfo* CStdTypeInfo<string>::CreateTypeInfo(void)
  1135. {
  1136.     return new CPrimitiveTypeInfoString();
  1137. }
  1139. TTypeInfo CStdTypeInfo<ncbi::CStringUTF8>::GetTypeInfo(void)
  1140. {
  1141.     static TTypeInfo info = CreateTypeInfo();
  1142.     return info;
  1143. }
  1145. CTypeInfo* CStdTypeInfo<ncbi::CStringUTF8>::CreateTypeInfo(void)
  1146. {
  1147.     return new CPrimitiveTypeInfoString(CPrimitiveTypeInfoString::eStringTypeUTF8);
  1148. }
  1150. class CStringStoreFunctions : public CStringFunctions<string>
  1151. {
  1152. public:
  1153.     static void Read(CObjectIStream& in, TTypeInfo , TObjectPtr objectPtr)
  1154.         {
  1155.             in.ReadStringStore(Get(objectPtr));
  1156.         }
  1157.     static void Write(CObjectOStream& out, TTypeInfo ,
  1158.                       TConstObjectPtr objectPtr)
  1159.         {
  1160.             out.WriteStringStore(Get(objectPtr));
  1161.         }
  1162.     static void Copy(CObjectStreamCopier& copier, TTypeInfo )
  1163.         {
  1164.             copier.CopyStringStore();
  1165.         }
  1166.     static void Skip(CObjectIStream& in, TTypeInfo )
  1167.         {
  1168.             in.SkipStringStore();
  1169.         }
  1170. };
  1172. TTypeInfo CStdTypeInfo<string>::GetTypeInfoStringStore(void)
  1173. {
  1174.     static TTypeInfo info = CreateTypeInfoStringStore();
  1175.     return info;
  1176. }
  1178. CTypeInfo* CStdTypeInfo<string>::CreateTypeInfoStringStore(void)
  1179. {
  1180.     CPrimitiveTypeInfo* info = new CPrimitiveTypeInfoString;
  1181.     typedef CStringStoreFunctions TFunctions;
  1182.     info->SetIOFunctions(&TFunctions::Read, &TFunctions::Write,
  1183.                          &TFunctions::Copy, &TFunctions::Skip);
  1184.     return info;
  1185. }
  1187. template<typename T>
  1188. class CCharPtrFunctions : public CPrimitiveTypeFunctions<T>
  1189. {
  1190.     typedef CPrimitiveTypeFunctions<T> CParent;
  1191. public:
  1192.     static bool IsDefault(TConstObjectPtr objectPtr)
  1193.         {
  1194.             return CParent::Get(objectPtr) == 0;
  1195.         }
  1196.     static void SetDefault(TObjectPtr dst)
  1197.         {
  1198.             free(const_cast<char*>(CParent::Get(dst)));
  1199.             CParent::Get(dst) = 0;
  1200.         }
  1201.     static bool Equals(TConstObjectPtr object1, TConstObjectPtr object2,
  1202.                        ESerialRecursionMode)
  1203.         {
  1204.             return strcmp(CParent::Get(object1), CParent::Get(object2)) == 0;
  1205.         }
  1206.     static void Assign(TObjectPtr dst, TConstObjectPtr src,
  1207.                        ESerialRecursionMode)
  1208.         {
  1209.             typename CPrimitiveTypeFunctions<T>::TObjectType value
  1210.                 = CParent::Get(src);
  1211.             _ASSERT(CParent::Get(dst) != value);
  1212.             free(const_cast<char*>(CParent::Get(dst)));
  1213.             if ( value )
  1214.                 CParent::Get(dst) = NotNull(strdup(value));
  1215.             else
  1216.                 CParent::Get(dst) = 0;
  1217.         }
  1218. };
  1220. template<typename T>
  1221. CPrimitiveTypeInfoCharPtr<T>::CPrimitiveTypeInfoCharPtr(void)
  1222.     : CParent(sizeof(TObjectType), ePrimitiveValueString)
  1223. {
  1224.     typedef CCharPtrFunctions<TObjectType> TFunctions;
  1225.     SetMemFunctions(&CVoidTypeFunctions::Create,
  1226.                     &TFunctions::IsDefault, &TFunctions::SetDefault,
  1227.                     &TFunctions::Equals, &TFunctions::Assign);
  1228.     SetIOFunctions(&TFunctions::Read, &TFunctions::Write,
  1229.                    &TFunctions::Copy, &TFunctions::Skip);
  1230. }
  1232. template<typename T>
  1233. char CPrimitiveTypeInfoCharPtr<T>::GetValueChar(TConstObjectPtr objectPtr) const
  1234. {
  1235.     TObjectType obj = CCharPtrFunctions<TObjectType>::Get(objectPtr);
  1236.     if ( !obj || obj[0] == '' || obj[1] != '' )
  1237.         ThrowIncompatibleValue();
  1238.     return obj[0];
  1239. }
  1241. template<typename T>
  1242. void CPrimitiveTypeInfoCharPtr<T>::SetValueChar(TObjectPtr objectPtr,
  1243.                                                 char value) const
  1244. {
  1245.     char* obj = static_cast<char*>(NotNull(malloc(2)));
  1246.     obj[0] =  value;
  1247.     obj[1] = '';
  1248.     CCharPtrFunctions<TObjectPtr>::Get(objectPtr) = obj;
  1249. }
  1251. template<typename T>
  1252. void CPrimitiveTypeInfoCharPtr<T>::GetValueString(TConstObjectPtr objectPtr,
  1253.                                                   string& value) const
  1254. {
  1255.     value = CCharPtrFunctions<TObjectType>::Get(objectPtr);
  1256. }
  1258. template<typename T>
  1259. void CPrimitiveTypeInfoCharPtr<T>::SetValueString(TObjectPtr objectPtr,
  1260.                                                   const string& value) const
  1261. {
  1262.     CCharPtrFunctions<TObjectPtr>::Get(objectPtr) =
  1263.         NotNull(strdup(value.c_str()));
  1264. }
  1266. TTypeInfo CStdTypeInfo<char*>::GetTypeInfo(void)
  1267. {
  1268.     static TTypeInfo info = CreateTypeInfo();
  1269.     return info;
  1270. }
  1272. CTypeInfo* CStdTypeInfo<char*>::CreateTypeInfo(void)
  1273. {
  1274.     return new CPrimitiveTypeInfoCharPtr<char*>();
  1275. }
  1277. TTypeInfo CStdTypeInfo<const char*>::GetTypeInfo(void)
  1278. {
  1279.     static TTypeInfo info = CreateTypeInfo();
  1280.     return info;
  1281. }
  1283. CTypeInfo* CStdTypeInfo<const char*>::CreateTypeInfo(void)
  1284. {
  1285.     return new CPrimitiveTypeInfoCharPtr<const char*>();
  1286. }
  1288. void ThrowIncompatibleValue(void)
  1289. {
  1290.     NCBI_THROW(CSerialException,eInvalidData, "incompatible value");
  1291. }
  1293. void ThrowIllegalCall(void)
  1294. {
  1295.     NCBI_THROW(CSerialException,eIllegalCall, "illegal call");
  1296. }
  1298. void ThrowIntegerOverflow(void)
  1299. {
  1300.     NCBI_THROW(CSerialException,eOverflow, "integer overflow");
  1301. }
  1303. class CCharVectorFunctionsBase
  1304. {
  1305. public:
  1306.     static void Copy(CObjectStreamCopier& copier,
  1307.                      TTypeInfo )
  1308.         {
  1309.             copier.CopyByteBlock();
  1310.         }
  1311.     static void Skip(CObjectIStream& in, TTypeInfo )
  1312.         {
  1313.             in.SkipByteBlock();
  1314.         }
  1315. };
  1317. template<typename Char>
  1318. class CCharVectorFunctions : public CCharVectorFunctionsBase
  1319. {
  1320. public:
  1321.     typedef vector<Char> TObjectType;
  1322.     typedef Char TChar;
  1324.     static TObjectType& Get(TObjectPtr object)
  1325.         {
  1326.             return CTypeConverter<TObjectType>::Get(object);
  1327.         }
  1328.     static const TObjectType& Get(TConstObjectPtr object)
  1329.         {
  1330.             return CTypeConverter<TObjectType>::Get(object);
  1331.         }
  1333.     static char* ToChar(TChar* p)
  1334.         { return reinterpret_cast<char*>(p); }
  1335.     static const char* ToChar(const TChar* p)
  1336.         { return reinterpret_cast<const char*>(p); }
  1337.     static const TChar* ToTChar(const char* p)
  1338.         { return reinterpret_cast<const TChar*>(p); }
  1340.     static TObjectPtr Create(TTypeInfo )
  1341.         {
  1342.             return new TObjectType();
  1343.         }
  1344.     static bool IsDefault(TConstObjectPtr object)
  1345.         {
  1346.             return Get(object).empty();
  1347.         }
  1348.     static bool Equals(TConstObjectPtr object1, TConstObjectPtr object2,
  1349.                        ESerialRecursionMode)
  1350.         {
  1351.             return Get(object1) == Get(object2);
  1352.         }
  1353.     static void SetDefault(TObjectPtr dst)
  1354.         {
  1355.             Get(dst).clear();
  1356.         }
  1357.     static void Assign(TObjectPtr dst, TConstObjectPtr src,
  1358.                        ESerialRecursionMode)
  1359.         {
  1360.             Get(dst) = Get(src);
  1361.         }
  1363.     static void Read(CObjectIStream& in,
  1364.                      TTypeInfo , TObjectPtr objectPtr)
  1365.         {
  1366.             TObjectType& o = Get(objectPtr);
  1367.             CObjectIStream::ByteBlock block(in);
  1368.             if ( block.KnownLength() ) {
  1369.                 size_t length = block.GetExpectedLength();
  1370. #if 1
  1371.                 o.clear();
  1372.                 o.reserve(length);
  1373.                 Char buf[2048];
  1374.                 size_t count;
  1375.                 while ( (count = block.Read(ToChar(buf), sizeof(buf))) != 0 ) {
  1376.                     o.insert(o.end(), buf, buf + count);
  1377.                 }
  1378. #else
  1379.                 o.resize(length);
  1380.                 block.Read(ToChar(&o.front()), length, true);
  1381. #endif
  1382.             }
  1383.             else {
  1384.                 // length is unknown -> copy via buffer
  1385.                 o.clear();
  1386.                 Char buf[4096];
  1387.                 size_t count;
  1388.                 while ( (count = block.Read(ToChar(buf), sizeof(buf))) != 0 ) {
  1389. #ifdef RESERVE_VECTOR_SIZE
  1390.                     size_t new_size = o.size() + count;
  1391.                     if ( new_size > o.capacity() ) {
  1392.                         o.reserve(RESERVE_VECTOR_SIZE(new_size));
  1393.                     }
  1394. #endif
  1395.                     o.insert(o.end(), buf, buf + count);
  1396.                 }
  1397.             }
  1398.             block.End();
  1399.         }
  1400.     static void Write(CObjectOStream& out,
  1401.                       TTypeInfo , TConstObjectPtr objectPtr)
  1402.         {
  1403.             const TObjectType& o = Get(objectPtr);
  1404.             size_t length = o.size();
  1405.             CObjectOStream::ByteBlock block(out, length);
  1406.             if ( length > 0 )
  1407.                 block.Write(ToChar(&o.front()), length);
  1408.             block.End();
  1409.         }
  1410. };
  1412. template<typename Char>
  1413. CCharVectorTypeInfo<Char>::CCharVectorTypeInfo(void)
  1414.     : CParent(sizeof(TObjectType), ePrimitiveValueOctetString)
  1415. {
  1416.     typedef CCharVectorFunctions<Char> TFunctions;
  1417.     SetMemFunctions(&TFunctions::Create,
  1418.                     &TFunctions::IsDefault, &TFunctions::SetDefault,
  1419.                     &TFunctions::Equals, &TFunctions::Assign);
  1420.     SetIOFunctions(&TFunctions::Read, &TFunctions::Write,
  1421.                    &TFunctions::Copy, &TFunctions::Skip);
  1422. }
  1424. template<typename Char>
  1425. void CCharVectorTypeInfo<Char>::GetValueString(TConstObjectPtr objectPtr,
  1426.                                                string& value) const
  1427. {
  1428.     const TObjectType& obj = CCharVectorFunctions<TChar>::Get(objectPtr);
  1429.     const char* buffer = CCharVectorFunctions<TChar>::ToChar(&obj.front());
  1430.     value.assign(buffer, buffer + obj.size());
  1431. }
  1433. template<typename Char>
  1434. void CCharVectorTypeInfo<Char>::SetValueString(TObjectPtr objectPtr,
  1435.                                                const string& value) const
  1436. {
  1437.     TObjectType& obj = CCharVectorFunctions<TChar>::Get(objectPtr);
  1438.     obj.clear();
  1439.     const TChar* buffer = CCharVectorFunctions<TChar>::ToTChar(value.data());
  1440.     obj.insert(obj.end(), buffer, buffer + value.size());
  1441. }
  1443. template<typename Char>
  1444. void CCharVectorTypeInfo<Char>::GetValueOctetString(TConstObjectPtr objectPtr,
  1445.                                                     vector<char>& value) const
  1446. {
  1447.     const TObjectType& obj = CCharVectorFunctions<TChar>::Get(objectPtr);
  1448.     value.clear();
  1449.     const char* buffer = CCharVectorFunctions<TChar>::ToChar(&obj.front());
  1450.     value.insert(value.end(), buffer, buffer + obj.size());
  1451. }
  1453. template<typename Char>
  1454. void CCharVectorTypeInfo<Char>::SetValueOctetString(TObjectPtr objectPtr,
  1455.                                                     const vector<char>& value) const
  1456. {
  1457.     TObjectType& obj = CCharVectorFunctions<TChar>::Get(objectPtr);
  1458.     obj.clear();
  1459.     const TChar* buffer = CCharVectorFunctions<TChar>::ToTChar(&value.front());
  1460.     obj.insert(obj.end(), buffer, buffer + value.size());
  1461. }
  1463. TTypeInfo CStdTypeInfo< vector<char> >::GetTypeInfo(void)
  1464. {
  1465.     static TTypeInfo typeInfo = CreateTypeInfo();
  1466.     return typeInfo;
  1467. }
  1469. TTypeInfo CStdTypeInfo< vector<signed char> >::GetTypeInfo(void)
  1470. {
  1471.     static TTypeInfo typeInfo = CreateTypeInfo();
  1472.     return typeInfo;
  1473. }
  1475. TTypeInfo CStdTypeInfo< vector<unsigned char> >::GetTypeInfo(void)
  1476. {
  1477.     static TTypeInfo typeInfo = CreateTypeInfo();
  1478.     return typeInfo;
  1479. }
  1481. CTypeInfo* CStdTypeInfo< vector<char> >::CreateTypeInfo(void)
  1482. {
  1483.     return new CCharVectorTypeInfo<char>;
  1484. }
  1486. CTypeInfo* CStdTypeInfo< vector<signed char> >::CreateTypeInfo(void)
  1487. {
  1488.     return new CCharVectorTypeInfo<signed char>;
  1489. }
  1491. CTypeInfo* CStdTypeInfo< vector<unsigned char> >::CreateTypeInfo(void)
  1492. {
  1493.     return new CCharVectorTypeInfo<unsigned char>;
  1494. }
  1497. class CAnyContentFunctions : public CPrimitiveTypeFunctions<ncbi::CAnyContentObject>
  1498. {
  1499. public:
  1500.     static TObjectPtr Create(TTypeInfo )
  1501.         {
  1502.             return new TObjectType();
  1503.         }
  1504.     static bool IsDefault(TConstObjectPtr objectPtr)
  1505.         {
  1506.             return Get(objectPtr) == TObjectType();
  1507.         }
  1508.     static void SetDefault(TObjectPtr objectPtr)
  1509.         {
  1510.             Get(objectPtr) = TObjectType();
  1511.         }
  1512.     static void Read(CObjectIStream& in, TTypeInfo , TObjectPtr objectPtr)
  1513.         {
  1514.             in.ReadAnyContentObject(Get(objectPtr));
  1515.         }
  1516.     static void Write(CObjectOStream& out, TTypeInfo ,
  1517.                       TConstObjectPtr objectPtr)
  1518.         {
  1519.             out.WriteAnyContentObject(Get(objectPtr));
  1520.         }
  1521.     static void Copy(CObjectStreamCopier& copier, TTypeInfo )
  1522.         {
  1523.             copier.CopyAnyContentObject();
  1524.         }
  1525.     static void Skip(CObjectIStream& in, TTypeInfo )
  1526.         {
  1527.             in.SkipAnyContentObject();
  1528.         }
  1529. };
  1531. CPrimitiveTypeInfoAnyContent::CPrimitiveTypeInfoAnyContent(void)
  1532.     : CParent(sizeof(CAnyContentObject), ePrimitiveValueOther)
  1533. {
  1534.     m_IsCObject = true;
  1535.     typedef CPrimitiveTypeFunctions<ncbi::CAnyContentObject> TFunctions;
  1536.     SetMemFunctions(&CAnyContentFunctions::Create,
  1537.                     &CAnyContentFunctions::IsDefault,
  1538.                     &CAnyContentFunctions::SetDefault,
  1539.                     &TFunctions::Equals, &TFunctions::Assign);
  1540.     SetIOFunctions(&CAnyContentFunctions::Read,
  1541.                    &CAnyContentFunctions::Write,
  1542.                    &CAnyContentFunctions::Copy,
  1543.                    &CAnyContentFunctions::Skip);
  1544. }
  1546. TTypeInfo CStdTypeInfo<CAnyContentObject>::GetTypeInfo(void)
  1547. {
  1548.     static TTypeInfo info = CreateTypeInfo();
  1549.     return info;
  1550. }
  1552. CTypeInfo* CStdTypeInfo<ncbi::CAnyContentObject>::CreateTypeInfo(void)
  1553. {
  1554.     return new CPrimitiveTypeInfoAnyContent();
  1555. }
  1557. END_NCBI_SCOPE
  1559. /*
  1560. * ===========================================================================
  1561. *
  1562. * $Log: stdtypes.cpp,v $
  1563. * Revision 1000.3  2004/06/01 19:41:52  gouriano
  1564. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.44
  1565. *
  1566. * Revision 1.44  2004/05/17 21:03:03  gorelenk
  1567. * Added include of PCH ncbi_pch.hpp
  1568. *
  1569. * Revision 1.43  2004/04/26 16:40:59  ucko
  1570. * Tweak for GCC 3.4 compatibility.
  1571. *
  1572. * Revision 1.42  2004/03/25 15:57:08  gouriano
  1573. * Added possibility to copy and compare serial object non-recursively
  1574. *
  1575. * Revision 1.41  2004/02/04 19:03:00  ucko
  1576. * Make floating-point comparison slightly looser, as I/O may introduce
  1577. * insignificant discrepancies.
  1578. *
  1579. * Revision 1.40  2004/02/02 14:42:48  vasilche
  1580. * Try to avoid filling vector<char> by zeroes.
  1581. *
  1582. * Revision 1.39  2004/01/27 17:09:12  ucko
  1583. * CStringFunctions::Create: tweak to compile with default IBM VisualAge
  1584. * settings.
  1585. * Move CVS log to end.
  1586. *
  1587. * Revision 1.38  2003/11/20 14:33:19  gouriano
  1588. * changed generated C++ code so NULL data types have no value
  1589. *
  1590. * Revision 1.37  2003/09/22 20:56:31  gouriano
  1591. * Changed base type of AnyContent object to CSerialObject
  1592. *
  1593. * Revision 1.36  2003/08/13 15:47:45  gouriano
  1594. * implemented serialization of AnyContent objects
  1595. *
  1596. * Revision 1.35  2003/05/22 20:10:02  gouriano
  1597. * added UTF8 strings
  1598. *
  1599. * Revision 1.34  2003/05/16 18:02:18  gouriano
  1600. * revised exception error messages
  1601. *
  1602. * Revision 1.33  2003/03/10 18:54:26  gouriano
  1603. * use new structured exceptions (based on CException)
  1604. *
  1605. * Revision 1.32  2002/10/25 14:49:27  vasilche
  1606. * NCBI C Toolkit compatibility code extracted to libxcser library.
  1607. * Serial streams flags names were renamed to fXxx.
  1608. *
  1609. * Names of flags
  1610. *
  1611. * Revision 1.31  2002/07/01 15:42:07  grichenk
  1612. * Fixed 'unused variable' warnings, removed commented code.
  1613. *
  1614. * Revision 1.30  2002/02/13 22:39:17  ucko
  1615. * Support AIX.
  1616. *
  1617. * Revision 1.29  2002/01/15 21:38:26  grichenk
  1618. * Fixed NULL type initialization/reading/writing
  1619. *
  1620. * Revision 1.28  2001/05/17 15:07:09  lavr
  1621. * Typos corrected
  1622. *
  1623. * Revision 1.27  2001/01/30 21:41:05  vasilche
  1624. * Fixed dealing with unsigned enums.
  1625. *
  1626. * Revision 1.26  2000/12/15 15:38:46  vasilche
  1627. * Added support of Int8 and long double.
  1628. * Enum values now have type Int4 instead of long.
  1629. *
  1630. * Revision 1.25  2000/11/07 17:25:41  vasilche
  1631. * Fixed encoding of XML:
  1632. *     removed unnecessary apostrophes in OCTET STRING
  1633. *     removed unnecessary content in NULL
  1634. * Added module names to CTypeInfo and CEnumeratedTypeValues
  1635. *
  1636. * Revision 1.24  2000/10/20 15:51:43  vasilche
  1637. * Fixed data error processing.
  1638. * Added interface for constructing container objects directly into output stream.
  1639. * object.hpp, object.inl and object.cpp were split to
  1640. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  1641. *
  1642. * Revision 1.23  2000/10/17 18:45:36  vasilche
  1643. * Added possibility to turn off object cross reference detection in
  1644. * CObjectIStream and CObjectOStream.
  1645. *
  1646. * Revision 1.22  2000/10/13 20:22:56  vasilche
  1647. * Fixed warnings on 64 bit compilers.
  1648. * Fixed missing typename in templates.
  1649. *
  1650. * Revision 1.21  2000/10/13 16:28:40  vasilche
  1651. * Reduced header dependency.
  1652. * Avoid use of templates with virtual methods.
  1653. * Reduced amount of different maps used.
  1654. * All this lead to smaller compiled code size (libraries and programs).
  1655. *
  1656. * Revision 1.20  2000/09/18 20:00:25  vasilche
  1657. * Separated CVariantInfo and CMemberInfo.
  1658. * Implemented copy hooks.
  1659. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  1660. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  1661. *
  1662. * Revision 1.19  2000/09/01 13:16:21  vasilche
  1663. * Implemented class/container/choice iterators.
  1664. * Implemented CObjectStreamCopier for copying data without loading into memory.
  1665. *
  1666. * Revision 1.18  2000/07/03 18:42:47  vasilche
  1667. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  1668. * Reduced header dependency.
  1669. *
  1670. * Revision 1.17  2000/05/24 20:08:49  vasilche
  1671. * Implemented XML dump.
  1672. *
  1673. * Revision 1.16  2000/04/06 16:11:01  vasilche
  1674. * Fixed bug with iterators in choices.
  1675. * Removed unneeded calls to ReadExternalObject/WriteExternalObject.
  1676. * Added output buffering to text ASN.1 data.
  1677. *
  1678. * Revision 1.15  2000/03/14 14:42:32  vasilche
  1679. * Fixed error reporting.
  1680. *
  1681. * Revision 1.14  2000/03/07 14:06:24  vasilche
  1682. * Added stream buffering to ASN.1 binary input.
  1683. * Optimized class loading/storing.
  1684. * Fixed bugs in processing OPTIONAL fields.
  1685. * Added generation of reference counted objects.
  1686. *
  1687. * Revision 1.13  2000/01/10 19:46:42  vasilche
  1688. * Fixed encoding/decoding of REAL type.
  1689. * Fixed encoding/decoding of StringStore.
  1690. * Fixed encoding/decoding of NULL type.
  1691. * Fixed error reporting.
  1692. * Reduced object map (only classes).
  1693. *
  1694. * Revision 1.12  2000/01/05 19:43:57  vasilche
  1695. * Fixed error messages when reading from ASN.1 binary file.
  1696. * Fixed storing of integers with enumerated values in ASN.1 binary file.
  1697. * Added TAG support to key/value of map.
  1698. * Added support of NULL variant in CHOICE.
  1699. *
  1700. * Revision 1.11  1999/12/28 18:55:52  vasilche
  1701. * Reduced size of compiled object files:
  1702. * 1. avoid inline or implicit virtual methods (especially destructors).
  1703. * 2. avoid std::string's methods usage in inline methods.
  1704. * 3. avoid string literals ("xxx") in inline methods.
  1705. *
  1706. * Revision 1.10  1999/12/17 19:05:04  vasilche
  1707. * Simplified generation of GetTypeInfo methods.
  1708. *
  1709. * Revision 1.9  1999/09/23 18:57:02  vasilche
  1710. * Fixed bugs with overloaded methods in objistr*.hpp & objostr*.hpp
  1711. *
  1712. * Revision 1.8  1999/09/14 18:54:20  vasilche
  1713. * Fixed bugs detected by gcc & egcs.
  1714. * Removed unneeded includes.
  1715. *
  1716. * Revision 1.7  1999/07/07 21:56:35  vasilche
  1717. * Fixed problem with static variables in templates on SunPro
  1718. *
  1719. * Revision 1.6  1999/07/07 21:15:03  vasilche
  1720. * Cleaned processing of string types (string, char*, const char*).
  1721. *
  1722. * Revision 1.5  1999/07/07 19:59:08  vasilche
  1723. * Reduced amount of data allocated on heap
  1724. * Cleaned ASN.1 structures info
  1725. *
  1726. * Revision 1.4  1999/06/30 16:05:05  vasilche
  1727. * Added support for old ASN.1 structures.
  1728. *
  1729. * Revision 1.3  1999/06/24 14:45:01  vasilche
  1730. * Added binary ASN.1 output.
  1731. *
  1732. * Revision 1.2  1999/06/04 20:51:49  vasilche
  1733. * First compilable version of serialization.
  1734. *
  1735. * Revision 1.1  1999/05/19 19:56:57  vasilche
  1736. * Commit just in case.
  1737. *
  1738. * ===========================================================================
  1739. */