types.hpp

ncbi源码

        m_Size = (s < 1) ? 1 : (s > kMaxBinSize ? kMaxBinSize : s);
        m_Val = new unsigned char[m_Size];
        memset(m_Val, 0, m_Size);
    }

    CDB_Binary(size_t s, const void* v, size_t v_size) {
        m_Size = (s == 0) ? 1 : (s > kMaxBinSize ? kMaxBinSize : s);
        m_Val  = new unsigned char[m_Size];
        SetValue(v, v_size);
    }

    CDB_Binary(const CDB_Binary& v) {
        m_Null = v.m_Null;
        m_Size = v.m_Size;
        m_Val = new unsigned char[m_Size];
        memcpy(m_Val, v.m_Val, m_Size);
    }

    void SetValue(const void* v, size_t v_size) {
        if (v  &&  v_size) {
            memcpy(m_Val, v, (v_size > m_Size) ? m_Size : v_size);
            if (v_size < m_Size) {
                memset(m_Val + v_size, 0, m_Size - v_size);
            }
            m_Null = false;
        } else {
            m_Null = true;
        }
    }

    CDB_Binary& operator= (const CDB_Binary& 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, 0, m_Size - l);
        }
        return *this;
    }

    //
    const void* Value() const  { return m_Null ? 0 : (void*) 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_Binary();

protected:
    size_t         m_Size;
    unsigned char* m_Val;
};

class NCBI_DBAPIDRIVER_EXPORT CDB_LongBinary : public CDB_Object
{
public:

    CDB_LongBinary(size_t s = K8_1) : CDB_Object(true) {
        m_Size = (s < 1) ? 1 : s;
        m_Val = new unsigned char[m_Size];
		m_DataSize= 0;
    }

    CDB_LongBinary(size_t s, const void* v, size_t v_size) {
        m_Size = (s == 0) ? K8_1 : s;
        m_Val  = new unsigned char[m_Size];
        SetValue(v, v_size);
    }

    CDB_LongBinary(const CDB_LongBinary& v) {
        m_Null = v.m_Null;
        m_Size = v.m_Size;
		m_DataSize= v.m_DataSize;
        m_Val = new unsigned char[m_Size];
        memcpy(m_Val, v.m_Val, m_DataSize);
    }

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

    CDB_LongBinary& operator= (const CDB_LongBinary& v) {
        m_Null = v.m_Null;
        m_DataSize = (m_Size > v.m_DataSize) ? v.m_DataSize : m_Size;
		if(m_DataSize) {
		    memmove(m_Val, v.m_Val, m_DataSize);
		}
        return *this;
    }

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

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

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

protected:
    size_t         m_Size;
    size_t         m_DataSize;
    unsigned char* m_Val;
};


class NCBI_DBAPIDRIVER_EXPORT CDB_Float : public CDB_Object
{
public:
    CDB_Float()        : CDB_Object(true)             { return; }
    CDB_Float(float i) : CDB_Object(false), m_Val(i)  { return; }

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

    float 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:
    float m_Val;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_Double : public CDB_Object
{
public:
    CDB_Double()         : CDB_Object(true)             { return; }
    CDB_Double(double i) : CDB_Object(false), m_Val(i)  { return; }

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

    //
    double 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:
    double m_Val;
};


class CMemStore;


class NCBI_DBAPIDRIVER_EXPORT CDB_Stream : public CDB_Object
{
public:
    // assignment
    virtual void AssignNULL();
    CDB_Stream&  Assign(const CDB_Stream& v);

    // data manipulations
    virtual size_t Read     (void* buff, size_t nof_bytes);
    virtual size_t Append   (const void* buff, size_t nof_bytes);
    virtual void   Truncate (size_t nof_bytes = kMax_Int);
    virtual bool   MoveTo   (size_t byte_number);

    // current size of data
    virtual size_t Size() const;
    virtual void AssignValue(CDB_Object& v);

protected:
    // 'ctors
    CDB_Stream();
    virtual ~CDB_Stream();

private:
    // data storage
    CMemStore* m_Store;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_Image : public CDB_Stream
{
public:
    CDB_Image& operator= (const CDB_Image& image);

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



class NCBI_DBAPIDRIVER_EXPORT CDB_Text : public CDB_Stream
{
public:
    virtual size_t Append(const void* buff, size_t nof_bytes = 0/*strlen*/);
    virtual size_t Append(const string& s);

    CDB_Text& operator= (const CDB_Text& text);

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



class NCBI_DBAPIDRIVER_EXPORT CDB_SmallDateTime : public CDB_Object
{
public:
    CDB_SmallDateTime(CTime::EInitMode mode= CTime::eEmpty)
	  : m_NCBITime(mode) {
        m_Status = 0x1;
    }
    CDB_SmallDateTime(const CTime& t) {
        m_NCBITime = t;
        m_Status   = 0x1;
        m_Null     = false;
    }
    CDB_SmallDateTime(Uint2 days, Uint2 minutes) {
        m_DBTime.days = days;
        m_DBTime.time = minutes;
        m_Status      = 0x2;
        m_Null        = false;
    }

    CDB_SmallDateTime& Assign(Uint2 days, Uint2 minutes) {
        m_DBTime.days = days;
        m_DBTime.time = minutes;
        m_Status      = 0x2;
        m_Null        = false;
        return *this;
    }

    CDB_SmallDateTime& operator= (const CTime& t) {
        m_NCBITime = t;
        m_Status = 0x1;
        m_Null= false;
        return *this;
    }

    const CTime& Value() const {
        if((m_Status & 0x1) == 0) {
            m_NCBITime.SetTimeDBU(m_DBTime);
            m_Status |= 0x1;
        }
        return m_NCBITime;
    }

    Uint2 GetDays() const {
        if((m_Status & 0x2) == 0) {
            m_DBTime = m_NCBITime.GetTimeDBU();
            m_Status |= 0x2;
        }
        return m_DBTime.days;
    }

    Uint2 GetMinutes() const {
        if((m_Status & 0x2) == 0) {
            m_DBTime = m_NCBITime.GetTimeDBU();
            m_Status |= 0x2;
        }
        return m_DBTime.time;
    }

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

protected:
    mutable CTime        m_NCBITime;
    mutable TDBTimeU     m_DBTime;
    // which of m_NCBITime(0x1), m_DBTime(0x2) is valid;  they both can be valid
    mutable unsigned int m_Status;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_DateTime : public CDB_Object
{
public:
    CDB_DateTime(CTime::EInitMode mode= CTime::eEmpty)
	  : m_NCBITime(mode) {
        m_Status = 0x1;
    }
    CDB_DateTime(const CTime& t) {
        m_NCBITime = t;
        m_Status = 0x1;
        m_Null= false;
    }
    CDB_DateTime(Int4 d, Int4 s300) {
        m_DBTime.days = d;
        m_DBTime.time = s300;
        m_Status = 0x2;
        m_Null= false;
    }

    CDB_DateTime& operator= (const CTime& t) {
        m_NCBITime = t;
        m_Status = 0x1;
        m_Null= false;
        return *this;
    }

    CDB_DateTime& Assign(Int4 d, Int4 s300) {
        m_DBTime.days = d;
        m_DBTime.time = s300;
        m_Status = 0x2;
        m_Null = false;
        return *this;
    }

    const CTime& Value() const {
        if((m_Status & 0x1) == 0) {
            m_NCBITime.SetTimeDBI(m_DBTime);
            m_Status |= 0x1;
        }
        return m_NCBITime;
    }

    Int4 GetDays() const {
        if((m_Status & 0x2) == 0) {
            m_DBTime = m_NCBITime.GetTimeDBI();
            m_Status |= 0x2;
        }
        return m_DBTime.days;
    }

    Int4 Get300Secs() const {
        if((m_Status & 0x2) == 0) {
            m_DBTime = m_NCBITime.GetTimeDBI();
            m_Status |= 0x2;
        }
        return m_DBTime.time;
    }

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

protected:
    mutable CTime        m_NCBITime;
    mutable TDBTimeI     m_DBTime;
    // which of m_NCBITime(0x1), m_DBTime(0x2) is valid;  they both can be valid
    mutable unsigned int m_Status;
};



class NCBI_DBAPIDRIVER_EXPORT CDB_Bit : public CDB_Object
{
public:
    CDB_Bit()       : CDB_Object(true)   { return; }
    CDB_Bit(int  i) : CDB_Object(false)  { m_Val = i ? 1 : 0; }
    CDB_Bit(bool i) : CDB_Object(false)  { m_Val = i ? 1 : 0; }

    CDB_Bit& operator= (const int& i) {
        m_Null = false;
        m_Val = i ? 1 : 0;
        return *this;
    }

    CDB_Bit& operator= (const bool& i) {
        m_Null = false;
        m_Val = i ? 1 : 0;
        return *this;
    }

    int   Value()   const  { return m_Null ? 0 : (int) 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_Numeric : public CDB_Object
{
public:
    CDB_Numeric() : CDB_Object(true)  { m_Precision= m_Scale= 0; return; }
    CDB_Numeric(unsigned int precision, unsigned int scale)
        : CDB_Object(false) {
        m_Precision = precision;
        m_Scale     = scale;
        memset(m_Body, 0, sizeof(m_Body));
    }
    CDB_Numeric(unsigned int precision, unsigned int scale,
                const unsigned char* arr)
        : CDB_Object(false) {
        m_Precision = precision;
        m_Scale     = scale;
        memcpy(m_Body, arr, sizeof(m_Body));
    }

    CDB_Numeric(unsigned int precision, unsigned int scale, bool is_negative,
                const unsigned char* arr)
        : CDB_Object(false) {
        m_Precision = precision;
        m_Scale     = scale;
        m_Body[0]= is_negative? 1 : 0;
        memcpy(m_Body+1, arr, sizeof(m_Body)-1);
    }

    CDB_Numeric(unsigned int precision, unsigned int scale, const char* val) {
        x_MakeFromString(precision, scale, val);
    }
    CDB_Numeric(unsigned int precision, unsigned int scale, const string& val) {
        x_MakeFromString(precision, scale, val.c_str());
    }

    CDB_Numeric& Assign(unsigned int precision, unsigned int scale,
                        const unsigned char* arr) {
        m_Precision = precision;
        m_Scale     = scale;
        m_Null      = false;
        memcpy(m_Body, arr, sizeof(m_Body));
        return *this;
    }

    CDB_Numeric& Assign(unsigned int precision, unsigned int scale,
                        bool is_negative, const unsigned char* arr) {
        m_Precision = precision;
        m_Scale     = scale;
        m_Null      = false;
        m_Body[0]= is_negative? 1 : 0;
        memcpy(m_Body + 1, arr, sizeof(m_Body) - 1);
        return *this;
    }

    CDB_Numeric& operator= (const char* val) {
        x_MakeFromString(m_Precision, m_Scale, val);
        return *this;
    }
    CDB_Numeric& operator= (const string& val) {
        x_MakeFromString(m_Precision, m_Scale, val.c_str());
        return *this;
    }

    string Value() const;

    Uint1 Precision() const {
        return m_Precision;
    }

    Uint1 Scale() const {
        return m_Scale;
    }

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

protected:
    void x_MakeFromString(unsigned int precision,
                          unsigned int scale,
                          const char*  val);
    Uint1         m_Precision;
    Uint1         m_Scale;
    unsigned char m_Body[34];
};


END_NCBI_SCOPE

#endif  /* DBAPI_DRIVER___TYPES__HPP */


/* @} */


/*
 * ===========================================================================
 * $Log: types.hpp,v $
 * Revision 1000.0  2003/10/29 20:19:16  gouriano
 * PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R1.17
 *
 * Revision 1.17  2003/05/13 16:54:40  sapojnik
 * CDB_Object::Create() - support for LongChar, LongBinary
 *
 * Revision 1.16  2003/05/05 15:56:15  soussov
 * new default size 8K-1 for CDB_LongChar, CDB_LongBinary
 *
 * Revision 1.15  2003/04/29 21:12:29  soussov
 * new datatypes CDB_LongChar and CDB_LongBinary added
 *
 * Revision 1.14  2003/04/11 17:46:11  siyan
 * Added doxygen support
 *
 * Revision 1.13  2003/01/30 16:06:04  soussov
 * Changes the default from eCurrent to eEmpty for DateTime types
 *
 * Revision 1.12  2002/12/26 19:29:12  dicuccio
 * Added Win32 export specifier for base DBAPI library
 *
 * Revision 1.11  2002/10/07 13:08:32  kans
 * repaired inconsistent newlines caught by Mac compiler
 *
 * Revision 1.10  2002/09/13 18:28:05  soussov
 * fixed bug with long overflow
 *
 * Revision 1.9  2002/05/16 21:27:01  soussov
 * AssignValue methods added
 *
 * Revision 1.8  2002/02/14 00:59:38  vakatov
 * Clean-up: warning elimination, fool-proofing, fine-tuning, identation, etc.
 *
 * Revision 1.7  2002/02/13 22:37:27  sapojnik
 * new_CDB_Object() renamed to CDB_Object::create()
 *
 * Revision 1.6  2002/02/13 22:14:50  sapojnik
 * new_CDB_Object() (needed for rdblib)
 *
 * Revision 1.5  2002/02/06 22:21:58  soussov
 * fixes the numeric default constructor
 *
 * Revision 1.4  2001/12/28 21:22:39  sapojnik
 * Made compatible with MS compiler: long long to Int8, static const within class def to enum
 *
 * Revision 1.3  2001/12/14 17:58:26  soussov
 * fixes bug in datetime related constructors
 *
 * Revision 1.2  2001/11/06 17:58:03  lavr
 * Formatted uniformly as the rest of the library
 *
 * Revision 1.1  2001/09/21 23:39:52  vakatov
 * -----  Initial (draft) revision.  -----
 * This is a major revamp (by Denis Vakatov, with help from Vladimir Soussov)
 * of the DBAPI "driver" libs originally written by Vladimir Soussov.
 * The revamp involved massive code shuffling and grooming, numerous local
 * API redesigns, adding comments and incorporating DBAPI to the C++ Toolkit.
 *
 * ===========================================================================
 */