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

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

生物技术

开发平台：

C/C++

types.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: types.hpp,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 20:19:16  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.17
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef DBAPI_DRIVER___TYPES__HPP
  11. #define DBAPI_DRIVER___TYPES__HPP
  13. /* $Id: types.hpp,v 1000.0 2003/10/29 20:19:16 gouriano Exp $
  14.  * ===========================================================================
  15.  *
  16.  *                            PUBLIC DOMAIN NOTICE
  17.  *               National Center for Biotechnology Information
  18.  *
  19.  *  This software/database is a "United States Government Work" under the
  20.  *  terms of the United States Copyright Act.  It was written as part of
  21.  *  the author's official duties as a United States Government employee and
  22.  *  thus cannot be copyrighted.  This software/database is freely available
  23.  *  to the public for use. The National Library of Medicine and the U.S.
  24.  *  Government have not placed any restriction on its use or reproduction.
  25.  *
  26.  *  Although all reasonable efforts have been taken to ensure the accuracy
  27.  *  and reliability of the software and data, the NLM and the U.S.
  28.  *  Government do not and cannot warrant the performance or results that
  29.  *  may be obtained by using this software or data. The NLM and the U.S.
  30.  *  Government disclaim all warranties, express or implied, including
  31.  *  warranties of performance, merchantability or fitness for any particular
  32.  *  purpose.
  33.  *
  34.  *  Please cite the author in any work or product based on this material.
  35.  *
  36.  * ===========================================================================
  37.  *
  38.  * Author:  Vladimir Soussov
  39.  *
  40.  * File Description:  DB types
  41.  *
  42.  */
  45. #include <corelib/ncbitime.hpp>
  46. #include <corelib/ncbi_limits.h>
  49. /** @addtogroup DbTypes
  50.  *
  51.  * @{
  52.  */
  55. BEGIN_NCBI_SCOPE
  58. // Set of supported types
  59. //
  61. enum EDB_Type {
  62.     eDB_Int,
  63.     eDB_SmallInt,
  64.     eDB_TinyInt,
  65.     eDB_BigInt,
  66.     eDB_VarChar,
  67.     eDB_Char,
  68.     eDB_VarBinary,
  69.     eDB_Binary,
  70.     eDB_Float,
  71.     eDB_Double,
  72.     eDB_DateTime,
  73.     eDB_SmallDateTime,
  74.     eDB_Text,
  75.     eDB_Image,
  76.     eDB_Bit,
  77.     eDB_Numeric,
  79.     eDB_UnsupportedType,
  80. eDB_LongChar,
  81. eDB_LongBinary
  82. };
  86. /////////////////////////////////////////////////////////////////////////////
  87. //
  88. //  CDB_Object::
  89. //
  90. // Base class for all "type objects" to support database NULL value
  91. // and provide the means to get the type and to clone the object.
  92. //
  94. class NCBI_DBAPIDRIVER_EXPORT CDB_Object
  95. {
  96. public:
  97.     CDB_Object(bool is_null = true) : m_Null(is_null)  { return; }
  98.     virtual ~CDB_Object();
  100.     bool IsNULL() const  { return m_Null; }
  101.     virtual void AssignNULL();
  103.     virtual EDB_Type    GetType() const = 0;
  104.     virtual CDB_Object* Clone()   const = 0;
  105.     virtual void AssignValue(CDB_Object& v)= 0;
  107.     // Create and return a new object (with internal value NULL) of type "type".
  108.     // NOTE:  "size" matters only for eDB_Char, eDB_Binary, eDB_LongChar, eDB_LongBinary.
  109.     static CDB_Object* Create(EDB_Type type, size_t size = 1);
  111. protected:
  112.     bool m_Null;
  113. };
  117. /////////////////////////////////////////////////////////////////////////////
  118. //
  119. //  CDB_Int::
  120. //  CDB_SmallInt::
  121. //  CDB_TinyInt::
  122. //  CDB_BigInt::
  123. //  CDB_VarChar::
  124. //  CDB_Char::
  125. //  CDB_VarBinary::
  126. //  CDB_Binary::
  127. //  CDB_Float::
  128. //  CDB_Double::
  129. //  CDB_Stream::
  130. //  CDB_Image::
  131. //  CDB_Text::
  132. //  CDB_SmallDateTime::
  133. //  CDB_DateTime::
  134. //  CDB_Bit::
  135. //  CDB_Numeric::
  136. //
  137. // Classes to represent objects of different types (derived from CDB_Object::)
  138. //
  141. class NCBI_DBAPIDRIVER_EXPORT CDB_Int : public CDB_Object
  142. {
  143. public:
  144.     CDB_Int()              : CDB_Object(true)             { return; }
  145.     CDB_Int(const Int4& i) : CDB_Object(false), m_Val(i)  { return; }
  147.     CDB_Int& operator= (const Int4& i) {
  148.         m_Null = false;
  149.         m_Val  = i;
  150.         return *this;
  151.     }
  153.     Int4  Value()   const  { return m_Null ? 0 : m_Val; }
  154.     void* BindVal() const  { return (void*) &m_Val; }
  156.     virtual EDB_Type    GetType() const;
  157.     virtual CDB_Object* Clone() const;
  158.     virtual void AssignValue(CDB_Object& v);
  160. protected:
  161.     Int4 m_Val;
  162. };
  166. class NCBI_DBAPIDRIVER_EXPORT CDB_SmallInt : public CDB_Object
  167. {
  168. public:
  169.     CDB_SmallInt()              : CDB_Object(true)             { return; }
  170.     CDB_SmallInt(const Int2& i) : CDB_Object(false), m_Val(i)  { return; }
  172.     CDB_SmallInt& operator= (const Int2& i) {
  173.         m_Null = false;
  174.         m_Val = i;
  175.         return *this;
  176.     }
  178.     Int2  Value()   const  { return m_Null ? 0 : m_Val; }
  179.     void* BindVal() const  { return (void*) &m_Val; }
  181.     virtual EDB_Type    GetType() const;
  182.     virtual CDB_Object* Clone() const;
  183.     virtual void AssignValue(CDB_Object& v);
  185. protected:
  186.     Int2 m_Val;
  187. };
  191. class NCBI_DBAPIDRIVER_EXPORT CDB_TinyInt : public CDB_Object
  192. {
  193. public:
  194.     CDB_TinyInt()               : CDB_Object(true)             { return; }
  195.     CDB_TinyInt(const Uint1& i) : CDB_Object(false), m_Val(i)  { return; }
  197.     CDB_TinyInt& operator= (const Uint1& i) {
  198.         m_Null = false;
  199.         m_Val = i;
  200.         return *this;
  201.     }
  203.     Uint1 Value()   const  { return m_Null ? 0 : m_Val; }
  204.     void* BindVal() const  { return (void*) &m_Val; }
  206.     virtual EDB_Type    GetType() const;
  207.     virtual CDB_Object* Clone()   const;
  208.     virtual void AssignValue(CDB_Object& v);
  210. protected:
  211.     Uint1 m_Val;
  212. };
  216. class NCBI_DBAPIDRIVER_EXPORT CDB_BigInt : public CDB_Object
  217. {
  218. public:
  219.     CDB_BigInt()              : CDB_Object(true)             { return; }
  220.     CDB_BigInt(const Int8& i) : CDB_Object(false), m_Val(i)  { return; }
  222.     CDB_BigInt& operator= (const Int8& i) {
  223.         m_Null = false;
  224.         m_Val = i;
  225.         return *this;
  226.     }
  228.     Int8 Value() const  { return m_Null ? 0 : m_Val; }
  229.     void* BindVal() const  { return (void*) &m_Val; }
  232.     virtual EDB_Type    GetType() const;
  233.     virtual CDB_Object* Clone()   const;
  234.     virtual void AssignValue(CDB_Object& v);
  236. protected:
  237.     Int8 m_Val;
  238. };
  241. class NCBI_DBAPIDRIVER_EXPORT CDB_VarChar : public CDB_Object
  242. {
  243. public:
  244.     // constructors
  245.     CDB_VarChar()                           : CDB_Object(true)  { return; }
  246.     CDB_VarChar(const string& s)            { SetValue(s); }
  247.     CDB_VarChar(const char*   s)            { SetValue(s); }
  248.     CDB_VarChar(const char*   s, size_t l)  { SetValue(s, l); }
  250.     // assignment operators
  251.     CDB_VarChar& operator= (const string& s)  { return SetValue(s); }
  252.     CDB_VarChar& operator= (const char*   s)  { return SetValue(s); }
  254.     // set-value methods
  255.     CDB_VarChar& SetValue(const string& s) {
  256.         m_Null = false;
  257.         m_Size = s.copy(m_Val, sizeof(m_Val) - 1);
  258.         m_Val[m_Size] = '';
  259.         return *this;
  260.     }
  261.     CDB_VarChar& SetValue(const char* s) {
  262.         if ( s ) {
  263.             for (m_Size = 0;  (m_Size < sizeof(m_Val) - 1)  &&  (*s != '');
  264.                  ++s) {
  265.                 m_Val[m_Size++] = *s;
  266.             }
  267.             m_Val[m_Size] = '';
  268.             m_Null = false;
  269.         }
  270.         else {
  271.             m_Null = true;
  272.         }
  273.         return *this;
  274.     }
  275.     CDB_VarChar& SetValue(const char* s, size_t l) {
  276.         if ( s ) {
  277.             m_Size = l < sizeof(m_Val) ? l : sizeof(m_Val) - 1;
  278.             if ( m_Size ) {
  279.                 memcpy(m_Val, s, m_Size);
  280.             }
  281.             m_Val[m_Size] = '';
  282.             m_Null = false;
  283.         }
  284.         else {
  285.             m_Null = true;
  286.         }
  287.         return *this;
  288.     }
  290.     //
  291.     const char* Value() const  { return m_Null ? 0 : m_Val;  }
  292.     size_t      Size()  const  { return m_Null ? 0 : m_Size; }
  294.     virtual EDB_Type    GetType() const;
  295.     virtual CDB_Object* Clone()   const;
  296.     virtual void AssignValue(CDB_Object& v);
  298. protected:
  299.     size_t m_Size;
  300.     char   m_Val[256];
  301. };
  305. class NCBI_DBAPIDRIVER_EXPORT CDB_Char : public CDB_Object
  306. {
  307. public:
  308.     enum { kMaxCharSize = 255 };
  310.     CDB_Char(size_t s = 1) : CDB_Object(true) {
  311.         m_Size = (s < 1) ? 1 : (s > kMaxCharSize ? kMaxCharSize : s);
  312.         m_Val  = new char[m_Size + 1];
  313.         memset(m_Val, ' ', m_Size);
  314.         m_Val[m_Size] = '';
  315.     }
  317.     CDB_Char(size_t s, const string& v) :  CDB_Object(false) {
  318.         m_Size = (s < 1) ? 1 : (s > kMaxCharSize ? kMaxCharSize : s);
  319.         m_Val = new char[m_Size + 1];
  320.         size_t l = v.copy(m_Val, m_Size);
  321.         if (l < m_Size) {
  322.             memset(m_Val + l, ' ', m_Size - l);
  323.         }
  324.         m_Val[m_Size] = '';
  325.     }
  327.     CDB_Char(size_t len, const char* str) :  CDB_Object(str == 0) {
  328.         m_Size = (len < 1) ? 1 : (len > kMaxCharSize ? kMaxCharSize : len);
  329.         m_Val = new char[m_Size + 1];
  331.         if ( str ) {
  332.             size_t l;
  333.             for (l = 0;  (l < m_Size)  &&  (*str != '');  ++str) {
  334.                 m_Val[l++] = *str;
  335.             }
  336.             if (l < m_Size) {
  337.                 memset(m_Val + l, ' ', m_Size - l);
  338.             }
  339.         } else {
  340.             memset(m_Val, ' ', m_Size);
  341.         }
  343.         m_Val[m_Size] = '';
  344.     }
  346.     CDB_Char(const CDB_Char& v) {
  347.         m_Null = v.m_Null;
  348.         m_Size = v.m_Size;
  349.         m_Val = new char[m_Size + 1];
  350.         memcpy(m_Val, v.m_Val, m_Size + 1);
  351.     }
  354.     CDB_Char& operator= (const CDB_Char& v) {
  355.         m_Null = v.m_Null;
  356.         size_t l = (m_Size > v.m_Size) ? v.m_Size : m_Size;
  357.         memmove(m_Val, v.m_Val, l);
  358.         if (l < m_Size)
  359.             memset(m_Val + l, ' ', m_Size - l);
  360.         return *this;
  361.     }
  363.     CDB_Char& operator= (const string& v) {
  364.         m_Null = false;
  365.         size_t l = v.copy(m_Val, m_Size);
  366.         if (l < m_Size)
  367.             memset(m_Val + l, ' ', m_Size - l);
  368.         return *this;
  369.     }
  371.     CDB_Char& operator= (const char* v) {
  372.         if (v == 0) {
  373.             m_Null = true;
  374.         }
  375.         else {
  376.             m_Null = false;
  377.             size_t l;
  379.             for (l = 0;  (l < m_Size)  &&  (*v != '');  ++v) {
  380.                 m_Val[l++] = *v;
  381.             }
  382.             if (l < m_Size)
  383.                 memset(m_Val + l, ' ', m_Size - l);
  384.         }
  385.         return *this;
  386.     }
  388.     void SetValue(const char* str, size_t len) {
  389.         if ( str ) {
  390.             if (len >= m_Size) {
  391.                 memcpy(m_Val, str, m_Size);
  392.             }
  393.             else {
  394.                 if ( len ) {
  395.                     memcpy(m_Val, str, len);
  396.                 }
  397.                 memset(m_Val + len, ' ', m_Size - len);
  398.             }
  399.             m_Null = false;
  400.         }
  401.         else {
  402.             m_Null = true;
  403.         }
  404.     }
  406.     const char* Value() const  { return m_Null ? 0 : m_Val; }
  407.     size_t      Size()  const  { return m_Size; }
  409.     virtual EDB_Type    GetType() const;
  410.     virtual CDB_Object* Clone()   const;
  412.     virtual void AssignValue(CDB_Object& v);
  413.     virtual ~CDB_Char();
  415. protected:
  416.     size_t m_Size;
  417.     char*  m_Val;
  418. };
  420. #define K8_1 8191
  422. class NCBI_DBAPIDRIVER_EXPORT CDB_LongChar : public CDB_Object
  423. {
  424. public:
  426.     CDB_LongChar(size_t s = K8_1) : CDB_Object(true) {
  427.         m_Size = (s < 1) ? 1 : s;
  428.         m_Val  = new char[m_Size + 1];
  429.     }
  431.     CDB_LongChar(size_t s, const string& v) :  CDB_Object(false) {
  432.         m_Size = (s < 1) ? K8_1 : s;
  433.         m_Val = new char[m_Size + 1];
  434.         size_t l = v.copy(m_Val, m_Size);
  435.         m_Val[l] = '';
  436.     }
  438.     CDB_LongChar(size_t len, const char* str) :  CDB_Object(str == 0) {
  439.         m_Size = (len < 1) ? K8_1 : len;
  440.         m_Val = new char[m_Size + 1];
  442. if(str) strncpy(m_Val, str, m_Size);
  443.         m_Val[m_Size] = '';
  444.     }
  446.     CDB_LongChar(const CDB_LongChar& v) {
  447.         m_Null = v.m_Null;
  448.         m_Size = v.m_Size;
  449.         m_Val = new char[m_Size + 1];
  450.         memcpy(m_Val, v.m_Val, m_Size + 1);
  451.     }
  454.     CDB_LongChar& operator= (const CDB_LongChar& v) {
  455.         m_Null = v.m_Null;
  456.         size_t l = (m_Size > v.m_Size) ? v.m_Size : m_Size;
  457.         memmove(m_Val, v.m_Val, l);
  458. m_Val[l]= '';
  459.         return *this;
  460.     }
  462.     CDB_LongChar& operator= (const string& v) {
  463.         m_Null = false;
  464.         size_t l = v.copy(m_Val, m_Size);
  465. m_Val[l]= '';
  466.         return *this;
  467.     }
  469.     CDB_LongChar& operator= (const char* v) {
  470.         if (v == 0) {
  471.             m_Null = true;
  472.         }
  473.         else {
  474.             m_Null = false;
  475.             size_t l;
  477.             for (l = 0;  (l < m_Size)  &&  (*v != '');  ++v) {
  478.                 m_Val[l++] = *v;
  479.             }
  480. m_Val[l]= '';
  481.         }
  482.         return *this;
  483.     }
  485.     void SetValue(const char* str, size_t len) {
  486.         if ( str ) {
  487.             if (len >= m_Size) {
  488.                 memcpy(m_Val, str, m_Size);
  489. m_Val[m_Size]= '';
  490.             }
  491.             else {
  492.                 if ( len ) {
  493.                     memcpy(m_Val, str, len);
  494.                 }
  495.                 m_Val[len]= '';
  496.             }
  497.             m_Null = false;
  498.         }
  499.         else {
  500.     m_Null = true;
  501.         }
  502.     }
  504.     const char* Value() const  { return m_Null ? 0 : m_Val; }
  505.     size_t      Size()  const  { return m_Size; }
  506.     size_t  DataSize()  const  { return m_Null? 0 : strlen(m_Val); }
  508.     virtual EDB_Type    GetType() const;
  509.     virtual CDB_Object* Clone()   const;
  511.     virtual void AssignValue(CDB_Object& v);
  512.     virtual ~CDB_LongChar();
  514. protected:
  515.     size_t m_Size;
  516.     char*  m_Val;
  517. };
  521. class NCBI_DBAPIDRIVER_EXPORT CDB_VarBinary : public CDB_Object
  522. {
  523. public:
  524.     CDB_VarBinary()                         : CDB_Object(true)  { return; }
  525.     CDB_VarBinary(const void* v, size_t l)  { SetValue(v, l); }
  527.     void SetValue(const void* v, size_t l) {
  528.         if (v  &&  l) {
  529.             m_Size = l > sizeof(m_Val) ? sizeof(m_Val) : l;
  530.             memcpy(m_Val, v, m_Size);
  531.             m_Null = false;
  532.         }
  533.         else {
  534.             m_Null = true;
  535.         }
  536.     }
  538.     //
  539.     const void* Value() const  { return m_Null ? 0 : (void*) m_Val; }
  540.     size_t      Size()  const  { return m_Null ? 0 : m_Size; }
  542.     virtual EDB_Type    GetType() const;
  543.     virtual CDB_Object* Clone()   const;
  544.     virtual void AssignValue(CDB_Object& v);
  546. protected:
  547.     size_t        m_Size;
  548.     unsigned char m_Val[255];
  549. };
  553. class NCBI_DBAPIDRIVER_EXPORT CDB_Binary : public CDB_Object
  554. {
  555. public:
  556.     enum { kMaxBinSize = 255 };
  558.     CDB_Binary(size_t s = 1) : CDB_Object(true) {
  559.         m_Size = (s < 1) ? 1 : (s > kMaxBinSize ? kMaxBinSize : s);
  560.         m_Val = new unsigned char[m_Size];
  561.         memset(m_Val, 0, m_Size);
  562.     }
  564.     CDB_Binary(size_t s, const void* v, size_t v_size) {
  565.         m_Size = (s == 0) ? 1 : (s > kMaxBinSize ? kMaxBinSize : s);
  566.         m_Val  = new unsigned char[m_Size];
  567.         SetValue(v, v_size);
  568.     }
  570.     CDB_Binary(const CDB_Binary& v) {
  571.         m_Null = v.m_Null;
  572.         m_Size = v.m_Size;
  573.         m_Val = new unsigned char[m_Size];
  574.         memcpy(m_Val, v.m_Val, m_Size);
  575.     }
  577.     void SetValue(const void* v, size_t v_size) {
  578.         if (v  &&  v_size) {
  579.             memcpy(m_Val, v, (v_size > m_Size) ? m_Size : v_size);
  580.             if (v_size < m_Size) {
  581.                 memset(m_Val + v_size, 0, m_Size - v_size);
  582.             }
  583.             m_Null = false;
  584.         } else {
  585.             m_Null = true;
  586.         }
  587.     }
  589.     CDB_Binary& operator= (const CDB_Binary& v) {
  590.         m_Null = v.m_Null;
  591.         size_t l = (m_Size > v.m_Size) ? v.m_Size : m_Size;
  592.         memmove(m_Val, v.m_Val, l);
  593.         if (l < m_Size) {
  594.             memset(m_Val+l, 0, m_Size - l);
  595.         }
  596.         return *this;
  597.     }
  599.     //
  600.     const void* Value() const  { return m_Null ? 0 : (void*) m_Val; }
  601.     size_t      Size()  const  { return m_Size; }
  603.     virtual EDB_Type    GetType() const;
  604.     virtual CDB_Object* Clone()   const;
  606.     virtual void AssignValue(CDB_Object& v);
  607.     virtual ~CDB_Binary();
  609. protected:
  610.     size_t         m_Size;
  611.     unsigned char* m_Val;
  612. };
  614. class NCBI_DBAPIDRIVER_EXPORT CDB_LongBinary : public CDB_Object
  615. {
  616. public:
  618.     CDB_LongBinary(size_t s = K8_1) : CDB_Object(true) {
  619.         m_Size = (s < 1) ? 1 : s;
  620.         m_Val = new unsigned char[m_Size];
  621. m_DataSize= 0;
  622.     }
  624.     CDB_LongBinary(size_t s, const void* v, size_t v_size) {
  625.         m_Size = (s == 0) ? K8_1 : s;
  626.         m_Val  = new unsigned char[m_Size];
  627.         SetValue(v, v_size);
  628.     }
  630.     CDB_LongBinary(const CDB_LongBinary& v) {
  631.         m_Null = v.m_Null;
  632.         m_Size = v.m_Size;
  633. m_DataSize= v.m_DataSize;
  634.         m_Val = new unsigned char[m_Size];
  635.         memcpy(m_Val, v.m_Val, m_DataSize);
  636.     }
  638.     void SetValue(const void* v, size_t v_size) {
  639.         if (v  &&  v_size) {
  640.     m_DataSize= (v_size > m_Size) ? m_Size : v_size;
  641.             memcpy(m_Val, v, m_DataSize);
  642.             m_Null = false;
  643.         } else {
  644.             m_Null = true;
  645. m_DataSize= 0;
  646.         }
  647.     }
  649.     CDB_LongBinary& operator= (const CDB_LongBinary& v) {
  650.         m_Null = v.m_Null;
  651.         m_DataSize = (m_Size > v.m_DataSize) ? v.m_DataSize : m_Size;
  652. if(m_DataSize) {
  653.     memmove(m_Val, v.m_Val, m_DataSize);
  654. }
  655.         return *this;
  656.     }
  658.     //
  659.     const void* Value() const  { return m_Null ? 0 : (void*) m_Val; }
  660.     size_t      Size()  const  { return m_Size; }
  661.     size_t  DataSize()  const  { return m_DataSize; }
  663.     virtual EDB_Type    GetType() const;
  664.     virtual CDB_Object* Clone()   const;
  666.     virtual void AssignValue(CDB_Object& v);
  667.     virtual ~CDB_LongBinary();
  669. protected:
  670.     size_t         m_Size;
  671.     size_t         m_DataSize;
  672.     unsigned char* m_Val;
  673. };
  676. class NCBI_DBAPIDRIVER_EXPORT CDB_Float : public CDB_Object
  677. {
  678. public:
  679.     CDB_Float()        : CDB_Object(true)             { return; }
  680.     CDB_Float(float i) : CDB_Object(false), m_Val(i)  { return; }
  682.     CDB_Float& operator= (const float& i) {
  683.         m_Null = false;
  684.         m_Val  = i;
  685.         return *this;
  686.     }
  688.     float Value()   const { return m_Null ? 0 : m_Val; }
  689.     void* BindVal() const { return (void*) &m_Val; }
  691.     virtual EDB_Type    GetType() const;
  692.     virtual CDB_Object* Clone()   const;
  693.     virtual void AssignValue(CDB_Object& v);
  695. protected:
  696.     float m_Val;
  697. };
  701. class NCBI_DBAPIDRIVER_EXPORT CDB_Double : public CDB_Object
  702. {
  703. public:
  704.     CDB_Double()         : CDB_Object(true)             { return; }
  705.     CDB_Double(double i) : CDB_Object(false), m_Val(i)  { return; }
  707.     CDB_Double& operator= (const double& i) {
  708.         m_Null = false;
  709.         m_Val  = i;
  710.         return *this;
  711.     }
  713.     //
  714.     double Value()   const  { return m_Null ? 0 : m_Val; }
  715.     void*  BindVal() const  { return (void*) &m_Val; }
  717.     virtual EDB_Type    GetType() const;
  718.     virtual CDB_Object* Clone()   const;
  719.     virtual void AssignValue(CDB_Object& v);
  721. protected:
  722.     double m_Val;
  723. };
  726. class CMemStore;
  729. class NCBI_DBAPIDRIVER_EXPORT CDB_Stream : public CDB_Object
  730. {
  731. public:
  732.     // assignment
  733.     virtual void AssignNULL();
  734.     CDB_Stream&  Assign(const CDB_Stream& v);
  736.     // data manipulations
  737.     virtual size_t Read     (void* buff, size_t nof_bytes);
  738.     virtual size_t Append   (const void* buff, size_t nof_bytes);
  739.     virtual void   Truncate (size_t nof_bytes = kMax_Int);
  740.     virtual bool   MoveTo   (size_t byte_number);
  742.     // current size of data
  743.     virtual size_t Size() const;
  744.     virtual void AssignValue(CDB_Object& v);
  746. protected:
  747.     // 'ctors
  748.     CDB_Stream();
  749.     virtual ~CDB_Stream();
  751. private:
  752.     // data storage
  753.     CMemStore* m_Store;
  754. };
  758. class NCBI_DBAPIDRIVER_EXPORT CDB_Image : public CDB_Stream
  759. {
  760. public:
  761.     CDB_Image& operator= (const CDB_Image& image);
  763.     virtual EDB_Type    GetType() const;
  764.     virtual CDB_Object* Clone()   const;
  765. };
  769. class NCBI_DBAPIDRIVER_EXPORT CDB_Text : public CDB_Stream
  770. {
  771. public:
  772.     virtual size_t Append(const void* buff, size_t nof_bytes = 0/*strlen*/);
  773.     virtual size_t Append(const string& s);
  775.     CDB_Text& operator= (const CDB_Text& text);
  777.     virtual EDB_Type    GetType() const;
  778.     virtual CDB_Object* Clone()   const;
  779. };
  783. class NCBI_DBAPIDRIVER_EXPORT CDB_SmallDateTime : public CDB_Object
  784. {
  785. public:
  786.     CDB_SmallDateTime(CTime::EInitMode mode= CTime::eEmpty)
  787.   : m_NCBITime(mode) {
  788.         m_Status = 0x1;
  789.     }
  790.     CDB_SmallDateTime(const CTime& t) {
  791.         m_NCBITime = t;
  792.         m_Status   = 0x1;
  793.         m_Null     = false;
  794.     }
  795.     CDB_SmallDateTime(Uint2 days, Uint2 minutes) {
  796.         m_DBTime.days = days;
  797.         m_DBTime.time = minutes;
  798.         m_Status      = 0x2;
  799.         m_Null        = false;
  800.     }
  802.     CDB_SmallDateTime& Assign(Uint2 days, Uint2 minutes) {
  803.         m_DBTime.days = days;
  804.         m_DBTime.time = minutes;
  805.         m_Status      = 0x2;
  806.         m_Null        = false;
  807.         return *this;
  808.     }
  810.     CDB_SmallDateTime& operator= (const CTime& t) {
  811.         m_NCBITime = t;
  812.         m_Status = 0x1;
  813.         m_Null= false;
  814.         return *this;
  815.     }
  817.     const CTime& Value() const {
  818.         if((m_Status & 0x1) == 0) {
  819.             m_NCBITime.SetTimeDBU(m_DBTime);
  820.             m_Status |= 0x1;
  821.         }
  822.         return m_NCBITime;
  823.     }
  825.     Uint2 GetDays() const {
  826.         if((m_Status & 0x2) == 0) {
  827.             m_DBTime = m_NCBITime.GetTimeDBU();
  828.             m_Status |= 0x2;
  829.         }
  830.         return m_DBTime.days;
  831.     }
  833.     Uint2 GetMinutes() const {
  834.         if((m_Status & 0x2) == 0) {
  835.             m_DBTime = m_NCBITime.GetTimeDBU();
  836.             m_Status |= 0x2;
  837.         }
  838.         return m_DBTime.time;
  839.     }
  841.     virtual EDB_Type    GetType() const;
  842.     virtual CDB_Object* Clone()   const;
  843.     virtual void AssignValue(CDB_Object& v);
  845. protected:
  846.     mutable CTime        m_NCBITime;
  847.     mutable TDBTimeU     m_DBTime;
  848.     // which of m_NCBITime(0x1), m_DBTime(0x2) is valid;  they both can be valid
  849.     mutable unsigned int m_Status;
  850. };
  854. class NCBI_DBAPIDRIVER_EXPORT CDB_DateTime : public CDB_Object
  855. {
  856. public:
  857.     CDB_DateTime(CTime::EInitMode mode= CTime::eEmpty)
  858.   : m_NCBITime(mode) {
  859.         m_Status = 0x1;
  860.     }
  861.     CDB_DateTime(const CTime& t) {
  862.         m_NCBITime = t;
  863.         m_Status = 0x1;
  864.         m_Null= false;
  865.     }
  866.     CDB_DateTime(Int4 d, Int4 s300) {
  867.         m_DBTime.days = d;
  868.         m_DBTime.time = s300;
  869.         m_Status = 0x2;
  870.         m_Null= false;
  871.     }
  873.     CDB_DateTime& operator= (const CTime& t) {
  874.         m_NCBITime = t;
  875.         m_Status = 0x1;
  876.         m_Null= false;
  877.         return *this;
  878.     }
  880.     CDB_DateTime& Assign(Int4 d, Int4 s300) {
  881.         m_DBTime.days = d;
  882.         m_DBTime.time = s300;
  883.         m_Status = 0x2;
  884.         m_Null = false;
  885.         return *this;
  886.     }
  888.     const CTime& Value() const {
  889.         if((m_Status & 0x1) == 0) {
  890.             m_NCBITime.SetTimeDBI(m_DBTime);
  891.             m_Status |= 0x1;
  892.         }
  893.         return m_NCBITime;
  894.     }
  896.     Int4 GetDays() const {
  897.         if((m_Status & 0x2) == 0) {
  898.             m_DBTime = m_NCBITime.GetTimeDBI();
  899.             m_Status |= 0x2;
  900.         }
  901.         return m_DBTime.days;
  902.     }
  904.     Int4 Get300Secs() const {
  905.         if((m_Status & 0x2) == 0) {
  906.             m_DBTime = m_NCBITime.GetTimeDBI();
  907.             m_Status |= 0x2;
  908.         }
  909.         return m_DBTime.time;
  910.     }
  912.     virtual EDB_Type    GetType() const;
  913.     virtual CDB_Object* Clone()   const;
  914.     virtual void AssignValue(CDB_Object& v);
  916. protected:
  917.     mutable CTime        m_NCBITime;
  918.     mutable TDBTimeI     m_DBTime;
  919.     // which of m_NCBITime(0x1), m_DBTime(0x2) is valid;  they both can be valid
  920.     mutable unsigned int m_Status;
  921. };
  925. class NCBI_DBAPIDRIVER_EXPORT CDB_Bit : public CDB_Object
  926. {
  927. public:
  928.     CDB_Bit()       : CDB_Object(true)   { return; }
  929.     CDB_Bit(int  i) : CDB_Object(false)  { m_Val = i ? 1 : 0; }
  930.     CDB_Bit(bool i) : CDB_Object(false)  { m_Val = i ? 1 : 0; }
  932.     CDB_Bit& operator= (const int& i) {
  933.         m_Null = false;
  934.         m_Val = i ? 1 : 0;
  935.         return *this;
  936.     }
  938.     CDB_Bit& operator= (const bool& i) {
  939.         m_Null = false;
  940.         m_Val = i ? 1 : 0;
  941.         return *this;
  942.     }
  944.     int   Value()   const  { return m_Null ? 0 : (int) m_Val; }
  945.     void* BindVal() const  { return (void*) &m_Val; }
  947.     virtual EDB_Type    GetType() const;
  948.     virtual CDB_Object* Clone()   const;
  949.     virtual void AssignValue(CDB_Object& v);
  951. protected:
  952.     Uint1 m_Val;
  953. };
  957. class NCBI_DBAPIDRIVER_EXPORT CDB_Numeric : public CDB_Object
  958. {
  959. public:
  960.     CDB_Numeric() : CDB_Object(true)  { m_Precision= m_Scale= 0; return; }
  961.     CDB_Numeric(unsigned int precision, unsigned int scale)
  962.         : CDB_Object(false) {
  963.         m_Precision = precision;
  964.         m_Scale     = scale;
  965.         memset(m_Body, 0, sizeof(m_Body));
  966.     }
  967.     CDB_Numeric(unsigned int precision, unsigned int scale,
  968.                 const unsigned char* arr)
  969.         : CDB_Object(false) {
  970.         m_Precision = precision;
  971.         m_Scale     = scale;
  972.         memcpy(m_Body, arr, sizeof(m_Body));
  973.     }
  975.     CDB_Numeric(unsigned int precision, unsigned int scale, bool is_negative,
  976.                 const unsigned char* arr)
  977.         : CDB_Object(false) {
  978.         m_Precision = precision;
  979.         m_Scale     = scale;
  980.         m_Body[0]= is_negative? 1 : 0;
  981.         memcpy(m_Body+1, arr, sizeof(m_Body)-1);
  982.     }
  984.     CDB_Numeric(unsigned int precision, unsigned int scale, const char* val) {
  985.         x_MakeFromString(precision, scale, val);
  986.     }
  987.     CDB_Numeric(unsigned int precision, unsigned int scale, const string& val) {
  988.         x_MakeFromString(precision, scale, val.c_str());
  989.     }
  991.     CDB_Numeric& Assign(unsigned int precision, unsigned int scale,
  992.                         const unsigned char* arr) {
  993.         m_Precision = precision;
  994.         m_Scale     = scale;
  995.         m_Null      = false;
  996.         memcpy(m_Body, arr, sizeof(m_Body));
  997.         return *this;
  998.     }
  1000.     CDB_Numeric& Assign(unsigned int precision, unsigned int scale,
  1001.                         bool is_negative, const unsigned char* arr) {
  1002.         m_Precision = precision;
  1003.         m_Scale     = scale;
  1004.         m_Null      = false;
  1005.         m_Body[0]= is_negative? 1 : 0;
  1006.         memcpy(m_Body + 1, arr, sizeof(m_Body) - 1);
  1007.         return *this;
  1008.     }
  1010.     CDB_Numeric& operator= (const char* val) {
  1011.         x_MakeFromString(m_Precision, m_Scale, val);
  1012.         return *this;
  1013.     }
  1014.     CDB_Numeric& operator= (const string& val) {
  1015.         x_MakeFromString(m_Precision, m_Scale, val.c_str());
  1016.         return *this;
  1017.     }
  1019.     string Value() const;
  1021.     Uint1 Precision() const {
  1022.         return m_Precision;
  1023.     }
  1025.     Uint1 Scale() const {
  1026.         return m_Scale;
  1027.     }
  1029.     virtual EDB_Type    GetType() const;
  1030.     virtual CDB_Object* Clone()   const;
  1031.     virtual void AssignValue(CDB_Object& v);
  1033. protected:
  1034.     void x_MakeFromString(unsigned int precision,
  1035.                           unsigned int scale,
  1036.                           const char*  val);
  1037.     Uint1         m_Precision;
  1038.     Uint1         m_Scale;
  1039.     unsigned char m_Body[34];
  1040. };
  1043. END_NCBI_SCOPE
  1045. #endif  /* DBAPI_DRIVER___TYPES__HPP */
  1048. /* @} */
  1051. /*
  1052.  * ===========================================================================
  1053.  * $Log: types.hpp,v $
  1054.  * Revision 1000.0  2003/10/29 20:19:16  gouriano
  1055.  * PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.17
  1056.  *
  1057.  * Revision 1.17  2003/05/13 16:54:40  sapojnik
  1058.  * CDB_Object::Create() - support for LongChar, LongBinary
  1059.  *
  1060.  * Revision 1.16  2003/05/05 15:56:15  soussov
  1061.  * new default size 8K-1 for CDB_LongChar, CDB_LongBinary
  1062.  *
  1063.  * Revision 1.15  2003/04/29 21:12:29  soussov
  1064.  * new datatypes CDB_LongChar and CDB_LongBinary added
  1065.  *
  1066.  * Revision 1.14  2003/04/11 17:46:11  siyan
  1067.  * Added doxygen support
  1068.  *
  1069.  * Revision 1.13  2003/01/30 16:06:04  soussov
  1070.  * Changes the default from eCurrent to eEmpty for DateTime types
  1071.  *
  1072.  * Revision 1.12  2002/12/26 19:29:12  dicuccio
  1073.  * Added Win32 export specifier for base DBAPI library
  1074.  *
  1075.  * Revision 1.11  2002/10/07 13:08:32  kans
  1076.  * repaired inconsistent newlines caught by Mac compiler
  1077.  *
  1078.  * Revision 1.10  2002/09/13 18:28:05  soussov
  1079.  * fixed bug with long overflow
  1080.  *
  1081.  * Revision 1.9  2002/05/16 21:27:01  soussov
  1082.  * AssignValue methods added
  1083.  *
  1084.  * Revision 1.8  2002/02/14 00:59:38  vakatov
  1085.  * Clean-up: warning elimination, fool-proofing, fine-tuning, identation, etc.
  1086.  *
  1087.  * Revision 1.7  2002/02/13 22:37:27  sapojnik
  1088.  * new_CDB_Object() renamed to CDB_Object::create()
  1089.  *
  1090.  * Revision 1.6  2002/02/13 22:14:50  sapojnik
  1091.  * new_CDB_Object() (needed for rdblib)
  1092.  *
  1093.  * Revision 1.5  2002/02/06 22:21:58  soussov
  1094.  * fixes the numeric default constructor
  1095.  *
  1096.  * Revision 1.4  2001/12/28 21:22:39  sapojnik
  1097.  * Made compatible with MS compiler: long long to Int8, static const within class def to enum
  1098.  *
  1099.  * Revision 1.3  2001/12/14 17:58:26  soussov
  1100.  * fixes bug in datetime related constructors
  1101.  *
  1102.  * Revision 1.2  2001/11/06 17:58:03  lavr
  1103.  * Formatted uniformly as the rest of the library
  1104.  *
  1105.  * Revision 1.1  2001/09/21 23:39:52  vakatov
  1106.  * -----  Initial (draft) revision.  -----
  1107.  * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
  1108.  * of the DBAPI "driver" libs originally written by Vladimir Soussov.
  1109.  * The revamp involved massive code shuffling and grooming, numerous local
  1110.  * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
  1111.  *
  1112.  * ===========================================================================
  1113.  */