enumerated.cpp
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:15k
源码类别:

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: enumerated.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:40:09  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.29
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. /*  $Id: enumerated.cpp,v 1000.2 2004/06/01 19:40:09 gouriano Exp $
  10. * ===========================================================================
  11. *
  12. *                            PUBLIC DOMAIN NOTICE
  13. *               National Center for Biotechnology Information
  14. *
  15. *  This software/database is a "United States Government Work" under the
  16. *  terms of the United States Copyright Act.  It was written as part of
  17. *  the author's official duties as a United States Government employee and
  18. *  thus cannot be copyrighted.  This software/database is freely available
  19. *  to the public for use. The National Library of Medicine and the U.S.
  20. *  Government have not placed any restriction on its use or reproduction.
  21. *
  22. *  Although all reasonable efforts have been taken to ensure the accuracy
  23. *  and reliability of the software and data, the NLM and the U.S.
  24. *  Government do not and cannot warrant the performance or results that
  25. *  may be obtained by using this software or data. The NLM and the U.S.
  26. *  Government disclaim all warranties, express or implied, including
  27. *  warranties of performance, merchantability or fitness for any particular
  28. *  purpose.
  29. *
  30. *  Please cite the author in any work or product based on this material.
  31. *
  32. * ===========================================================================
  33. *
  34. * Author: Eugene Vasilchenko
  35. *
  36. * File Description:
  37. *   !!! PUT YOUR DESCRIPTION HERE !!!
  38. *
  39. * ---------------------------------------------------------------------------
  40. * $Log: enumerated.cpp,v $
  41. * Revision 1000.2  2004/06/01 19:40:09  gouriano
  42. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.29
  43. *
  44. * Revision 1.29  2004/05/17 21:03:02  gorelenk
  45. * Added include of PCH ncbi_pch.hpp
  46. *
  47. * Revision 1.28  2004/03/25 15:57:08  gouriano
  48. * Added possibility to copy and compare serial object non-recursively
  49. *
  50. * Revision 1.27  2003/05/16 18:02:18  gouriano
  51. * revised exception error messages
  52. *
  53. * Revision 1.26  2003/03/11 20:08:07  kuznets
  54. * iterate -> ITERATE
  55. *
  56. * Revision 1.25  2003/03/10 18:54:25  gouriano
  57. * use new structured exceptions (based on CException)
  58. *
  59. * Revision 1.24  2002/10/25 14:49:27  vasilche
  60. * NCBI C Toolkit compatibility code extracted to libxcser library.
  61. * Serial streams flags names were renamed to fXxx.
  62. *
  63. * Names of flags
  64. *
  65. * Revision 1.23  2002/09/19 20:05:44  vasilche
  66. * Safe initialization of static mutexes
  67. *
  68. * Revision 1.22  2002/09/05 21:21:32  vasilche
  69. * Added mutex for enum values map
  70. *
  71. * Revision 1.21  2002/08/30 16:21:32  vasilche
  72. * Added MT lock for cache maps
  73. *
  74. * Revision 1.20  2001/05/17 15:07:06  lavr
  75. * Typos corrected
  76. *
  77. * Revision 1.19  2001/01/30 21:41:04  vasilche
  78. * Fixed dealing with unsigned enums.
  79. *
  80. * Revision 1.18  2000/12/15 15:38:42  vasilche
  81. * Added support of Int8 and long double.
  82. * Enum values now have type Int4 instead of long.
  83. *
  84. * Revision 1.17  2000/11/07 17:25:40  vasilche
  85. * Fixed encoding of XML:
  86. *     removed unnecessary apostrophes in OCTET STRING
  87. *     removed unnecessary content in NULL
  88. * Added module names to CTypeInfo and CEnumeratedTypeValues
  89. *
  90. * Revision 1.16  2000/10/20 15:51:38  vasilche
  91. * Fixed data error processing.
  92. * Added interface for constructing container objects directly into output stream.
  93. * object.hpp, object.inl and object.cpp were split to
  94. * objectinfo.*, objecttype.*, objectiter.* and objectio.*.
  95. *
  96. * Revision 1.15  2000/10/17 18:45:33  vasilche
  97. * Added possibility to turn off object cross reference detection in
  98. * CObjectIStream and CObjectOStream.
  99. *
  100. * Revision 1.14  2000/09/26 18:09:48  vasilche
  101. * Fixed some warnings.
  102. *
  103. * Revision 1.13  2000/09/18 20:00:21  vasilche
  104. * Separated CVariantInfo and CMemberInfo.
  105. * Implemented copy hooks.
  106. * All hooks now are stored in CTypeInfo/CMemberInfo/CVariantInfo.
  107. * Most type specific functions now are implemented via function pointers instead of virtual functions.
  108. *
  109. * Revision 1.12  2000/09/01 13:16:15  vasilche
  110. * Implemented class/container/choice iterators.
  111. * Implemented CObjectStreamCopier for copying data without loading into memory.
  112. *
  113. * Revision 1.11  2000/08/15 19:44:47  vasilche
  114. * Added Read/Write hooks:
  115. * CReadObjectHook/CWriteObjectHook for objects of specified type.
  116. * CReadClassMemberHook/CWriteClassMemberHook for specified members.
  117. * CReadChoiceVariantHook/CWriteChoiceVariant for specified choice variants.
  118. * CReadContainerElementHook/CWriteContainerElementsHook for containers.
  119. *
  120. * Revision 1.10  2000/07/03 18:42:43  vasilche
  121. * Added interface to typeinfo via CObjectInfo and CConstObjectInfo.
  122. * Reduced header dependency.
  123. *
  124. * Revision 1.9  2000/06/07 19:45:58  vasilche
  125. * Some code cleaning.
  126. * Macros renaming in more clear way.
  127. * BEGIN_NAMED_*_INFO, ADD_*_MEMBER, ADD_NAMED_*_MEMBER.
  128. *
  129. * Revision 1.8  2000/06/01 19:07:02  vasilche
  130. * Added parsing of XML data.
  131. *
  132. * ===========================================================================
  133. */
  134. #include <ncbi_pch.hpp>
  135. #include <corelib/ncbistd.hpp>
  136. #include <corelib/ncbiutil.hpp>
  137. #include <corelib/ncbithr.hpp>
  138. #include <serial/enumvalues.hpp>
  139. #include <serial/enumerated.hpp>
  140. #include <serial/serialutil.hpp>
  141. #include <serial/objistr.hpp>
  142. #include <serial/objostr.hpp>
  143. #include <serial/objcopy.hpp>
  144. BEGIN_NCBI_SCOPE
  145. CEnumeratedTypeValues::CEnumeratedTypeValues(const char* name,
  146.                                              bool isInteger)
  147.     : m_Name(name), m_Integer(isInteger)
  148. {
  149. }
  150. CEnumeratedTypeValues::CEnumeratedTypeValues(const string& name,
  151.                                              bool isInteger)
  152.     : m_Name(name), m_Integer(isInteger)
  153. {
  154. }
  155. CEnumeratedTypeValues::~CEnumeratedTypeValues(void)
  156. {
  157. }
  158. void CEnumeratedTypeValues::SetModuleName(const string& name)
  159. {
  160.     if ( !m_ModuleName.empty() )
  161.         NCBI_THROW(CSerialException,eFail,"cannot change module name");
  162.     m_ModuleName = name;
  163. }
  164. TEnumValueType CEnumeratedTypeValues::FindValue(const CLightString& name) const
  165. {
  166.     const TNameToValue& m = NameToValue();
  167.     TNameToValue::const_iterator i = m.find(name);
  168.     if ( i == m.end() ) {
  169.         NCBI_THROW(CSerialException,eInvalidData,
  170.                    "invalid value of enumerated type");
  171.     }
  172.     return i->second;
  173. }
  174. const string& CEnumeratedTypeValues::FindName(TEnumValueType value,
  175.                                               bool allowBadValue) const
  176. {
  177.     const TValueToName& m = ValueToName();
  178.     TValueToName::const_iterator i = m.find(value);
  179.     if ( i == m.end() ) {
  180.         if ( allowBadValue ) {
  181.             return NcbiEmptyString;
  182.         }
  183.         else {
  184.             NCBI_THROW(CSerialException,eInvalidData,
  185.                        "invalid value of enumerated type");
  186.         }
  187.     }
  188.     return *i->second;
  189. }
  190. void CEnumeratedTypeValues::AddValue(const string& name, TEnumValueType value)
  191. {
  192.     if ( name.empty() ) {
  193.         NCBI_THROW(CSerialException,eInvalidData,
  194.                    "empty enum value name");
  195.     }
  196.     m_Values.push_back(make_pair(name, value));
  197.     m_ValueToName.reset(0);
  198.     m_NameToValue.reset(0);
  199. }
  200. DEFINE_STATIC_FAST_MUTEX(s_EnumValuesMutex);
  201. const CEnumeratedTypeValues::TValueToName&
  202. CEnumeratedTypeValues::ValueToName(void) const
  203. {
  204.     TValueToName* m = m_ValueToName.get();
  205.     if ( !m ) {
  206.         CFastMutexGuard GUARD(s_EnumValuesMutex);
  207.         m = m_ValueToName.get();
  208.         if ( !m ) {
  209.             auto_ptr<TValueToName> keep(m = new TValueToName);
  210.             ITERATE ( TValues, i, m_Values ) {
  211.                 (*m)[i->second] = &i->first;
  212.             }
  213.             m_ValueToName = keep;
  214.         }
  215.     }
  216.     return *m;
  217. }
  218. const CEnumeratedTypeValues::TNameToValue&
  219. CEnumeratedTypeValues::NameToValue(void) const
  220. {
  221.     TNameToValue* m = m_NameToValue.get();
  222.     if ( !m ) {
  223.         CFastMutexGuard GUARD(s_EnumValuesMutex);
  224.         m = m_NameToValue.get();
  225.         if ( !m ) {
  226.             auto_ptr<TNameToValue> keep(m = new TNameToValue);
  227.             ITERATE ( TValues, i, m_Values ) {
  228.                 const string& s = i->first;
  229.                 pair<TNameToValue::iterator, bool> p =
  230.                     m->insert(TNameToValue::value_type(s, i->second));
  231.                 if ( !p.second ) {
  232.                     NCBI_THROW(CSerialException,eInvalidData,
  233.                                "duplicate enum value name");
  234.                 }
  235.             }
  236.             m_NameToValue = keep;
  237.         }
  238.     }
  239.     return *m;
  240. }
  241. void CEnumeratedTypeValues::AddValue(const char* name, TEnumValueType value)
  242. {
  243.     AddValue(string(name), value);
  244. }
  245. CEnumeratedTypeInfo::CEnumeratedTypeInfo(size_t size,
  246.                                          const CEnumeratedTypeValues* values,
  247.                                          bool sign)
  248.     : CParent(size, values->GetName(), ePrimitiveValueEnum, sign),
  249.       m_ValueType(CPrimitiveTypeInfo::GetIntegerTypeInfo(size, sign)),
  250.       m_Values(*values)
  251. {
  252.     _ASSERT(m_ValueType->GetPrimitiveValueType() == ePrimitiveValueInteger);
  253.     if ( !values->GetModuleName().empty() )
  254.         SetModuleName(values->GetModuleName());
  255.     SetCreateFunction(&CreateEnum);
  256.     SetReadFunction(&ReadEnum);
  257.     SetWriteFunction(&WriteEnum);
  258.     SetCopyFunction(&CopyEnum);
  259.     SetSkipFunction(&SkipEnum);
  260. }
  261. bool CEnumeratedTypeInfo::IsDefault(TConstObjectPtr object) const
  262. {
  263.     return m_ValueType->IsDefault(object);
  264. }
  265. bool CEnumeratedTypeInfo::Equals(TConstObjectPtr object1, TConstObjectPtr object2,
  266.                                  ESerialRecursionMode how) const
  267. {
  268.     return m_ValueType->Equals(object1, object2, how);
  269. }
  270. void CEnumeratedTypeInfo::SetDefault(TObjectPtr dst) const
  271. {
  272.     m_ValueType->SetDefault(dst);
  273. }
  274. void CEnumeratedTypeInfo::Assign(TObjectPtr dst, TConstObjectPtr src,
  275.                                  ESerialRecursionMode how) const
  276. {
  277.     m_ValueType->Assign(dst, src, how);
  278. }
  279. bool CEnumeratedTypeInfo::IsSigned(void) const
  280. {
  281.     return m_ValueType->IsSigned();
  282. }
  283. Int4 CEnumeratedTypeInfo::GetValueInt4(TConstObjectPtr objectPtr) const
  284. {
  285.     return m_ValueType->GetValueInt4(objectPtr);
  286. }
  287. Uint4 CEnumeratedTypeInfo::GetValueUint4(TConstObjectPtr objectPtr) const
  288. {
  289.     return m_ValueType->GetValueUint4(objectPtr);
  290. }
  291. void CEnumeratedTypeInfo::SetValueInt4(TObjectPtr objectPtr, Int4 value) const
  292. {
  293.     if ( !Values().IsInteger() ) {
  294.         // check value for acceptance
  295.         _ASSERT(sizeof(TEnumValueType) == sizeof(value));
  296.         TEnumValueType v = TEnumValueType(value);
  297.         Values().FindName(v, false);
  298.     }
  299.     m_ValueType->SetValueInt4(objectPtr, value);
  300. }
  301. void CEnumeratedTypeInfo::SetValueUint4(TObjectPtr objectPtr,
  302.                                         Uint4 value) const
  303. {
  304.     if ( !Values().IsInteger() ) {
  305.         // check value for acceptance
  306.         _ASSERT(sizeof(TEnumValueType) == sizeof(value));
  307.         TEnumValueType v = TEnumValueType(value);
  308.         if ( v < 0 ) {
  309.             NCBI_THROW(CSerialException,eOverflow,"overflow error");
  310.         }
  311.         Values().FindName(v, false);
  312.     }
  313.     m_ValueType->SetValueUint4(objectPtr, value);
  314. }
  315. Int8 CEnumeratedTypeInfo::GetValueInt8(TConstObjectPtr objectPtr) const
  316. {
  317.     return m_ValueType->GetValueInt8(objectPtr);
  318. }
  319. Uint8 CEnumeratedTypeInfo::GetValueUint8(TConstObjectPtr objectPtr) const
  320. {
  321.     return m_ValueType->GetValueUint8(objectPtr);
  322. }
  323. void CEnumeratedTypeInfo::SetValueInt8(TObjectPtr objectPtr, Int8 value) const
  324. {
  325.     if ( !Values().IsInteger() ) {
  326.         // check value for acceptance
  327.         _ASSERT(sizeof(TEnumValueType) < sizeof(value));
  328.         TEnumValueType v = TEnumValueType(value);
  329.         if ( v != value )
  330.             NCBI_THROW(CSerialException,eOverflow,"overflow error");
  331.         Values().FindName(v, false);
  332.     }
  333.     m_ValueType->SetValueInt8(objectPtr, value);
  334. }
  335. void CEnumeratedTypeInfo::SetValueUint8(TObjectPtr objectPtr,
  336.                                         Uint8 value) const
  337. {
  338.     if ( !Values().IsInteger() ) {
  339.         // check value for acceptance
  340.         _ASSERT(sizeof(TEnumValueType) < sizeof(value));
  341.         TEnumValueType v = TEnumValueType(value);
  342.         if ( v < 0 || Uint8(v) != value )
  343.             NCBI_THROW(CSerialException,eOverflow,"overflow error");
  344.         Values().FindName(v, false);
  345.     }
  346.     m_ValueType->SetValueUint8(objectPtr, value);
  347. }
  348. void CEnumeratedTypeInfo::GetValueString(TConstObjectPtr objectPtr,
  349.                                          string& value) const
  350. {
  351.     value = Values().FindName(m_ValueType->GetValueInt(objectPtr), false);
  352. }
  353. void CEnumeratedTypeInfo::SetValueString(TObjectPtr objectPtr,
  354.                                          const string& value) const
  355. {
  356.     m_ValueType->SetValueInt(objectPtr, Values().FindValue(value));
  357. }
  358. TObjectPtr CEnumeratedTypeInfo::CreateEnum(TTypeInfo objectType)
  359. {
  360.     const CEnumeratedTypeInfo* enumType =
  361.         CTypeConverter<CEnumeratedTypeInfo>::SafeCast(objectType);
  362.     return enumType->m_ValueType->Create();
  363. }
  364. void CEnumeratedTypeInfo::ReadEnum(CObjectIStream& in,
  365.                                    TTypeInfo objectType,
  366.                                    TObjectPtr objectPtr)
  367. {
  368.     const CEnumeratedTypeInfo* enumType =
  369.         CTypeConverter<CEnumeratedTypeInfo>::SafeCast(objectType);
  370.     try {
  371.         enumType->m_ValueType->SetValueInt(objectPtr,
  372.                                            in.ReadEnum(enumType->Values()));
  373.     }
  374.     catch ( CException& e ) {
  375.         NCBI_RETHROW_SAME(e,"invalid enum value");
  376.     }
  377.     catch ( ... ) {
  378.         in.ThrowError(in.fFormatError,"invalid enum value");
  379.     }
  380. }
  381. void CEnumeratedTypeInfo::WriteEnum(CObjectOStream& out,
  382.                                     TTypeInfo objectType,
  383.                                     TConstObjectPtr objectPtr)
  384. {
  385.     const CEnumeratedTypeInfo* enumType =
  386.         CTypeConverter<CEnumeratedTypeInfo>::SafeCast(objectType);
  387.     try {
  388.         out.WriteEnum(enumType->Values(),
  389.                       enumType->m_ValueType->GetValueInt(objectPtr));
  390.     }
  391.     catch ( CException& e ) {
  392.         NCBI_RETHROW_SAME(e,"invalid enum value");
  393.     }
  394.     catch ( ... ) {
  395.         out.ThrowError(out.fInvalidData,"invalid enum value");
  396.     }
  397. }
  398. void CEnumeratedTypeInfo::CopyEnum(CObjectStreamCopier& copier,
  399.                                    TTypeInfo objectType)
  400. {
  401.     const CEnumeratedTypeInfo* enumType =
  402.         CTypeConverter<CEnumeratedTypeInfo>::SafeCast(objectType);
  403.     try {
  404.         copier.Out().CopyEnum(enumType->Values(), copier.In());
  405.     }
  406.     catch ( CException& e ) {
  407.         NCBI_RETHROW_SAME(e,"invalid enum value");
  408.     }
  409.     catch ( ... ) {
  410.         copier.ThrowError(CObjectIStream::fFormatError,"invalid enum value");
  411.     }
  412. }
  413. void CEnumeratedTypeInfo::SkipEnum(CObjectIStream& in,
  414.                                    TTypeInfo objectType)
  415. {
  416.     const CEnumeratedTypeInfo* enumType =
  417.         CTypeConverter<CEnumeratedTypeInfo>::SafeCast(objectType);
  418.     try {
  419.         in.ReadEnum(enumType->Values());
  420.     }
  421.     catch ( CException& e ) {
  422.         NCBI_RETHROW_SAME(e,"invalid enum value");
  423.     }
  424.     catch ( ... ) {
  425.         in.ThrowError(in.fFormatError,"invalid enum value");
  426.     }
  427. }
  428. END_NCBI_SCOPE