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

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

生物技术

开发平台：

C/C++

bdb_types.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: bdb_types.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 18:37:36  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.23
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: bdb_types.cpp,v 1000.3 2004/06/01 18:37:36 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: Anatoliy Kuznetsov
  36.  *
  37.  * File Description:  BDB libarary types implementations.
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <corelib/ncbi_bswap.hpp>
  43. #include <bdb/bdb_types.hpp>
  44. #include <db.h>
  46. BEGIN_NCBI_SCOPE
  49. static
  50. const unsigned char* s_GetLString(const unsigned char* str, 
  51.                                   bool  check_legacy, 
  52.                                   int*  str_len)
  53. {
  54.     _ASSERT(str);
  55.     _ASSERT(str_len);
  57.     // string length reconstruction
  58.     *str_len = (str[0])       | 
  59.                (str[1] << 8)  |
  60.                (str[2] << 16) |
  61.                (str[3] << 24);
  62.     
  63.     if (check_legacy) {
  64.         if (*str_len < 0) { // true L-string
  65.             *str_len = -(*str_len);
  66.             str += 4;
  67.         } else {
  68.             *str_len = ::strlen((const char*)str);
  69.         }
  70.     } else {  // no legacy strings
  71.         if (*str_len < 0) { // true L-string
  72.             *str_len = -(*str_len);
  73.             str += 4;
  74.         } else {
  75.             _ASSERT(0); // positive length !
  76.         }
  77.     }
  79.     return str;
  81. }
  83. static 
  84. const unsigned char* s_GetLString(const DBT* val, 
  85.                                   bool  check_legacy, 
  86.                                   int*  str_len)
  87. {
  88.     const unsigned char* str = (const unsigned char*)val->data;
  90.     if (val->size <= 4) {  // looks like legacy C-string
  91.         _ASSERT(check_legacy);
  92.         *str_len = ::strlen((const char*)str);
  93.         return str;
  94.     }
  96.     return s_GetLString(str, check_legacy, str_len);
  97. }
  101. extern "C"
  102. {
  104. /////////////////////////////////////////////////////////////////////////////
  105. //  BDB comparison functions
  106. //
  108. int BDB_UintCompare(DB*, const DBT* val1, const DBT* val2)
  109. {
  110.     unsigned int v1, v2;
  111.     ::memcpy(&v1, val1->data, sizeof(unsigned));
  112.     ::memcpy(&v2, val2->data, sizeof(unsigned));
  113.     return (v1 < v2) ? -1
  114.                      : ((v2 < v1) ? 1 : 0);
  115. }
  117. int BDB_IntCompare(DB*, const DBT* val1, const DBT* val2)
  118. {
  119.     int v1, v2;
  120.     ::memcpy(&v1, val1->data, sizeof(int));
  121.     ::memcpy(&v2, val2->data, sizeof(int));
  122.     return (v1 < v2) ? -1
  123.                      : ((v2 < v1) ? 1 : 0);
  124. }
  126. int BDB_Int2Compare(DB*, const DBT* val1, const DBT* val2)
  127. {
  128.     Int2 v1, v2;
  129.     ::memcpy(&v1, val1->data, sizeof(Int2));
  130.     ::memcpy(&v2, val2->data, sizeof(Int2));
  131.     return (v1 < v2) ? -1
  132.                      : ((v2 < v1) ? 1 : 0);
  133. }
  135. int BDB_UCharCompare(DB*, const DBT* val1, const DBT* val2)
  136. {
  137.     const unsigned char& v1=*static_cast<unsigned char*>(val1->data);
  138.     const unsigned char& v2=*static_cast<unsigned char*>(val2->data);
  140.     return (v1 < v2) ? -1
  141.                      : ((v2 < v1) ? 1 : 0);
  142. }
  144. int BDB_FloatCompare(DB*, const DBT* val1, const DBT* val2)
  145. {
  146.     float v1, v2;
  147.     ::memcpy(&v1, val1->data, sizeof(v1));
  148.     ::memcpy(&v2, val2->data, sizeof(v2));
  149.     return (v1 < v2) ? -1
  150.                      : ((v2 < v1) ? 1 : 0);
  151. }
  153. int BDB_DoubleCompare(DB*, const DBT* val1, const DBT* val2)
  154. {
  155.     double v1, v2;
  156.     ::memcpy(&v1, val1->data, sizeof(v1));
  157.     ::memcpy(&v2, val2->data, sizeof(v2));
  158.     return (v1 < v2) ? -1
  159.                      : ((v2 < v1) ? 1 : 0);
  160. }
  162. int BDB_StringCompare(DB*, const DBT* val1, const DBT* val2)
  163. {
  164.     return ::strcmp((const char*)val1->data, (const char*)val2->data);
  165. }
  169. int BDB_LStringCompare(DB* db, const DBT* val1, const DBT* val2)
  170. {
  171.     const CBDB_BufferManager* fbuf1 =
  172.           static_cast<CBDB_BufferManager*> (db->app_private);
  174.     bool check_legacy = fbuf1->IsLegacyStrings();
  175.     
  176.     const unsigned char* str1;
  177.     const unsigned char* str2;
  178.     int str_len1; 
  179.     int str_len2;
  181.     str1 = s_GetLString(val1, check_legacy, &str_len1); 
  182.     str2 = s_GetLString(val2, check_legacy, &str_len2); 
  184.     int cmp_len = min(str_len1, str_len2);
  185.     int r = ::memcmp(str1, str2, cmp_len);
  186.     if (r == 0) {
  187.         return (str_len1 < str_len2) ? -1
  188.                                      : ((str_len2 < str_len1) ? 1 : 0);
  189.     }
  190.     return r;
  191. }
  194. int BDB_StringCaseCompare(DB*, const DBT* val1, const DBT* val2)
  195. {
  196.     return NStr::strcasecmp((const char*)val1->data, (const char*)val2->data);
  197. }
  199. int BDB_Compare(DB* db, const DBT* val1, const DBT* val2)
  200. {
  201.     const CBDB_BufferManager* fbuf1 =
  202.           static_cast<CBDB_BufferManager*> (db->app_private);
  204.     bool byte_swapped = fbuf1->IsByteSwapped();
  206.     _ASSERT(fbuf1);
  208.     const char* p1 = static_cast<char*> (val1->data);
  209.     const char* p2 = static_cast<char*> (val2->data);
  211.     unsigned int cmp_limit = fbuf1->GetFieldCompareLimit();
  212.     if (cmp_limit == 0) {
  213.         cmp_limit = fbuf1->FieldCount();
  214.     } else {
  215.         _ASSERT(cmp_limit <= fbuf1->FieldCount());
  216.     }
  218.     for (unsigned int i = 0;  i < cmp_limit;  ++i) {
  219.         const CBDB_Field& fld1 = fbuf1->GetField(i);
  220.         int ret = fld1.Compare(p1, p2, byte_swapped);
  221.         if ( ret )
  222.             return ret;
  224.         p1 += fld1.GetDataLength(p1);
  225.         p2 += fld1.GetDataLength(p2);
  226.     }
  228.     return 0;
  229. }
  233. int BDB_ByteSwap_UintCompare(DB*, const DBT* val1, const DBT* val2)
  234. {
  235.     unsigned int v1, v2;
  236.     v1 = (unsigned int) CByteSwap::GetInt4((unsigned char*)val1->data);
  237.     v2 = (unsigned int) CByteSwap::GetInt4((unsigned char*)val2->data);
  238.     return (v1 < v2) ? -1
  239.                      : ((v2 < v1) ? 1 : 0);
  240. }
  242. int BDB_ByteSwap_IntCompare(DB*, const DBT* val1, const DBT* val2)
  243. {
  244.     int v1, v2;
  245.     v1 = CByteSwap::GetInt4((unsigned char*)val1->data);
  246.     v2 = CByteSwap::GetInt4((unsigned char*)val2->data);
  247.     return (v1 < v2) ? -1
  248.                      : ((v2 < v1) ? 1 : 0);
  249. }
  251. int BDB_ByteSwap_Int2Compare(DB*, const DBT* val1, const DBT* val2)
  252. {
  253.     Int2 v1, v2;
  254.     v1 = CByteSwap::GetInt2((unsigned char*)val1->data);
  255.     v2 = CByteSwap::GetInt2((unsigned char*)val2->data);
  256.     return (v1 < v2) ? -1
  257.                      : ((v2 < v1) ? 1 : 0);
  258. }
  261. int BDB_ByteSwap_FloatCompare(DB*, const DBT* val1, const DBT* val2)
  262. {
  263.     float v1, v2;
  264.     v1 = CByteSwap::GetFloat((unsigned char*)val1->data);
  265.     v2 = CByteSwap::GetFloat((unsigned char*)val2->data);
  266.     return (v1 < v2) ? -1
  267.                      : ((v2 < v1) ? 1 : 0);
  268. }
  271. int BDB_ByteSwap_DoubleCompare(DB*, const DBT* val1, const DBT* val2)
  272. {
  273.     double v1, v2;
  274.     v1 = CByteSwap::GetDouble((unsigned char*)val1->data);
  275.     v2 = CByteSwap::GetDouble((unsigned char*)val2->data);
  276.     return (v1 < v2) ? -1
  277.                      : ((v2 < v1) ? 1 : 0);
  279. }
  284. } // extern "C"
  286. /////////////////////////////////////////////////////////////////////////////
  287. //  IBDB_Field::
  288. //
  290. IBDB_Field::~IBDB_Field() 
  291. {
  292. }
  294. /////////////////////////////////////////////////////////////////////////////
  295. //  CBDB_Field::
  296. //
  298. CBDB_Field::CBDB_Field(ELengthType length_type)
  299. : m_BufferManager(0),
  300.   m_Buffer(0),
  301.   m_BufferSize(0),
  302.   m_BufferIdx(0)
  303. {   
  304.     m_Flags.VariableLength = (length_type == eFixedLength) ? 0 : 1;
  305.     m_Flags.Attached = 0;
  306.     m_Flags.Nullable = 0;
  307. }
  309. BDB_CompareFunction 
  310. CBDB_Field::GetCompareFunction(bool /*byte_swapped*/) const
  311. { 
  312.     return BDB_Compare; 
  313. }
  316. /////////////////////////////////////////////////////////////////////////////
  317. //  CBDB_BufferManager::
  318. //
  321. CBDB_BufferManager::CBDB_BufferManager()
  322.   : m_Buffer(0),
  323.     m_BufferSize(0),
  324.     m_PackedSize(0),
  325.     m_DBT_Size(0),
  326.     m_Packable(false),
  327.     m_ByteSwapped(false),
  328.     m_Nullable(false),
  329.     m_NullSetSize(0),
  330.     m_CompareLimit(0),
  331.     m_LegacyString(false)
  332. {
  333. }
  335. CBDB_BufferManager::~CBDB_BufferManager()
  336. {
  337.     delete [] m_Buffer;
  338. }
  340. void CBDB_BufferManager::Bind(CBDB_Field* field, ENullable is_nullable)
  341. {
  342.     m_Fields.push_back(field);
  343.     m_Ptrs.push_back(0);
  345.     unsigned field_idx = (unsigned)(m_Fields.size() - 1);
  346.     field->SetBufferIdx(field_idx);
  348.     if ( !m_Packable ) {
  349.         // If we bind any var length field, then record becomes packable
  350.         m_Packable = field->IsVariableLength();
  351.     }
  353.     if (is_nullable == eNullable)
  354.         field->SetNullable();
  355. }
  357. int CBDB_BufferManager::GetFieldIndex(const string& name) const
  358. {
  359.     for (size_t i = 0;  i < m_Fields.size();  ++i) {
  360.         const CBDB_Field& field = *m_Fields[i];
  361.         const string& fname = field.GetName();
  362.         if (NStr::CompareNocase(name, fname) == 0) {
  363.             return i;
  364.         }
  365.     }
  366.     return -1;
  367. }
  369. size_t CBDB_BufferManager::ComputeBufferSize() const
  370. {
  371.     size_t buf_len = 0;
  372.     for (size_t i = 0;  i < m_Fields.size();  ++i) {
  373.         const CBDB_Field& field = *m_Fields[i];
  374.         buf_len += field.GetBufferSize();
  375.     }
  376.     return buf_len;
  377. }
  380. void CBDB_BufferManager::CheckNullConstraint() const
  381. {
  382.     if ( !IsNullable() )
  383.         return;
  385.     for (size_t i = 0;  i < m_Fields.size();  ++i) {
  386.         const CBDB_Field& fld = *m_Fields[i];
  387.         if (!fld.IsNullable()  &&  TestNullBit((unsigned)i)) {
  388.             string message("NULL field in database operation.");
  389.             const string& field_name = fld.GetName();
  390.             if ( !field_name.empty() ) {
  391.                 message.append("(Field:");
  392.                 message.append(field_name);
  393.                 message.append(")");
  394.             }
  395.             BDB_THROW(eNull, message);
  396.         }
  397.     }
  398. }
  401. void CBDB_BufferManager::Construct()
  402. {
  403.     _ASSERT(m_Fields.size());
  405.     // Buffer construction: fields size calculation.
  406.     m_BufferSize = ComputeBufferSize();
  408.     if ( IsNullable() ) {
  409.         m_NullSetSize = ComputeNullSetSize();
  410.         m_BufferSize += m_NullSetSize;
  411.     }
  413.     delete [] m_Buffer; m_Buffer = 0;
  414.     m_Buffer = new char[m_BufferSize];
  415.     ::memset(m_Buffer, 0, m_BufferSize);
  417.     // Record construction: set element offsets(pointers)
  418.     char*  buf_ptr = (char*) m_Buffer;
  419.     buf_ptr += m_NullSetSize;
  421.     for (size_t i = 0;  i < m_Fields.size();  ++i) {
  422.         CBDB_Field& df = *m_Fields[i];
  423.         m_Ptrs[i] = buf_ptr;
  425.         df.SetBufferManager(this);
  426.         df.SetBuffer(buf_ptr);
  428.         buf_ptr += df.GetBufferSize();
  429.     }
  431.     m_PackedSize = 0;  // not packed
  432. }
  435. BDB_CompareFunction 
  436. CBDB_BufferManager::GetCompareFunction() const
  437. {
  438.     if (m_Fields.size() > 1)
  439.         return BDB_Compare;
  440.     bool byte_swapped = IsByteSwapped();
  441.     return m_Fields[0]->GetCompareFunction(byte_swapped);
  442. }
  445. void CBDB_BufferManager::ArrangePtrsPacked()
  446. {
  447.     _ASSERT(m_Fields.size());
  449.     if ( !IsPackable() ) {
  450.         m_PackedSize = m_BufferSize;
  451.         return;
  452.     }
  454.     char* buf_ptr = m_Buffer;
  455.     buf_ptr += m_NullSetSize;
  456.     m_PackedSize = m_NullSetSize;
  458.     for (size_t i = 0;  i < m_Fields.size();  ++i) {
  459.         CBDB_Field& df = *m_Fields[i];
  460.         df.SetBuffer(buf_ptr);
  461.         size_t len = df.GetDataLength(buf_ptr);
  462.         buf_ptr += len;
  463.         m_PackedSize += len;
  464.     }
  465. }
  468. unsigned int CBDB_BufferManager::Pack()
  469. {
  470.     _ASSERT(m_Fields.size());
  471.     if (m_PackedSize != 0)
  472.         return (unsigned)m_PackedSize;
  473.     if ( !IsPackable() ) {
  474.         m_PackedSize = m_BufferSize;
  475.         return (unsigned)m_PackedSize;
  476.     }
  478.     char* new_ptr = m_Buffer;
  479.     new_ptr += m_NullSetSize;
  480.     m_PackedSize = m_NullSetSize;
  482.     for (size_t i = 0;  i < m_Fields.size();  ++i) {
  483.         CBDB_Field& df = *m_Fields[i];
  484.         size_t actual_len = df.GetLength();
  485.         void* old_ptr = m_Ptrs[i];
  487.         if (new_ptr != old_ptr) {
  488.             ::memmove(new_ptr, old_ptr, actual_len);
  489.             df.SetBuffer(new_ptr);
  490.         }
  492.         if ( m_NullSetSize ) {
  493.             if (df.IsVariableLength()  &&  TestNullBit((unsigned)i)) {
  494.                 actual_len = 1;
  495.                 *new_ptr = ''; // for string it will guarantee it is empty
  496.             }
  497.         }
  499.         new_ptr      += actual_len;
  500.         m_PackedSize += actual_len;
  501.     }
  503.     return (unsigned)m_PackedSize;
  504. }
  507. unsigned int CBDB_BufferManager::Unpack()
  508. {
  509.     _ASSERT(m_Fields.size());
  510.     if (m_PackedSize == 0)
  511.         return (unsigned)m_BufferSize;
  512.     if ( !IsPackable() ) {
  513.         m_PackedSize = 0;
  514.         return (unsigned)m_PackedSize;
  515.     }
  517.     _ASSERT(!m_Fields.empty());
  518.     for (size_t i = m_Fields.size() - 1;  true;  --i) {
  519.         CBDB_Field& df = *m_Fields[i];
  520.         size_t actual_len = df.GetLength();
  521.         void* new_ptr = m_Ptrs[i];
  522.         const void* old_ptr = df.GetBuffer();
  523.         if (new_ptr != old_ptr) {
  524.             ::memmove(new_ptr, old_ptr, actual_len);
  525.             df.SetBuffer(new_ptr);
  526.         }
  527.         m_PackedSize -= actual_len;
  529.         if (i == 0)
  530.             break;
  531.     }
  533.     m_PackedSize -= m_NullSetSize;
  535.     _ASSERT(m_PackedSize == 0);
  536.     return (unsigned)m_BufferSize;
  537. }
  539. void CBDB_BufferManager::PrepareDBT_ForWrite(DBT* dbt)
  540. {
  541.     Pack();
  542.     dbt->data = m_Buffer;
  543.     dbt->size = (unsigned)m_PackedSize;
  544. }
  546. void CBDB_BufferManager::PrepareDBT_ForRead(DBT* dbt)
  547. {
  548.     dbt->data = m_Buffer;
  549.     dbt->size = dbt->ulen = (unsigned)m_BufferSize;
  550.     dbt->flags = DB_DBT_USERMEM;
  551. }
  553. int CBDB_BufferManager::Compare(const CBDB_BufferManager& buf_mgr,
  554.                                 unsigned int              field_count)
  555.     const
  556. {
  557.     if ( !field_count ) {
  558.         field_count = FieldCount();
  559.     }
  560.     _ASSERT(field_count <= FieldCount());
  562.     for (unsigned int i = 0;  i < field_count;  ++i) {
  563.         const CBDB_Field& df1 = GetField(i);
  564.         const CBDB_Field& df2 = buf_mgr.GetField(i);
  566.         int ret = df1.CompareWith(df2);
  567.         if ( ret )
  568.             return ret;
  569.     }
  571.     return 0;
  572. }
  575. void CBDB_BufferManager::DuplicateStructureFrom(const CBDB_BufferManager& buf_mgr)
  576. {
  577.     _ASSERT(FieldCount() == 0);
  578.     for (unsigned int i = 0;  i < buf_mgr.FieldCount();  ++i) {
  579.         const CBDB_Field& src_fld = buf_mgr.GetField(i);
  580.         auto_ptr<CBDB_Field> dst_fld(src_fld.Construct(0));
  581.         dst_fld->SetName(src_fld.GetName().c_str());
  582.         Bind(dst_fld.get());
  583.         dst_fld.release();
  584.     }
  585.     m_LegacyString = buf_mgr.IsLegacyStrings();
  586. }
  591. /////////////////////////////////////////////////////////////////////////////
  592. //  CBDB_FieldLString::
  593. //
  595. CBDB_FieldLString::CBDB_FieldLString() 
  596.  : CBDB_FieldStringBase()
  597. {
  598.     SetBufferSize(256 + 4);
  599. }
  601. CBDB_Field* CBDB_FieldLString::Construct(size_t buf_size) const
  602. {
  603.     CBDB_FieldLString* fld = new CBDB_FieldLString();
  604.     fld->SetBufferSize(buf_size ? buf_size : GetBufferSize());
  605.     return fld;
  606. }
  609. const unsigned char* 
  610. CBDB_FieldLString::GetLString(const unsigned char* str,
  611.                               bool                 check_legacy,
  612.                               int*                 str_len) const
  613. {
  614.     size_t DBT_size = m_BufferManager->GetDBT_Size();
  616.     if (DBT_size > 0 && DBT_size <= 4) {  // looks like legacy C-string
  617.         _ASSERT(check_legacy);
  618.         *str_len = (int)::strlen((const char*)str);
  619.     } else {
  620.         str = s_GetLString(str, check_legacy, str_len);
  621.     }
  622.     return str;
  623. }
  625. /*
  626. CBDB_FieldLString::operator const char* () const
  627. {
  628.     const unsigned char* str = (const unsigned char*)GetBuffer();
  629.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  631.     int str_len;
  632.     size_t DBT_size = m_BufferManager->GetDBT_Size();
  634.     if (DBT_size <= 4) {  // looks like legacy C-string
  635.         _ASSERT(check_legacy);
  636.         str_len = ::strlen((const char*)str);
  637.     } else {
  638.         str = GetLString(str, check_legacy, &str_len);
  639.     }
  640.     return (const char*) str;
  641. }
  642. */
  644. const CBDB_FieldLString& 
  645. CBDB_FieldLString::operator=(const CBDB_FieldLString& str)
  646. {
  647.     void* buf = GetBuffer();
  648.     if (this == &str)
  649.         return *this;
  651.     size_t len = str.GetDataLength(buf);
  652.     if ( len > (GetBufferSize() - 4) ) {
  653.         // TODO: allow partial string assignment?
  654.         BDB_THROW(eOverflow, "String field overflow.");
  655.     }
  656.     Unpack();
  657.     ::memcpy(buf, str.GetBuffer(), len);
  659.     if ( str.IsNull() ) {
  660.         SetNull();
  661.     } else {
  662.         SetNotNull();
  663.     }
  665.     return *this;
  666. }
  669. void CBDB_FieldLString::Set(const char* str, EOverflowAction if_overflow)
  670. {
  671.     if ( !str )
  672.         str = kEmptyCStr;
  674.     unsigned int new_len = ::strlen(str) + 1;
  676.     // check overflow
  677.     if ( new_len > (GetBufferSize() - 4) ) {
  678.         if (if_overflow == eTruncateOnOverflow) {
  679.             new_len = GetBufferSize();
  680.         } else {
  681.             string message("String field overflow."); 
  682.             // TODO: add info what caused overflow, what length expected
  683.             BDB_THROW(eOverflow, message);
  684.         }
  685.     }
  686.     Unpack();
  687.     unsigned char* str_buf = (unsigned char*) GetBuffer();
  689.     int s_len = -new_len;  // always store it negative
  690.     str_buf[0] = (unsigned char) (s_len);
  691.     str_buf[1] = (unsigned char) (s_len >> 8);
  692.     str_buf[2] = (unsigned char) (s_len >> 16);
  693.     str_buf[3] = (unsigned char) (s_len >> 24);
  695.     str_buf += 4;
  697.     ::memcpy(str_buf, str, new_len);
  699.     SetNotNull();
  700. }
  702. void CBDB_FieldLString::SetString(const char* str)
  703. {
  704.     operator=(str);
  705. }
  708. int CBDB_FieldLString::Compare(const void* p1, 
  709.                                const void* p2, 
  710.                                bool /*byte_swapped*/) const
  711. {
  712.     _ASSERT(p1 && p2);
  714.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  715.     
  716.     const unsigned char* str1;
  717.     const unsigned char* str2;
  718.     int str_len1; 
  719.     int str_len2;
  721.     str1 = GetLString((const unsigned char*)p1, check_legacy, &str_len1);
  722.     str2 = GetLString((const unsigned char*)p2, check_legacy, &str_len2); 
  724.     int cmp_len = min(str_len1, str_len2);
  725.     int r = ::memcmp(str1, str2, cmp_len);
  726.     if (r == 0) {
  727.         return (str_len1 < str_len2) ? -1
  728.                                      : ((str_len2 < str_len1) ? 1 : 0);
  729.     }
  730.     return r;
  731. }
  734. void CBDB_FieldLString::SetMinVal()
  735. {
  736.     Set("", eTruncateOnOverflow);
  737. }
  740. void CBDB_FieldLString::SetMaxVal()
  741. {
  742.     void* buf = Unpack();
  743.     int buf_size = GetBufferSize();
  745.     ::memset(buf, 0x7F, buf_size); // 0xFF for international
  746.     ((char*) buf)[buf_size - 1] = '';
  748.     int s_len = -(buf_size - 4);  // always store it negative
  749.     unsigned char* str_buf = (unsigned char*) buf;
  751.     str_buf[0] = (unsigned char) (s_len);
  752.     str_buf[1] = (unsigned char) (s_len >> 8);
  753.     str_buf[2] = (unsigned char) (s_len >> 16);
  754.     str_buf[3] = (unsigned char) (s_len >> 24);
  756.     SetNotNull();
  757. }
  760. bool CBDB_FieldLString::IsEmpty() const
  761. {
  762.     const unsigned char* str = (const unsigned char*) GetBuffer();
  763.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  764.     int str_len;
  766.     str = GetLString(str, check_legacy, &str_len);
  768.     return (str_len == 0);
  769. }
  771. bool CBDB_FieldLString::IsBlank() const
  772. {
  773.     const unsigned char* str = (const unsigned char*) GetBuffer();
  774.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  775.     int str_len;
  777.     str = GetLString(str, check_legacy, &str_len);
  779.     for (int i = 0; i < str_len; ++i) {
  780.         if (!isspace(str[i]))
  781.             return false;
  782.     }
  784.     return true;
  785. }
  788. size_t CBDB_FieldLString::GetDataLength(const void* buf) const
  789. {
  790.     const unsigned char* str = (const unsigned char*) buf;
  791.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  792.     int str_len;
  794.     str = GetLString(str, check_legacy, &str_len);
  795.     if (str != (const unsigned char*) buf)
  796.         str_len += 4;
  797.     return str_len + 1;
  798. }
  800. const CBDB_FieldLString& CBDB_FieldLString::operator= (const char* str)
  801. { 
  802.     Set(str, eThrowOnOverflow); 
  803.     return *this;
  804. }
  806. const CBDB_FieldLString& CBDB_FieldLString::operator= (const string& str)
  807. {
  808.     SetStdString(str);
  809.     return *this;
  810. }
  813. string CBDB_FieldLString::Get() const
  814. {
  815.     const unsigned char* buf = (const unsigned char*) GetBuffer();
  816.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  817.     
  818.     const unsigned char* str;
  819.     int str_len; 
  821.     str = GetLString(buf, check_legacy, &str_len);
  822.     if (str_len == 0) {
  823.         return kEmptyStr;
  824.     } 
  825.     string ret((const char*) str, str_len);
  826.     return ret;
  827. }
  829. void CBDB_FieldLString::ToString(string& ostr) const
  830. {
  831.     const unsigned char* buf = (const unsigned char*) GetBuffer();
  832.     bool check_legacy = m_BufferManager->IsLegacyStrings();
  833.     
  834.     const unsigned char* str;
  835.     int str_len;
  837.     ostr.resize(0);
  839.     str = GetLString(buf, check_legacy, &str_len);
  840.     if (str_len == 0) {
  841.         return;
  842.     }
  843.     ostr.append((const char*) str, str_len);
  844. }
  846. void CBDB_FieldLString::SetStdString(const string& str)
  847. {
  848.     unsigned int str_len = str.length();
  849.     if (str_len == 0) {
  850.         Set("", eThrowOnOverflow);
  851.         return;
  852.     }
  854.     // check overflow
  855.     if (str_len > (GetBufferSize() - 4 - 1)) {
  856.         string message("String field overflow."); 
  857.         // TODO: add info what caused overflow, what length expected
  858.         BDB_THROW(eOverflow, message);
  859.     }
  861.     const char* str_data = str.data();
  863.     /* void* buf = */ Unpack();
  865.     unsigned char* str_buf = (unsigned char*) GetBuffer();
  867.     int s_len = -str_len;  // always store it negative
  868.     str_buf[0] = (unsigned char) (s_len);
  869.     str_buf[1] = (unsigned char) (s_len >> 8);
  870.     str_buf[2] = (unsigned char) (s_len >> 16);
  871.     str_buf[3] = (unsigned char) (s_len >> 24);
  873.     str_buf += 4;
  875.     ::memcpy(str_buf, str_data, str_len);
  877.     str_buf[str_len] = 0;
  879.     SetNotNull();
  881. }
  884. END_NCBI_SCOPE
  887. /*
  888.  * ===========================================================================
  889.  * $Log: bdb_types.cpp,v $
  890.  * Revision 1000.3  2004/06/01 18:37:36  gouriano
  891.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.23
  892.  *
  893.  * Revision 1.23  2004/05/17 20:55:11  gorelenk
  894.  * Added include of PCH ncbi_pch.hpp
  895.  *
  896.  * Revision 1.22  2004/05/06 15:42:19  rotmistr
  897.  * Changed Char type to UChar
  898.  *
  899.  * Revision 1.21  2004/05/05 19:18:21  rotmistr
  900.  * CBDB_FieldChar added
  901.  *
  902.  * Revision 1.20  2004/03/08 13:30:39  kuznets
  903.  * + ToString
  904.  *
  905.  * Revision 1.19  2004/02/17 19:05:21  kuznets
  906.  * GCC warnings fix
  907.  *
  908.  * Revision 1.18  2004/02/12 19:54:39  kuznets
  909.  * CBDB_BufferManager::GetFieldIndex()
  910.  *
  911.  * Revision 1.17  2004/02/04 17:03:39  kuznets
  912.  * Fixed bug in LString manipulation.
  913.  *
  914.  * Revision 1.16  2003/12/22 18:54:14  kuznets
  915.  * Implemeneted length prefixed string field (CBDB_FieldLString)
  916.  *
  917.  * Revision 1.15  2003/11/06 14:06:02  kuznets
  918.  * Removing auto_ptr from CBDB_BufferManager
  919.  *
  920.  * Revision 1.14  2003/10/16 19:25:38  kuznets
  921.  * Added field comparison limit to the fields manager
  922.  *
  923.  * Revision 1.13  2003/09/29 16:27:06  kuznets
  924.  * Cleaned up 64-bit compilation warnings
  925.  *
  926.  * Revision 1.12  2003/09/17 13:31:12  kuznets
  927.  * Implemented Int2Compare family of functions
  928.  *
  929.  * Revision 1.11  2003/09/11 16:34:35  kuznets
  930.  * Implemented byte-order independence.
  931.  *
  932.  * Revision 1.10  2003/07/25 15:47:15  kuznets
  933.  * Added support for double field type
  934.  *
  935.  * Revision 1.9  2003/07/23 20:21:43  kuznets
  936.  * Implemented new improved scheme for setting BerkeleyDB comparison function.
  937.  * When table has non-segmented key the simplest(and fastest) possible function
  938.  * is assigned (automatically without reloading CBDB_File::SetCmp function).
  939.  *
  940.  * Revision 1.8  2003/07/02 17:55:35  kuznets
  941.  * Implementation modifications to eliminated direct dependency from <db.h>
  942.  *
  943.  * Revision 1.7  2003/06/10 20:08:27  kuznets
  944.  * Fixed function names.
  945.  *
  946.  * Revision 1.6  2003/05/27 18:43:45  kuznets
  947.  * Fixed some compilation problems with GCC 2.95
  948.  *
  949.  * Revision 1.5  2003/05/02 14:12:11  kuznets
  950.  * Bug fix
  951.  *
  952.  * Revision 1.4  2003/04/29 19:07:22  kuznets
  953.  * Cosmetics..
  954.  *
  955.  * Revision 1.3  2003/04/29 19:04:47  kuznets
  956.  * Fixed a bug in buffers management
  957.  *
  958.  * Revision 1.2  2003/04/28 14:51:55  kuznets
  959.  * #include directives changed to conform the NCBI policy
  960.  *
  961.  * Revision 1.1  2003/04/24 16:34:30  kuznets
  962.  * Initial revision
  963.  *
  964.  * ===========================================================================
  965.  */