bdb_types.cpp

来自「ncbi源码」· C++ 代码 · 共 966 行 · 第 1/2 页

        size_t actual_len = df.GetLength();
        void* old_ptr = m_Ptrs[i];

        if (new_ptr != old_ptr) {
            ::memmove(new_ptr, old_ptr, actual_len);
            df.SetBuffer(new_ptr);
        }

        if ( m_NullSetSize ) {
            if (df.IsVariableLength()  &&  TestNullBit((unsigned)i)) {
                actual_len = 1;
                *new_ptr = '\0'; // for string it will guarantee it is empty
            }
        }

        new_ptr      += actual_len;
        m_PackedSize += actual_len;
    }

    return (unsigned)m_PackedSize;
}


unsigned int CBDB_BufferManager::Unpack()
{
    _ASSERT(m_Fields.size());
    if (m_PackedSize == 0)
        return (unsigned)m_BufferSize;
    if ( !IsPackable() ) {
        m_PackedSize = 0;
        return (unsigned)m_PackedSize;
    }

    _ASSERT(!m_Fields.empty());
    for (size_t i = m_Fields.size() - 1;  true;  --i) {
        CBDB_Field& df = *m_Fields[i];
        size_t actual_len = df.GetLength();
        void* new_ptr = m_Ptrs[i];
        const void* old_ptr = df.GetBuffer();
        if (new_ptr != old_ptr) {
            ::memmove(new_ptr, old_ptr, actual_len);
            df.SetBuffer(new_ptr);
        }
        m_PackedSize -= actual_len;

        if (i == 0)
            break;
    }

    m_PackedSize -= m_NullSetSize;

    _ASSERT(m_PackedSize == 0);
    return (unsigned)m_BufferSize;
}

void CBDB_BufferManager::PrepareDBT_ForWrite(DBT* dbt)
{
    Pack();
    dbt->data = m_Buffer;
    dbt->size = (unsigned)m_PackedSize;
}

void CBDB_BufferManager::PrepareDBT_ForRead(DBT* dbt)
{
    dbt->data = m_Buffer;
    dbt->size = dbt->ulen = (unsigned)m_BufferSize;
    dbt->flags = DB_DBT_USERMEM;
}

int CBDB_BufferManager::Compare(const CBDB_BufferManager& buf_mgr,
                                unsigned int              field_count)
    const
{
    if ( !field_count ) {
        field_count = FieldCount();
    }
    _ASSERT(field_count <= FieldCount());

    for (unsigned int i = 0;  i < field_count;  ++i) {
        const CBDB_Field& df1 = GetField(i);
        const CBDB_Field& df2 = buf_mgr.GetField(i);

        int ret = df1.CompareWith(df2);
        if ( ret )
            return ret;
    }

    return 0;
}


void CBDB_BufferManager::DuplicateStructureFrom(const CBDB_BufferManager& buf_mgr)
{
    _ASSERT(FieldCount() == 0);
    for (unsigned int i = 0;  i < buf_mgr.FieldCount();  ++i) {
        const CBDB_Field& src_fld = buf_mgr.GetField(i);
        auto_ptr<CBDB_Field> dst_fld(src_fld.Construct(0));
        dst_fld->SetName(src_fld.GetName().c_str());
        Bind(dst_fld.get());
        dst_fld.release();
    }
    m_LegacyString = buf_mgr.IsLegacyStrings();
}




/////////////////////////////////////////////////////////////////////////////
//  CBDB_FieldLString::
//

CBDB_FieldLString::CBDB_FieldLString() 
 : CBDB_FieldStringBase()
{
    SetBufferSize(256 + 4);
}

CBDB_Field* CBDB_FieldLString::Construct(size_t buf_size) const
{
    CBDB_FieldLString* fld = new CBDB_FieldLString();
    fld->SetBufferSize(buf_size ? buf_size : GetBufferSize());
    return fld;
}


const unsigned char* 
CBDB_FieldLString::GetLString(const unsigned char* str,
                              bool                 check_legacy,
                              int*                 str_len) const
{
    size_t DBT_size = m_BufferManager->GetDBT_Size();

    if (DBT_size > 0 && DBT_size <= 4) {  // looks like legacy C-string
        _ASSERT(check_legacy);
        *str_len = (int)::strlen((const char*)str);
    } else {
        str = s_GetLString(str, check_legacy, str_len);
    }
    return str;
}

/*
CBDB_FieldLString::operator const char* () const
{
    const unsigned char* str = (const unsigned char*)GetBuffer();
    bool check_legacy = m_BufferManager->IsLegacyStrings();

    int str_len;
    size_t DBT_size = m_BufferManager->GetDBT_Size();

    if (DBT_size <= 4) {  // looks like legacy C-string
        _ASSERT(check_legacy);
        str_len = ::strlen((const char*)str);
    } else {
        str = GetLString(str, check_legacy, &str_len);
    }
    return (const char*) str;
}
*/

const CBDB_FieldLString& 
CBDB_FieldLString::operator=(const CBDB_FieldLString& str)
{
    void* buf = GetBuffer();
    if (this == &str)
        return *this;

    size_t len = str.GetDataLength(buf);
    if ( len > (GetBufferSize() - 4) ) {
        // TODO: allow partial string assignment?
        BDB_THROW(eOverflow, "String field overflow.");
    }
    Unpack();
    ::memcpy(buf, str.GetBuffer(), len);

    if ( str.IsNull() ) {
        SetNull();
    } else {
        SetNotNull();
    }

    return *this;
}


void CBDB_FieldLString::Set(const char* str, EOverflowAction if_overflow)
{
    if ( !str )
        str = kEmptyCStr;

    unsigned int new_len = ::strlen(str) + 1;

    // check overflow
    if ( new_len > (GetBufferSize() - 4) ) {
        if (if_overflow == eTruncateOnOverflow) {
            new_len = GetBufferSize();
        } else {
            string message("String field overflow."); 
            // TODO: add info what caused overflow, what length expected
            BDB_THROW(eOverflow, message);
        }
    }
    Unpack();
    unsigned char* str_buf = (unsigned char*) GetBuffer();

    int s_len = -new_len;  // always store it negative
    str_buf[0] = (unsigned char) (s_len);
    str_buf[1] = (unsigned char) (s_len >> 8);
    str_buf[2] = (unsigned char) (s_len >> 16);
    str_buf[3] = (unsigned char) (s_len >> 24);

    str_buf += 4;

    ::memcpy(str_buf, str, new_len);

    SetNotNull();
}

void CBDB_FieldLString::SetString(const char* str)
{
    operator=(str);
}


int CBDB_FieldLString::Compare(const void* p1, 
                               const void* p2, 
                               bool /*byte_swapped*/) const
{
    _ASSERT(p1 && p2);

    bool check_legacy = m_BufferManager->IsLegacyStrings();
    
    const unsigned char* str1;
    const unsigned char* str2;
    int str_len1; 
    int str_len2;

    str1 = GetLString((const unsigned char*)p1, check_legacy, &str_len1);
    str2 = GetLString((const unsigned char*)p2, check_legacy, &str_len2); 

    int cmp_len = min(str_len1, str_len2);
    int r = ::memcmp(str1, str2, cmp_len);
    if (r == 0) {
        return (str_len1 < str_len2) ? -1
                                     : ((str_len2 < str_len1) ? 1 : 0);
    }
    return r;
}


void CBDB_FieldLString::SetMinVal()
{
    Set("", eTruncateOnOverflow);
}


void CBDB_FieldLString::SetMaxVal()
{
    void* buf = Unpack();
    int buf_size = GetBufferSize();

    ::memset(buf, 0x7F, buf_size); // 0xFF for international
    ((char*) buf)[buf_size - 1] = '\0';

    int s_len = -(buf_size - 4);  // always store it negative
    unsigned char* str_buf = (unsigned char*) buf;

    str_buf[0] = (unsigned char) (s_len);
    str_buf[1] = (unsigned char) (s_len >> 8);
    str_buf[2] = (unsigned char) (s_len >> 16);
    str_buf[3] = (unsigned char) (s_len >> 24);

    SetNotNull();
}


bool CBDB_FieldLString::IsEmpty() const
{
    const unsigned char* str = (const unsigned char*) GetBuffer();
    bool check_legacy = m_BufferManager->IsLegacyStrings();
    int str_len;

    str = GetLString(str, check_legacy, &str_len);

    return (str_len == 0);
}

bool CBDB_FieldLString::IsBlank() const
{
    const unsigned char* str = (const unsigned char*) GetBuffer();
    bool check_legacy = m_BufferManager->IsLegacyStrings();
    int str_len;

    str = GetLString(str, check_legacy, &str_len);

    for (int i = 0; i < str_len; ++i) {
        if (!isspace(str[i]))
            return false;
    }

    return true;
}


size_t CBDB_FieldLString::GetDataLength(const void* buf) const
{
    const unsigned char* str = (const unsigned char*) buf;
    bool check_legacy = m_BufferManager->IsLegacyStrings();
    int str_len;

    str = GetLString(str, check_legacy, &str_len);
    if (str != (const unsigned char*) buf)
        str_len += 4;
    return str_len + 1;
}

const CBDB_FieldLString& CBDB_FieldLString::operator= (const char* str)
{ 
    Set(str, eThrowOnOverflow); 
    return *this;
}

const CBDB_FieldLString& CBDB_FieldLString::operator= (const string& str)
{
    SetStdString(str);
    return *this;
}


string CBDB_FieldLString::Get() const
{
    const unsigned char* buf = (const unsigned char*) GetBuffer();
    bool check_legacy = m_BufferManager->IsLegacyStrings();
    
    const unsigned char* str;
    int str_len; 

    str = GetLString(buf, check_legacy, &str_len);
    if (str_len == 0) {
        return kEmptyStr;
    } 
    string ret((const char*) str, str_len);
    return ret;
}

void CBDB_FieldLString::ToString(string& ostr) const
{
    const unsigned char* buf = (const unsigned char*) GetBuffer();
    bool check_legacy = m_BufferManager->IsLegacyStrings();
    
    const unsigned char* str;
    int str_len;

    ostr.resize(0);

    str = GetLString(buf, check_legacy, &str_len);
    if (str_len == 0) {
        return;
    }
    ostr.append((const char*) str, str_len);
}

void CBDB_FieldLString::SetStdString(const string& str)
{
    unsigned int str_len = str.length();
    if (str_len == 0) {
        Set("", eThrowOnOverflow);
        return;
    }

    // check overflow
    if (str_len > (GetBufferSize() - 4 - 1)) {
        string message("String field overflow."); 
        // TODO: add info what caused overflow, what length expected
        BDB_THROW(eOverflow, message);
    }

    const char* str_data = str.data();

    /* void* buf = */ Unpack();

    unsigned char* str_buf = (unsigned char*) GetBuffer();

    int s_len = -str_len;  // always store it negative
    str_buf[0] = (unsigned char) (s_len);
    str_buf[1] = (unsigned char) (s_len >> 8);
    str_buf[2] = (unsigned char) (s_len >> 16);
    str_buf[3] = (unsigned char) (s_len >> 24);

    str_buf += 4;

    ::memcpy(str_buf, str_data, str_len);

    str_buf[str_len] = 0;

    SetNotNull();

}


END_NCBI_SCOPE


/*
 * ===========================================================================
 * $Log: bdb_types.cpp,v $
 * Revision 1000.3  2004/06/01 18:37:36  gouriano
 * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.23
 *
 * Revision 1.23  2004/05/17 20:55:11  gorelenk
 * Added include of PCH ncbi_pch.hpp
 *
 * Revision 1.22  2004/05/06 15:42:19  rotmistr
 * Changed Char type to UChar
 *
 * Revision 1.21  2004/05/05 19:18:21  rotmistr
 * CBDB_FieldChar added
 *
 * Revision 1.20  2004/03/08 13:30:39  kuznets
 * + ToString
 *
 * Revision 1.19  2004/02/17 19:05:21  kuznets
 * GCC warnings fix
 *
 * Revision 1.18  2004/02/12 19:54:39  kuznets
 * CBDB_BufferManager::GetFieldIndex()
 *
 * Revision 1.17  2004/02/04 17:03:39  kuznets
 * Fixed bug in LString manipulation.
 *
 * Revision 1.16  2003/12/22 18:54:14  kuznets
 * Implemeneted length prefixed string field (CBDB_FieldLString)
 *
 * Revision 1.15  2003/11/06 14:06:02  kuznets
 * Removing auto_ptr from CBDB_BufferManager
 *
 * Revision 1.14  2003/10/16 19:25:38  kuznets
 * Added field comparison limit to the fields manager
 *
 * Revision 1.13  2003/09/29 16:27:06  kuznets
 * Cleaned up 64-bit compilation warnings
 *
 * Revision 1.12  2003/09/17 13:31:12  kuznets
 * Implemented Int2Compare family of functions
 *
 * Revision 1.11  2003/09/11 16:34:35  kuznets
 * Implemented byte-order independence.
 *
 * Revision 1.10  2003/07/25 15:47:15  kuznets
 * Added support for double field type
 *
 * Revision 1.9  2003/07/23 20:21:43  kuznets
 * Implemented new improved scheme for setting BerkeleyDB comparison function.
 * When table has non-segmented key the simplest(and fastest) possible function
 * is assigned (automatically without reloading CBDB_File::SetCmp function).
 *
 * Revision 1.8  2003/07/02 17:55:35  kuznets
 * Implementation modifications to eliminated direct dependency from <db.h>
 *
 * Revision 1.7  2003/06/10 20:08:27  kuznets
 * Fixed function names.
 *
 * Revision 1.6  2003/05/27 18:43:45  kuznets
 * Fixed some compilation problems with GCC 2.95
 *
 * Revision 1.5  2003/05/02 14:12:11  kuznets
 * Bug fix
 *
 * Revision 1.4  2003/04/29 19:07:22  kuznets
 * Cosmetics..
 *
 * Revision 1.3  2003/04/29 19:04:47  kuznets
 * Fixed a bug in buffers management
 *
 * Revision 1.2  2003/04/28 14:51:55  kuznets
 * #include directives changed to conform the NCBI policy
 *
 * Revision 1.1  2003/04/24 16:34:30  kuznets
 * Initial revision
 *
 * ===========================================================================
 */