types.hpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: types.hpp,v $
 * PRODUCTION Revision 1000.0  2003/10/29 20:19:16  gouriano
 * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.17
 * PRODUCTION
 * ===========================================================================
 */

#ifndef DBAPI_DRIVER___TYPES__HPP
#define DBAPI_DRIVER___TYPES__HPP

/* $Id: types.hpp,v 1000.0 2003/10/29 20:19:16 gouriano Exp $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Vladimir Soussov
 *
 * File Description:  DB types
 *
 */


#include <corelib/ncbitime.hpp>
#include <corelib/ncbi_limits.h>


/** @addtogroup DbTypes
 *
 * @{
 */


BEGIN_NCBI_SCOPE


// Set of supported types
//

enum EDB_Type {
    eDB_Int,
    eDB_SmallInt,
    eDB_TinyInt,
    eDB_BigInt,
    eDB_VarChar,
    eDB_Char,
    eDB_VarBinary,
    eDB_Binary,
    eDB_Float,
    eDB_Double,
    eDB_DateTime,
    eDB_SmallDateTime,
    eDB_Text,
    eDB_Image,
    eDB_Bit,
    eDB_Numeric,

    eDB_UnsupportedType,
	eDB_LongChar,
	eDB_LongBinary
};



/////////////////////////////////////////////////////////////////////////////
//
//  CDB_Object::
//
// Base class for all "type objects" to support database NULL value
// and provide the means to get the type and to clone the object.
//

class NCBI_DBAPIDRIVER_EXPORT CDB_Object
{
public:
    CDB_Object(bool is_null = true) : m_Null(is_null)  { return; }
    virtual ~CDB_Object();

    bool IsNULL() const  { return m_Null; }
    virtual void AssignNULL();

    virtual EDB_Type    GetType() const = 0;
    virtual CDB_Object* Clone()   const = 0;
    virtual void AssignValue(CDB_Object& v)= 0;

    // Create and return a new object (with internal value NULL) of type "type".
    // NOTE:  "size" matters only for eDB_Char, eDB_Binary, eDB_LongChar, eDB_LongBinary.
    static CDB_Object* Create(EDB_Type type, size_t size = 1);

protected:
    bool m_Null;
};



/////////////////////////////////////////////////////////////////////////////
//
//  CDB_Int::
//  CDB_SmallInt::
//  CDB_TinyInt::
//  CDB_BigInt::
//  CDB_VarChar::
//  CDB_Char::
//  CDB_VarBinary::
//  CDB_Binary::
//  CDB_Float::
//  CDB_Double::
//  CDB_Stream::
//  CDB_Image::
//  CDB_Text::
//  CDB_SmallDateTime::
//  CDB_DateTime::
//  CDB_Bit::
//  CDB_Numeric::
//
// Classes to represent objects of different types (derived from CDB_Object::)
//


class NCBI_DBAPIDRIVER_EXPORT CDB_Int : public CDB_Object
{
public:
    CDB_Int()              : CDB_Object(true)             { return; }
    CDB_Int(const Int4& i) : CDB_Object(false), m_Val(i)  { return; }

    CDB_Int& operator= (const Int4& i) {
        m_Null = false;
        m_Val  = i;
        return *this;
    }

    Int4  Value()   const  { return m_Null ? 0 : m_Val; }
    void* BindVal() const  { return (void*) &m_Val; }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone() const;
    virtual void AssignValue(CDB_Object& v);

protected:
    Int4 m_Val;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_SmallInt : public CDB_Object
{
public:
    CDB_SmallInt()              : CDB_Object(true)             { return; }
    CDB_SmallInt(const Int2& i) : CDB_Object(false), m_Val(i)  { return; }

    CDB_SmallInt& operator= (const Int2& i) {
        m_Null = false;
        m_Val = i;
        return *this;
    }

    Int2  Value()   const  { return m_Null ? 0 : m_Val; }
    void* BindVal() const  { return (void*) &m_Val; }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone() const;
    virtual void AssignValue(CDB_Object& v);

protected:
    Int2 m_Val;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_TinyInt : public CDB_Object
{
public:
    CDB_TinyInt()               : CDB_Object(true)             { return; }
    CDB_TinyInt(const Uint1& i) : CDB_Object(false), m_Val(i)  { return; }

    CDB_TinyInt& operator= (const Uint1& i) {
        m_Null = false;
        m_Val = i;
        return *this;
    }

    Uint1 Value()   const  { return m_Null ? 0 : m_Val; }
    void* BindVal() const  { return (void*) &m_Val; }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone()   const;
    virtual void AssignValue(CDB_Object& v);

protected:
    Uint1 m_Val;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_BigInt : public CDB_Object
{
public:
    CDB_BigInt()              : CDB_Object(true)             { return; }
    CDB_BigInt(const Int8& i) : CDB_Object(false), m_Val(i)  { return; }

    CDB_BigInt& operator= (const Int8& i) {
        m_Null = false;
        m_Val = i;
        return *this;
    }

    Int8 Value() const  { return m_Null ? 0 : m_Val; }
    void* BindVal() const  { return (void*) &m_Val; }


    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone()   const;
    virtual void AssignValue(CDB_Object& v);

protected:
    Int8 m_Val;
};


class NCBI_DBAPIDRIVER_EXPORT CDB_VarChar : public CDB_Object
{
public:
    // constructors
    CDB_VarChar()                           : CDB_Object(true)  { return; }
    CDB_VarChar(const string& s)            { SetValue(s); }
    CDB_VarChar(const char*   s)            { SetValue(s); }
    CDB_VarChar(const char*   s, size_t l)  { SetValue(s, l); }

    // assignment operators
    CDB_VarChar& operator= (const string& s)  { return SetValue(s); }
    CDB_VarChar& operator= (const char*   s)  { return SetValue(s); }

    // set-value methods
    CDB_VarChar& SetValue(const string& s) {
        m_Null = false;
        m_Size = s.copy(m_Val, sizeof(m_Val) - 1);
        m_Val[m_Size] = '\0';
        return *this;
    }
    CDB_VarChar& SetValue(const char* s) {
        if ( s ) {
            for (m_Size = 0;  (m_Size < sizeof(m_Val) - 1)  &&  (*s != '\0');
                 ++s) {
                m_Val[m_Size++] = *s;
            }
            m_Val[m_Size] = '\0';
            m_Null = false;
        }
        else {
            m_Null = true;
        }
        return *this;
    }
    CDB_VarChar& SetValue(const char* s, size_t l) {
        if ( s ) {
            m_Size = l < sizeof(m_Val) ? l : sizeof(m_Val) - 1;
            if ( m_Size ) {
                memcpy(m_Val, s, m_Size);
            }
            m_Val[m_Size] = '\0';
            m_Null = false;
        }
        else {
            m_Null = true;
        }
        return *this;
    }

    //
    const char* Value() const  { return m_Null ? 0 : m_Val;  }
    size_t      Size()  const  { return m_Null ? 0 : m_Size; }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone()   const;
    virtual void AssignValue(CDB_Object& v);

protected:
    size_t m_Size;
    char   m_Val[256];
};



class NCBI_DBAPIDRIVER_EXPORT CDB_Char : public CDB_Object
{
public:
    enum { kMaxCharSize = 255 };

    CDB_Char(size_t s = 1) : CDB_Object(true) {
        m_Size = (s < 1) ? 1 : (s > kMaxCharSize ? kMaxCharSize : s);
        m_Val  = new char[m_Size + 1];
        memset(m_Val, ' ', m_Size);
        m_Val[m_Size] = '\0';
    }

    CDB_Char(size_t s, const string& v) :  CDB_Object(false) {
        m_Size = (s < 1) ? 1 : (s > kMaxCharSize ? kMaxCharSize : s);
        m_Val = new char[m_Size + 1];
        size_t l = v.copy(m_Val, m_Size);
        if (l < m_Size) {
            memset(m_Val + l, ' ', m_Size - l);
        }
        m_Val[m_Size] = '\0';
    }

    CDB_Char(size_t len, const char* str) :  CDB_Object(str == 0) {
        m_Size = (len < 1) ? 1 : (len > kMaxCharSize ? kMaxCharSize : len);
        m_Val = new char[m_Size + 1];

        if ( str ) {
            size_t l;
            for (l = 0;  (l < m_Size)  &&  (*str != '\0');  ++str) {
                m_Val[l++] = *str;
            }
            if (l < m_Size) {
                memset(m_Val + l, ' ', m_Size - l);
            }
        } else {
            memset(m_Val, ' ', m_Size);
        }

        m_Val[m_Size] = '\0';
    }

    CDB_Char(const CDB_Char& v) {
        m_Null = v.m_Null;
        m_Size = v.m_Size;
        m_Val = new char[m_Size + 1];
        memcpy(m_Val, v.m_Val, m_Size + 1);
    }


    CDB_Char& operator= (const CDB_Char& v) {
        m_Null = v.m_Null;
        size_t l = (m_Size > v.m_Size) ? v.m_Size : m_Size;
        memmove(m_Val, v.m_Val, l);
        if (l < m_Size)
            memset(m_Val + l, ' ', m_Size - l);
        return *this;
    }

    CDB_Char& operator= (const string& v) {
        m_Null = false;
        size_t l = v.copy(m_Val, m_Size);
        if (l < m_Size)
            memset(m_Val + l, ' ', m_Size - l);
        return *this;
    }

    CDB_Char& operator= (const char* v) {
        if (v == 0) {
            m_Null = true;
        }
        else {
            m_Null = false;
            size_t l;

            for (l = 0;  (l < m_Size)  &&  (*v != '\0');  ++v) {
                m_Val[l++] = *v;
            }
            if (l < m_Size)
                memset(m_Val + l, ' ', m_Size - l);
        }
        return *this;
    }

    void SetValue(const char* str, size_t len) {
        if ( str ) {
            if (len >= m_Size) {
                memcpy(m_Val, str, m_Size);
            }
            else {
                if ( len ) {
                    memcpy(m_Val, str, len);
                }
                memset(m_Val + len, ' ', m_Size - len);
            }
            m_Null = false;
        }
        else {
            m_Null = true;
        }
    }

    const char* Value() const  { return m_Null ? 0 : m_Val; }
    size_t      Size()  const  { return m_Size; }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone()   const;

    virtual void AssignValue(CDB_Object& v);
    virtual ~CDB_Char();

protected:
    size_t m_Size;
    char*  m_Val;
};

#define K8_1 8191

class NCBI_DBAPIDRIVER_EXPORT CDB_LongChar : public CDB_Object
{
public:

    CDB_LongChar(size_t s = K8_1) : CDB_Object(true) {
        m_Size = (s < 1) ? 1 : s;
        m_Val  = new char[m_Size + 1];
    }

    CDB_LongChar(size_t s, const string& v) :  CDB_Object(false) {
        m_Size = (s < 1) ? K8_1 : s;
        m_Val = new char[m_Size + 1];
        size_t l = v.copy(m_Val, m_Size);
        m_Val[l] = '\0';
    }

    CDB_LongChar(size_t len, const char* str) :  CDB_Object(str == 0) {
        m_Size = (len < 1) ? K8_1 : len;
        m_Val = new char[m_Size + 1];

		if(str) strncpy(m_Val, str, m_Size);
        m_Val[m_Size] = '\0';
    }

    CDB_LongChar(const CDB_LongChar& v) {
        m_Null = v.m_Null;
        m_Size = v.m_Size;
        m_Val = new char[m_Size + 1];
        memcpy(m_Val, v.m_Val, m_Size + 1);
    }


    CDB_LongChar& operator= (const CDB_LongChar& v) {
        m_Null = v.m_Null;
        size_t l = (m_Size > v.m_Size) ? v.m_Size : m_Size;
        memmove(m_Val, v.m_Val, l);
		m_Val[l]= '\0';
        return *this;
    }

    CDB_LongChar& operator= (const string& v) {
        m_Null = false;
        size_t l = v.copy(m_Val, m_Size);
		m_Val[l]= '\0';
        return *this;
    }

    CDB_LongChar& operator= (const char* v) {
        if (v == 0) {
            m_Null = true;
        }
        else {
            m_Null = false;
            size_t l;

            for (l = 0;  (l < m_Size)  &&  (*v != '\0');  ++v) {
                m_Val[l++] = *v;
            }
			m_Val[l]= '\0';
        }
        return *this;
    }

    void SetValue(const char* str, size_t len) {
        if ( str ) {
            if (len >= m_Size) {
                memcpy(m_Val, str, m_Size);
				m_Val[m_Size]= '\0';
            }
            else {
                if ( len ) {
                    memcpy(m_Val, str, len);
                }
                m_Val[len]= '\0';
            }
            m_Null = false;
        }
        else {
		    m_Null = true;
        }
    }

    const char* Value() const  { return m_Null ? 0 : m_Val; }
    size_t      Size()  const  { return m_Size; }
    size_t  DataSize()  const  { return m_Null? 0 : strlen(m_Val); }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone()   const;

    virtual void AssignValue(CDB_Object& v);
    virtual ~CDB_LongChar();

protected:
    size_t m_Size;
    char*  m_Val;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_VarBinary : public CDB_Object
{
public:
    CDB_VarBinary()                         : CDB_Object(true)  { return; }
    CDB_VarBinary(const void* v, size_t l)  { SetValue(v, l); }

    void SetValue(const void* v, size_t l) {
        if (v  &&  l) {
            m_Size = l > sizeof(m_Val) ? sizeof(m_Val) : l;
            memcpy(m_Val, v, m_Size);
            m_Null = false;
        }
        else {
            m_Null = true;
        }
    }

    //
    const void* Value() const  { return m_Null ? 0 : (void*) m_Val; }
    size_t      Size()  const  { return m_Null ? 0 : m_Size; }

    virtual EDB_Type    GetType() const;
    virtual CDB_Object* Clone()   const;
    virtual void AssignValue(CDB_Object& v);

protected:
    size_t        m_Size;
    unsigned char m_Val[255];
};



class NCBI_DBAPIDRIVER_EXPORT CDB_Binary : public CDB_Object
{
public:
    enum { kMaxBinSize = 255 };

    CDB_Binary(size_t s = 1) : CDB_Object(true) {