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

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

生物技术

开发平台：

C/C++

types.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: types.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:19:28  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /* $Id: types.cpp,v 1000.2 2004/06/01 19:19:28 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:  Vladimir Soussov
  36.  *
  37.  * File Description:  Type conversions
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbitime.hpp>
  44. #include <dbapi/driver/exception.hpp>
  45. #include <dbapi/driver/util/numeric_convert.hpp>
  46. #include "memory_store.hpp"
  48. #include <dbapi/driver/types.hpp>
  50. #include <string.h>
  53. BEGIN_NCBI_SCOPE
  56. /////////////////////////////////////////////////////////////////////////////
  57. //  CDB_Object::
  58. //
  60. CDB_Object::~CDB_Object()
  61. {
  62.     return;
  63. }
  65. void CDB_Object::AssignNULL()
  66. {
  67.     m_Null = true;
  68. }
  71. CDB_Object* CDB_Object::Create(EDB_Type type, size_t size)
  72. {
  73.     switch ( type ) {
  74.     case eDB_Int             : return new CDB_Int           ();
  75.     case eDB_SmallInt        : return new CDB_SmallInt      ();
  76.     case eDB_TinyInt         : return new CDB_TinyInt       ();
  77.     case eDB_BigInt          : return new CDB_BigInt        ();
  78.     case eDB_VarChar         : return new CDB_VarChar       ();
  79.     case eDB_Char            : return new CDB_Char      (size);
  80.     case eDB_VarBinary       : return new CDB_VarBinary     ();
  81.     case eDB_Binary          : return new CDB_Binary    (size);
  82.     case eDB_Float           : return new CDB_Float         ();
  83.     case eDB_Double          : return new CDB_Double        ();
  84.     case eDB_DateTime        : return new CDB_DateTime      ();
  85.     case eDB_SmallDateTime   : return new CDB_SmallDateTime ();
  86.     case eDB_Text            : return new CDB_Text          ();
  87.     case eDB_Image           : return new CDB_Image         ();
  88.     case eDB_Bit             : return new CDB_Bit           ();
  89.     case eDB_Numeric         : return new CDB_Numeric       ();
  90.     case eDB_LongBinary      : return new CDB_LongBinary(size);
  91.     case eDB_LongChar        : return new CDB_LongChar  (size);
  92.     case eDB_UnsupportedType : break;
  93.     }
  94.     throw CDB_ClientEx(eDB_Error, 2, "CDB_Object::Create", "unknown type");
  95. }
  98. /////////////////////////////////////////////////////////////////////////////
  99. //  CDB_Int::
  100. //
  102. EDB_Type CDB_Int::GetType() const
  103. {
  104.     return eDB_Int;
  105. }
  107. CDB_Object* CDB_Int::Clone() const
  108. {
  109.     return m_Null ? new CDB_Int : new CDB_Int(m_Val);
  110. }
  112. void CDB_Int::AssignValue(CDB_Object& v)
  113. {
  114.     switch( v.GetType() ) {
  115.         case eDB_Int     : *this= (CDB_Int&)v; break;
  116.         case eDB_SmallInt: *this= ((CDB_SmallInt&)v).Value(); break;
  117.         case eDB_TinyInt : *this= ((CDB_TinyInt &)v).Value(); break;
  118.         default:
  119.             throw CDB_ClientEx(eDB_Error, 2, "CDB_Int::AssignValue",
  120.                                "wrong type of CDB_Object");
  121.     }
  123. }
  126. /////////////////////////////////////////////////////////////////////////////
  127. //  CDB_SmallInt::
  128. //
  130. EDB_Type CDB_SmallInt::GetType() const
  131. {
  132.     return eDB_SmallInt;
  133. }
  135. CDB_Object* CDB_SmallInt::Clone() const
  136. {
  137.     return m_Null ? new CDB_SmallInt : new CDB_SmallInt(m_Val);
  138. }
  140. void CDB_SmallInt::AssignValue(CDB_Object& v)
  141. {
  142.     switch( v.GetType() ) {
  143.         case eDB_SmallInt: *this= (CDB_SmallInt&)v; break;
  144.         case eDB_TinyInt : *this= ((CDB_TinyInt &)v).Value(); break;
  145.         default:
  146.             throw CDB_ClientEx(eDB_Error, 2, "CDB_SmallInt::AssignValue",
  147.                                          "wrong type of CDB_Object");
  148.     }
  149.     *this= (CDB_SmallInt&)v;
  150. }
  152. /////////////////////////////////////////////////////////////////////////////
  153. //  CDB_TinyInt::
  154. //
  156. EDB_Type CDB_TinyInt::GetType() const
  157. {
  158.     return eDB_TinyInt;
  159. }
  161. CDB_Object* CDB_TinyInt::Clone() const
  162. {
  163.     return m_Null ? new CDB_TinyInt : new CDB_TinyInt(m_Val);
  164. }
  166. void CDB_TinyInt::AssignValue(CDB_Object& v)
  167. {
  168.     if(v.GetType() != eDB_TinyInt) {
  169.         throw CDB_ClientEx(eDB_Error, 2, "CDB_TinyInt::AssignValue",
  170.                            "wrong type of CDB_Object");
  171.     }
  172.     *this= (CDB_TinyInt&)v;
  173. }
  176. /////////////////////////////////////////////////////////////////////////////
  177. //  CDB_BigInt::
  178. //
  180. EDB_Type CDB_BigInt::GetType() const
  181. {
  182.     return eDB_BigInt;
  183. }
  185. CDB_Object* CDB_BigInt::Clone() const
  186. {
  187.     return m_Null ? new CDB_BigInt : new CDB_BigInt(m_Val);
  188. }
  190. void CDB_BigInt::AssignValue(CDB_Object& v)
  191. {
  192.     switch( v.GetType() ) {
  193.         case eDB_BigInt  : *this= (CDB_BigInt&)v; break;
  194.         case eDB_Int     : *this= ((CDB_Int     &)v).Value(); break;
  195.         case eDB_SmallInt: *this= ((CDB_SmallInt&)v).Value(); break;
  196.         case eDB_TinyInt : *this= ((CDB_TinyInt &)v).Value(); break;
  197.         default:
  198.             throw CDB_ClientEx(eDB_Error, 2, "CDB_BigInt::AssignValue",
  199.                                "wrong type of CDB_Object");
  200.     }
  201. }
  203. /////////////////////////////////////////////////////////////////////////////
  204. //  CDB_VarChar::
  205. //
  207. EDB_Type CDB_VarChar::GetType() const
  208. {
  209.     return eDB_VarChar;
  210. }
  212. CDB_Object* CDB_VarChar::Clone() const
  213. {
  214.     return m_Null ? new CDB_VarChar : new CDB_VarChar(m_Val);
  215. }
  217. void CDB_VarChar::AssignValue(CDB_Object& v)
  218. {
  219.     if(v.GetType() != eDB_VarChar) {
  220.         throw CDB_ClientEx(eDB_Error, 2, "CDB_VarChar::AssignValue",
  221.                            "wrong type of CDB_Object");
  222.     }
  223.     *this= (CDB_VarChar&)v;
  224. }
  226. /////////////////////////////////////////////////////////////////////////////
  227. //  CDB_Char::
  228. //
  230. EDB_Type CDB_Char::GetType() const
  231. {
  232.     return eDB_Char;
  233. }
  235. CDB_Object* CDB_Char::Clone() const
  236. {
  237.     return new CDB_Char(*this);
  238. }
  240. void CDB_Char::AssignValue(CDB_Object& v)
  241. {
  242.     if(v.GetType() != eDB_Char) {
  243.         throw CDB_ClientEx(eDB_Error, 2, "CDB_Char::AssignValue",
  244.                            "wrong type of CDB_Object");
  245.     }
  246.     register CDB_Char& cv= (CDB_Char&)v;
  247.     if(m_Size < cv.m_Size) {
  248.         delete [] m_Val;
  249.         m_Val= new char[cv.m_Size+1];
  250.     }
  251.     m_Size= cv.m_Size;
  252.     if(cv.IsNULL()) {
  253.         m_Null= true;
  254.     }
  255.     else {
  256.         m_Null= false;
  257.         memcpy(m_Val, cv.m_Val, m_Size+1);
  258.     }
  259. }
  261. CDB_Char::~CDB_Char()
  262. {
  263.     delete [] m_Val;
  264. }
  266. /////////////////////////////////////////////////////////////////////////////
  267. //  CDB_LongChar::
  268. //
  270. EDB_Type CDB_LongChar::GetType() const
  271. {
  272.     return eDB_LongChar;
  273. }
  275. CDB_Object* CDB_LongChar::Clone() const
  276. {
  277.     return new CDB_LongChar(*this);
  278. }
  280. void CDB_LongChar::AssignValue(CDB_Object& v)
  281. {
  282.     if(v.GetType() != eDB_LongChar) {
  283.         throw CDB_ClientEx(eDB_Error, 2, "CDB_LongChar::AssignValue",
  284.                            "wrong type of CDB_Object");
  285.     }
  286.     register CDB_LongChar& cv= (CDB_LongChar&)v;
  287.     if(m_Size < cv.m_Size) {
  288.         delete [] m_Val;
  289.         m_Val= new char[cv.m_Size+1];
  290.     }
  291.     m_Size= cv.m_Size;
  292.     if(cv.IsNULL()) {
  293.         m_Null= true;
  294.     }
  295.     else {
  296.         m_Null= false;
  297.         memcpy(m_Val, cv.m_Val, m_Size+1);
  298.     }
  299. }
  301. CDB_LongChar::~CDB_LongChar()
  302. {
  303.     delete [] m_Val;
  304. }
  307. /////////////////////////////////////////////////////////////////////////////
  308. //  CDB_VarBinary::
  309. //
  311. EDB_Type CDB_VarBinary::GetType() const
  312. {
  313.     return eDB_VarBinary;
  314. }
  316. CDB_Object* CDB_VarBinary::Clone() const
  317. {
  318.     return m_Null ? new CDB_VarBinary : new CDB_VarBinary(m_Val, m_Size);
  319. }
  321. void CDB_VarBinary::AssignValue(CDB_Object& v)
  322. {
  323.     if(v.GetType() != eDB_VarBinary) {
  324.         throw CDB_ClientEx(eDB_Error, 2, "CDB_VarBinary::AssignValue",
  325.                            "wrong type of CDB_Object");
  326.     }
  327.     *this= (CDB_VarBinary&)v;
  328. }
  330. /////////////////////////////////////////////////////////////////////////////
  331. //  CDB_Binary::
  332. //
  334. EDB_Type CDB_Binary::GetType() const
  335. {
  336.     return eDB_Binary;
  337. }
  339. CDB_Object* CDB_Binary::Clone() const
  340. {
  341.     return m_Null ? new CDB_Binary(m_Size) : new CDB_Binary(*this);
  342. }
  344. void CDB_Binary::AssignValue(CDB_Object& v)
  345. {
  346.     if(v.GetType() != eDB_Binary) {
  347.         throw CDB_ClientEx(eDB_Error, 2, "CDB_Binary::AssignValue",
  348.                            "wrong type of CDB_Object");
  349.     }
  350.     register CDB_Binary& cv= (CDB_Binary&)v;
  351.     if(m_Size < cv.m_Size) {
  352.         delete [] m_Val;
  353.         m_Val= new unsigned char[cv.m_Size];
  354.     }
  355.     m_Size= cv.m_Size;
  356.     if(cv.IsNULL()) {
  357.         m_Null= true;
  358.     }
  359.     else {
  360.         m_Null= false;
  361.         memcpy(m_Val, cv.m_Val, m_Size);
  362.     }
  363. }
  365. CDB_Binary::~CDB_Binary()
  366. {
  367.     delete[] m_Val;
  368. }
  370. /////////////////////////////////////////////////////////////////////////////
  371. //  CDB_LongBinary::
  372. //
  374. EDB_Type CDB_LongBinary::GetType() const
  375. {
  376.     return eDB_LongBinary;
  377. }
  379. CDB_Object* CDB_LongBinary::Clone() const
  380. {
  381.     return new CDB_LongBinary(*this);
  382. }
  384. void CDB_LongBinary::AssignValue(CDB_Object& v)
  385. {
  386.     if(v.GetType() != eDB_LongBinary) {
  387.         throw CDB_ClientEx(eDB_Error, 2, "CDB_LongBinary::AssignValue",
  388.                            "wrong type of CDB_Object");
  389.     }
  390.     register CDB_LongBinary& cv= (CDB_LongBinary&)v;
  391.     if(cv.IsNULL()) {
  392.         m_Null= true;
  393.     }
  394.     else {
  395.         m_Null= false;
  396.         m_DataSize= (m_Size < cv.m_DataSize)? m_Size : cv.m_DataSize;
  397.         memcpy(m_Val, cv.m_Val, m_DataSize);
  398.     }
  399. }
  401. CDB_LongBinary::~CDB_LongBinary()
  402. {
  403.     delete[] m_Val;
  404. }
  407. /////////////////////////////////////////////////////////////////////////////
  408. //  CDB_Float::
  409. //
  411. EDB_Type CDB_Float::GetType() const
  412. {
  413.     return eDB_Float;
  414. }
  416. CDB_Object* CDB_Float::Clone() const
  417. {
  418.     return m_Null ? new CDB_Float : new CDB_Float(m_Val);
  419. }
  421. void CDB_Float::AssignValue(CDB_Object& v)
  422. {
  423.     switch( v.GetType() ) {
  424.         case eDB_Float   : *this= (CDB_Float&)v; break;
  425.         case eDB_SmallInt: *this= ((CDB_SmallInt&)v).Value(); break;
  426.         case eDB_TinyInt : *this= ((CDB_TinyInt &)v).Value(); break;
  427.         default:
  428.             throw CDB_ClientEx(eDB_Error, 2, "CDB_Float::AssignValue",
  429.                                "wrong type of CDB_Object");
  430.     }
  431. }
  433. /////////////////////////////////////////////////////////////////////////////
  434. //  CDB_Double::
  435. //
  437. EDB_Type CDB_Double::GetType() const
  438. {
  439.     return eDB_Double;
  440. }
  442. CDB_Object* CDB_Double::Clone() const
  443. {
  444.     return m_Null ? new CDB_Double : new CDB_Double(m_Val);
  445. }
  447. void CDB_Double::AssignValue(CDB_Object& v)
  448. {
  449.     switch( v.GetType() ) {
  450.         case eDB_Double  : *this= (CDB_Double&)v; break;
  451.         case eDB_Float   : *this= ((CDB_Float   &)v).Value(); break;
  452.         case eDB_Int     : *this= ((CDB_Int     &)v).Value(); break;
  453.         case eDB_SmallInt: *this= ((CDB_SmallInt&)v).Value(); break;
  454.         case eDB_TinyInt : *this= ((CDB_TinyInt &)v).Value(); break;
  455.         default:
  456.             throw CDB_ClientEx(eDB_Error, 2, "CDB_Double::AssignValue",
  457.                                "wrong type of CDB_Object");
  458.     }
  459. }
  461. /////////////////////////////////////////////////////////////////////////////
  462. //  CDB_Stream::
  463. //
  465. CDB_Stream::CDB_Stream()
  466.     : CDB_Object(true)
  467. {
  468.     m_Store = new CMemStore;
  469. }
  471. CDB_Stream& CDB_Stream::Assign(const CDB_Stream& v)
  472. {
  473.     m_Null = v.m_Null;
  474.     m_Store->Truncate();
  475.     if ( !m_Null ) {
  476.         char buff[1024];
  477.         CMemStore* s = (CMemStore*) &v.m_Store;
  478.         size_t pos = s->Tell();
  479.         for (size_t n = s->Read((void*) buff, sizeof(buff));
  480.              n > 0;
  481.              n = s->Read((void*) buff, sizeof(buff))) {
  482.             Append((void*) buff, n);
  483.         }
  484.         s->Seek((long) pos, C_RA_Storage::eHead);
  485.     }
  486.     return *this;
  487. }
  489. void CDB_Stream::AssignNULL()
  490. {
  491.     CDB_Object::AssignNULL();
  492.     Truncate();
  493. }
  495. size_t CDB_Stream::Read(void* buff, size_t nof_bytes)
  496. {
  497.     return m_Store->Read(buff, nof_bytes);
  498. }
  500. size_t CDB_Stream::Append(const void* buff, size_t nof_bytes)
  501. {
  502.     if(buff && (nof_bytes > 0)) m_Null = false;
  503.     return m_Store->Append(buff, nof_bytes);
  504. }
  506. bool CDB_Stream::MoveTo(size_t byte_number)
  507. {
  508.     return m_Store->Seek((long) byte_number, C_RA_Storage::eHead)
  509.         == (long) byte_number;
  510. }
  512. size_t CDB_Stream::Size() const
  513. {
  514.     return m_Store->GetDataSize();
  515. }
  517. void CDB_Stream::Truncate(size_t nof_bytes)
  518. {
  519.     m_Store->Truncate(nof_bytes);
  520.     m_Null = (m_Store->GetDataSize() <= 0);
  521. }
  523. void CDB_Stream::AssignValue(CDB_Object& v)
  524. {
  525.     if((v.GetType() != eDB_Image) && (v.GetType() != eDB_Text)) {
  526.         throw CDB_ClientEx(eDB_Error, 2, "CDB_Stream::AssignValue",
  527.                            "wrong type of CDB_Object");
  528.     }
  529.     Assign((CDB_Stream&)v);
  530. }
  532. CDB_Stream::~CDB_Stream()
  533. {
  534.     delete m_Store;
  535. }
  538. /////////////////////////////////////////////////////////////////////////////
  539. //  CDB_Image::
  540. //
  542. CDB_Image& CDB_Image::operator= (const CDB_Image& image)
  543. {
  544.     return dynamic_cast<CDB_Image&> (Assign(image));
  545. }
  547. EDB_Type CDB_Image::GetType() const
  548. {
  549.     return eDB_Image;
  550. }
  552. CDB_Object* CDB_Image::Clone() const
  553. {
  554.     if ( !m_Null ) {
  555.         throw CDB_ClientEx(eDB_Error, 1, "CDB_Image::Clone",
  556.                            "Clone for the non NULL image is not supported");
  557.     }
  558.     return new CDB_Image;
  559. }
  562. /////////////////////////////////////////////////////////////////////////////
  563. //  CDB_Text::
  564. //
  566. size_t CDB_Text::Append(const void* buff, size_t nof_bytes)
  567. {
  568.     if(!buff) return 0;
  569.     return CDB_Stream::Append
  570.         (buff, nof_bytes ? nof_bytes : strlen((const char*) buff));
  571. }
  573. size_t CDB_Text::Append(const string& s)
  574. {
  575.     return CDB_Stream::Append(s.data(), s.size());
  576. }
  578. CDB_Text& CDB_Text::operator= (const CDB_Text& text)
  579. {
  580.     return dynamic_cast<CDB_Text&> (Assign(text));
  581. }
  583. EDB_Type CDB_Text::GetType() const
  584. {
  585.     return eDB_Text;
  586. }
  588. CDB_Object* CDB_Text::Clone() const
  589. {
  590.     if ( !m_Null ) {
  591.         throw CDB_ClientEx(eDB_Error, 1, "CDB_Text::Clone",
  592.                            "Clone for the non-NULL text is not supported");
  593.     }
  594.     return new CDB_Text;
  595. }
  598. /////////////////////////////////////////////////////////////////////////////
  599. //  CDB_SmallDateTime::
  600. //
  602. EDB_Type CDB_SmallDateTime::GetType() const
  603. {
  604.     return eDB_SmallDateTime;
  605. }
  607. CDB_Object* CDB_SmallDateTime::Clone() const
  608. {
  609.     return m_Null ? new CDB_SmallDateTime : new CDB_SmallDateTime(Value());
  610. }
  612. void CDB_SmallDateTime::AssignValue(CDB_Object& v)
  613. {
  614.     if(v.GetType() != eDB_SmallDateTime) {
  615.         throw CDB_ClientEx(eDB_Error, 2, "CDB_SmallDateTime::AssignValue",
  616.                            "wrong type of CDB_Object");
  617.     }
  618.     *this= (CDB_SmallDateTime&)v;
  619. }
  622. /////////////////////////////////////////////////////////////////////////////
  623. //  CDB_DateTime::
  624. //
  626. EDB_Type CDB_DateTime::GetType() const
  627. {
  628.     return eDB_DateTime;
  629. }
  631. CDB_Object* CDB_DateTime::Clone() const
  632. {
  633.     return m_Null ? new CDB_DateTime : new CDB_DateTime(Value());
  634. }
  636. void CDB_DateTime::AssignValue(CDB_Object& v)
  637. {
  638.     if(v.GetType() != eDB_DateTime) {
  639.         throw CDB_ClientEx(eDB_Error, 2, "CDB_DateTime::AssignValue",
  640.                            "wrong type of CDB_Object");
  641.     }
  642.     *this= (CDB_DateTime&)v;
  643. }
  645. /////////////////////////////////////////////////////////////////////////////
  646. //  CDB_Bit::
  647. //
  649. EDB_Type CDB_Bit::GetType() const
  650. {
  651.     return eDB_Bit;
  652. }
  654. CDB_Object* CDB_Bit::Clone() const
  655. {
  656.     return m_Null ? new CDB_Bit : new CDB_Bit(m_Val ? 1 : 0);
  657. }
  659. void CDB_Bit::AssignValue(CDB_Object& v)
  660. {
  661.     if(v.GetType() != eDB_Bit) {
  662.         throw CDB_ClientEx(eDB_Error, 2, "CDB_Bit::AssignValue",
  663.                            "wrong type of CDB_Object");
  664.     }
  665.     *this= (CDB_Bit&)v;
  666. }
  669. /////////////////////////////////////////////////////////////////////////////
  670. //
  671. //  CDB_Numeric::
  672. //
  675. EDB_Type CDB_Numeric::GetType() const
  676. {
  677.     return eDB_Numeric;
  678. }
  681. CDB_Object* CDB_Numeric::Clone() const
  682. {
  683.     return new CDB_Numeric((unsigned int) m_Precision,
  684.                            (unsigned int) m_Scale, m_Body);
  685. }
  688. static int s_NumericBytesPerPrec[] =
  689. {
  690.     2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 7, 7, 8, 8, 9, 9, 9,
  691.     10, 10, 11, 11, 11, 12, 12, 13, 13, 14, 14, 14, 15, 15,
  692.     16, 16, 16, 17, 17, 18, 18, 19, 19, 19, 20, 20, 21, 21, 21,
  693.     22, 22, 23, 23, 24, 24, 24, 25, 25, 26, 26, 26
  694. };
  697. static const unsigned int kMaxPrecision = 50;
  700. static void s_DoCarry(unsigned char* product)
  701. {
  702.     for (unsigned int j = 0;  j < kMaxPrecision;  j++) {
  703.         if (product[j] > 9) {
  704.             product[j + 1] += product[j] / 10;
  705.             product[j]     %= 10;
  706.         }
  707.     }
  708. }
  711. static void s_MultiplyByte(unsigned char* product, int num,
  712.                            const unsigned char* multiplier)
  713. {
  714.     unsigned char number[3];
  715.     number[0] =  num        % 10;
  716.     number[1] = (num /  10) % 10;
  717.     number[2] = (num / 100) % 10;
  719.     int top;
  720.     for (top = kMaxPrecision - 1;  top >= 0  &&  !multiplier[top];  top--)
  721.         continue;
  723.     int start = 0;
  724.     for (int i = 0;  i <= top;  i++) {
  725.         for (int j =0;  j < 3;  j++) {
  726.             product[j + start] += multiplier[i] * number[j];
  727.         }
  728.         s_DoCarry(product);
  729.         start++;
  730.     }
  731. }
  734. static char* s_ArrayToString(const unsigned char* array, int scale, char* s)
  735. {
  736.     int top;
  738.     for (top = kMaxPrecision - 1;  top >= 0  &&  top > scale  &&  !array[top];
  739.          top--)
  740.         continue;
  742.     if (top == -1) {
  743.         s[0] = '0';
  744.         s[1] = '';
  745.         return s;
  746.     }
  748.     int j = 0;
  749.     for (int i = top;  i >= 0;  i--) {
  750.         if (top + 1 - j == scale)
  751.             s[j++] = '.';
  752.         s[j++] = array[i] + '0';
  753.     }
  754.     s[j] = '';
  756.     return s;
  757. }
  760. string CDB_Numeric::Value() const
  761. {
  762.     unsigned char multiplier[kMaxPrecision];
  763.     unsigned char temp[kMaxPrecision];
  764.     unsigned char product[kMaxPrecision];
  765.     char result[kMaxPrecision + 1];
  766.     char* s = result;
  767.     int num_bytes;
  769.     memset(multiplier, 0, kMaxPrecision);
  770.     memset(product,    0, kMaxPrecision);
  771.     multiplier[0] = 1;
  772.     num_bytes = s_NumericBytesPerPrec[m_Precision-1];
  774.     if (m_Body[0] == 1) {
  775.         *s++ = '-';
  776.     }
  778.     for (int pos = num_bytes - 1;  pos > 0;  pos--) {
  779.         s_MultiplyByte(product, m_Body[pos], multiplier);
  781.         memcpy(temp, multiplier, kMaxPrecision);
  782.         memset(multiplier, 0, kMaxPrecision);
  783.         s_MultiplyByte(multiplier, 256, temp);
  784.     }
  786.     s_ArrayToString(product, m_Scale, s);
  787.     return result;
  788. }
  792. static int s_NextValue(const char** s, int rem, int base)
  793. {
  794.     while (**s < base) {
  795.         rem = rem * base + (int) **s;
  796.         (*s)++;
  797.         if (rem >= 256)
  798.             break;
  799.     }
  800.     return rem;
  801. }
  804. static int s_Div256(const char* value, char* product, int base)
  805. {
  806.     int res = 0;
  807.     int n;
  809.     while (*value < base) {
  810.         n = s_NextValue(&value, res, base);
  811.         *product = (char) (n / 256);
  812.         res = n % 256;
  813.         ++product;
  814.     }
  815.     *product = base;
  816.     return res;
  817. }
  820. void CDB_Numeric::x_MakeFromString(unsigned int precision, unsigned int scale,
  821.                                    const char* val)
  822. {
  824.     if (m_Precision == 0  &&  precision == 0  &&  val) {
  825.         precision= (unsigned int) strlen(val);
  826.         if (scale == 0) {
  827.             scale= precision - (Uint1) strcspn(val, ".");
  828.             if (scale > 1)
  829.                 --scale;
  830.         }
  831.     }
  833.     if (!precision  ||  precision > kMaxPrecision) {
  834.         throw CDB_ClientEx(eDB_Error, 100, "CDB_Numeric::x_MakeFromString",
  835.                            "illegal precision");
  836.     }
  837.     if (scale > precision) {
  838.         throw CDB_ClientEx(eDB_Error, 101, "CDB_Numeric::x_MakeFromString",
  839.                            "scale can not be more than precision");
  840.     }
  842.     bool is_negative= false;
  843.     if(*val == '-') {
  844.         is_negative= true;
  845.         ++val;
  846.     }
  848.     while (*val == '0') {
  849.         ++val;
  850.     }
  852.     char buff1[kMaxPrecision + 1];
  853.     unsigned int n = 0;
  854.     while (*val  &&  n < precision) {
  855.         if (*val >= '0'  &&  *val <= '9') {
  856.             buff1[n++] = *val - '0';
  857.         } else if (*val == '.') {
  858.             break;
  859.         } else {
  860.             throw CDB_ClientEx(eDB_Error, 102, "CDB_Numeric::x_MakeFromString",
  861.                                "string can not be converted");
  862.         }
  863.         ++val;
  864.     }
  866.     if (precision - n < scale) {
  867.         throw CDB_ClientEx(eDB_Error, 103, "CDB_Numeric::x_MakeFromString",
  868.                            "string can not be converted because of overflow");
  869.     }
  871.     unsigned int dec = 0;
  872.     if (*val == '.') {
  873.         ++val;
  874.         while (*val  &&  dec < scale) {
  875.             if (*val >= '0'  &&  *val <= '9') {
  876.                 buff1[n++] = *val - '0';
  877.             } else {
  878.                 throw CDB_ClientEx(eDB_Error, 102,
  879.                                    "CDB_Numeric::x_MakeFromString",
  880.                                    "string can not be converted");
  881.             }
  882.             ++dec;
  883.             ++val;
  884.         }
  885.     }
  887.     while (dec++ < scale) {
  888.         buff1[n++] = 0;
  889.     }
  890.     if (n == 0) {
  891.         buff1[n++] = 0;
  892.     }
  893.     buff1[n] = 10;
  895.     char  buff2[kMaxPrecision + 1];
  896.     char* p[2];
  897.     p[0] = buff1;
  898.     p[1] = buff2;
  900.     // Setup everything now
  901.     memset(m_Body, 0, sizeof(m_Body));
  902.     if (is_negative) {
  903.         m_Body[0] = 1/*sign*/;
  904.     }
  905.     unsigned char* num = m_Body + s_NumericBytesPerPrec[precision - 1] - 1;
  906.     for (int i = 0;  *p[i];  i = 1 - i) {
  907.         *num = s_Div256(p[i], p[1-i], 10);
  908.         --num;
  909.     }
  911.     m_Precision = precision;
  912.     m_Scale     = scale;
  913.     m_Null      = false;
  914. }
  916. void CDB_Numeric::AssignValue(CDB_Object& v)
  917. {
  918.     if(v.GetType() != eDB_Numeric) {
  919.         throw CDB_ClientEx(eDB_Error, 2, "CDB_Numeric::AssignValue",
  920.                            "wrong type of CDB_Object");
  921.     }
  922.     *this= (CDB_Numeric&)v;
  923. }
  925. END_NCBI_SCOPE
  929. /*
  930.  * ===========================================================================
  931.  * $Log: types.cpp,v $
  932.  * Revision 1000.2  2004/06/01 19:19:28  gouriano
  933.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.17
  934.  *
  935.  * Revision 1.17  2004/05/17 21:11:38  gorelenk
  936.  * Added include of PCH ncbi_pch.hpp
  937.  *
  938.  * Revision 1.16  2004/01/21 18:07:35  sapojnik
  939.  * AssignValue() for misc. int, float, double accepts less capable types; only no loss type conversions allowed
  940.  *
  941.  * Revision 1.15  2003/12/10 18:50:22  soussov
  942.  * fixes bug with null value flag in AssignValue methods for CDB_Char, CDB_Binary, CDB_LongChar, CDB_LongBinary
  943.  *
  944.  * Revision 1.14  2003/08/13 18:02:11  soussov
  945.  * fixes bug in Clone() for [Small]DateTime
  946.  *
  947.  * Revision 1.13  2003/05/13 16:54:40  sapojnik
  948.  * CDB_Object::Create() - support for LongChar, LongBinary
  949.  *
  950.  * Revision 1.12  2003/05/05 15:58:22  soussov
  951.  * fixed bug in Clone() method for CDB_Char, CDB_LongChar and CDB_LongBinary when NULL value is cloned
  952.  *
  953.  * Revision 1.11  2003/04/29 21:13:57  soussov
  954.  * new datatypes CDB_LongChar and CDB_LongBinary added
  955.  *
  956.  * Revision 1.10  2002/09/25 21:47:51  soussov
  957.  * adds check for not-empty append before dropping the Null flag in CDB_Stream
  958.  *
  959.  * Revision 1.9  2002/07/19 15:31:43  soussov
  960.  * add check for NULL pointer in CDB_Text::Append
  961.  *
  962.  * Revision 1.8  2002/05/16 21:29:38  soussov
  963.  * AssignValue methods added
  964.  *
  965.  * Revision 1.7  2002/02/14 00:59:42  vakatov
  966.  * Clean-up: warning elimination, fool-proofing, fine-tuning, identation, etc.
  967.  *
  968.  * Revision 1.6  2002/02/13 22:37:26  sapojnik
  969.  * new_CDB_Object() renamed to CDB_Object::create()
  970.  *
  971.  * Revision 1.5  2002/02/13 22:14:50  sapojnik
  972.  * new_CDB_Object() (needed for rdblib)
  973.  *
  974.  * Revision 1.4  2002/02/06 22:22:54  soussov
  975.  * fixes the string to numeric assignment
  976.  *
  977.  * Revision 1.3  2001/11/06 17:59:54  lavr
  978.  * Formatted uniformly as the rest of the library
  979.  *
  980.  * Revision 1.2  2001/09/24 20:38:52  soussov
  981.  * fixed bug in sign processing
  982.  *
  983.  * Revision 1.1  2001/09/21 23:40:00  vakatov
  984.  * -----  Initial (draft) revision.  -----
  985.  * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
  986.  * of the DBAPI "driver" libs originally written by Vladimir Soussov.
  987.  * The revamp involved massive code shuffling and grooming, numerous local
  988.  * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
  989.  *
  990.  * ===========================================================================
  991.  */