variant.cpp

ncbi源码

    switch( GetType() ) {
    case eDB_Char:
        return ((CDB_Char*)GetData())->Value();
    case eDB_VarChar:
        return ((CDB_VarChar*)GetData())->Value();
    case eDB_LongChar:
        return ((CDB_LongChar*)GetData())->Value();
    case eDB_Binary:
        {
            CDB_Binary *b = (CDB_Binary*)GetData();
            return string((char*)b->Value(), b->Size());
        }
    case eDB_LongBinary:
        {
            CDB_LongBinary *vb = (CDB_LongBinary*)GetData();
            return string((char*)vb->Value(), vb->Size());
        }
    case eDB_VarBinary:
        {
            CDB_VarBinary *vb = (CDB_VarBinary*)GetData();
            return string((char*)vb->Value(), vb->Size());
        }
    case eDB_TinyInt:
        return NStr::IntToString((long)GetByte()); 
    case eDB_SmallInt:      
        return NStr::IntToString(GetInt2()); 
    case eDB_Int:
        return NStr::IntToString(GetInt4()); 
    case eDB_BigInt:
        return NStr::Int8ToString(GetInt8()); 
    case eDB_Float:
        return NStr::DoubleToString(GetFloat()); 
    case eDB_Double:
        return NStr::DoubleToString(GetDouble()); 
    case eDB_Bit:
        return NStr::BoolToString(GetBit()); 
    case eDB_Numeric:
        return ((CDB_Numeric*)GetData())->Value(); 
    case eDB_DateTime:
    case eDB_SmallDateTime:
        return GetCTime().AsString();
    default:
        break;
    }
  
    throw CVariantException("CVariant::GetString(): type not supported");
}


Int8 CVariant::GetInt8() const
{
    switch( GetType() ) {
    case eDB_BigInt:
        return ((CDB_BigInt*)GetData())->Value();
    case eDB_Int:
        return ((CDB_Int*)GetData())->Value();
    case eDB_SmallInt:
        return ((CDB_SmallInt*)GetData())->Value();
    case eDB_TinyInt:
        return ((CDB_TinyInt*)GetData())->Value();
    default:
        VerifyType(false);
    }
    return 0;
}


Int4 CVariant::GetInt4() const
{
    switch( GetType() ) {
    case eDB_Int:
        return ((CDB_Int*)GetData())->Value();
    case eDB_SmallInt:
        return ((CDB_SmallInt*)GetData())->Value();
    case eDB_TinyInt:
        return ((CDB_TinyInt*)GetData())->Value();
    default:
        VerifyType(false);
    }
    return 0;
}

Int2 CVariant::GetInt2() const
{
    switch( GetType() ) {
    case eDB_SmallInt:
        return ((CDB_SmallInt*)GetData())->Value();
    case eDB_TinyInt:
        return ((CDB_TinyInt*)GetData())->Value();
    default:
        VerifyType(false);
    }
    return 0;
}

Uint1 CVariant::GetByte() const
{
    switch( GetType() ) {
    case eDB_TinyInt:
        return ((CDB_TinyInt*)GetData())->Value();
    default:
        VerifyType(false);
    }
    return 0;
}

float CVariant::GetFloat() const
{
    switch( GetType() ) {
    case eDB_Float:
        return ((CDB_Float*)GetData())->Value();
    case eDB_Int:
        return ((CDB_Int*)GetData())->Value();
    case eDB_SmallInt:
        return ((CDB_SmallInt*)GetData())->Value();
    case eDB_TinyInt:
        return ((CDB_TinyInt*)GetData())->Value();
    default:
        VerifyType(false);
    }
    return 0;
}

double CVariant::GetDouble() const
{
    switch( GetType() ) {
    case eDB_Float:
        return ((CDB_Float*)GetData())->Value();
    case eDB_Double:
        return ((CDB_Double*)GetData())->Value();
    case eDB_Int:
        return ((CDB_Int*)GetData())->Value();
    case eDB_SmallInt:
        return ((CDB_SmallInt*)GetData())->Value();
    case eDB_TinyInt:
        return ((CDB_TinyInt*)GetData())->Value();
    default:
        VerifyType(false);
    }
    return 0;
}

bool CVariant::GetBit() const
{
    VerifyType( GetType() == eDB_Bit );
    return ((CDB_Bit*)GetData())->Value() != 0;
}

string CVariant::GetNumeric() const
{
    VerifyType( GetType() == eDB_Numeric );
    return ((CDB_Numeric*)GetData())->Value();
}

const CTime& CVariant::GetCTime() const
{
    switch(GetType()) {
    case eDB_DateTime:
        return ((CDB_DateTime*)GetData())->Value();
    case eDB_SmallDateTime:
        return ((CDB_SmallDateTime*)GetData())->Value();
    default:
        throw CVariantException("CVariant::GetCTime(): invalid type");
    }
}

string CVariant::AsNotNullString(const string& v) const 
{
    if( IsNull() )
        return v;
    else
        return GetString();
}

bool CVariant::IsNull() const
{
    return GetData() == 0 ? true : GetData()->IsNULL();
}

size_t CVariant::Read(void* buf, size_t len) const
{

    switch(GetType()) {
    case eDB_Image:
    case eDB_Text:
        return ((CDB_Stream*)GetData())->Read(buf, len);

    default:
        throw CVariantException("CVariant::Read(): invalid type");
    }
}

size_t CVariant::Append(const void* buf, size_t len)
{

    switch(GetType()) {
    case eDB_Image:
    case eDB_Text:
        return ((CDB_Stream*)GetData())->Append(buf, len);

    default:
        throw CVariantException("CVariant::Append(): invalid type");
    }
}

size_t CVariant::GetBlobSize() const
{

    switch(GetType()) {
    case eDB_Image:
    case eDB_Text:
        return ((CDB_Stream*)GetData())->Size();

    default:
        throw CVariantException("CVariant::GetBlobSize(): invalid type");
    }
}

void CVariant::Truncate(size_t len)
{

    switch(GetType()) {
    case eDB_Image:
        ((CDB_Image*)GetData())->Truncate(len);
        break;
    case eDB_Text:
        ((CDB_Text*)GetData())->Truncate(len);
        break;
    default:
        throw CVariantException("CVariant::Truncate(): invalid type");
    }
    return;
}

bool CVariant::MoveTo(size_t pos) const
{

    switch(GetType()) {
    case eDB_Image:
        return ((CDB_Image*)GetData())->MoveTo(pos);
        break;
    case eDB_Text:
        return ((CDB_Text*)GetData())->MoveTo(pos);
        break;
    default:
        throw CVariantException("CVariant::MoveTo(): invalid type");
    }
    return false;
}

CVariant& CVariant::operator=(const Int8& v)
{
    VerifyType(GetType() == eDB_BigInt);
    *((CDB_BigInt*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const Int4& v)
{
    VerifyType(GetType() == eDB_Int);
    *((CDB_Int*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const Int2& v)
{
    VerifyType(GetType() == eDB_SmallInt);
    *((CDB_SmallInt*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const Uint1& v)
{
    VerifyType(GetType() == eDB_TinyInt);
    *((CDB_TinyInt*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const float& v)
{
    VerifyType(GetType() == eDB_Float);
    *((CDB_Float*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const double& v)
{
    VerifyType(GetType() == eDB_Double);
    *((CDB_Double*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const string& v)
{
    switch( GetType()) {
    case eDB_VarChar:
        *((CDB_VarChar*)GetData()) = v;
        break;
    case eDB_LongChar:
        *((CDB_LongChar*)GetData()) = v;
        break;
    case eDB_Char:
        *((CDB_Char*)GetData()) = v;
        break;
    default:
        VerifyType(false);
    }

    return *this;
}

CVariant& CVariant::operator=(const char* v)
{
    switch( GetType()) {
    case eDB_VarChar:
        *((CDB_VarChar*)GetData()) = v;
        break;
    case eDB_LongChar:
        *((CDB_LongChar*)GetData()) = v;
        break;
    case eDB_Char:
        *((CDB_Char*)GetData()) = v;
        break;
    default:
        VerifyType(false);
    }

    return *this;
}

CVariant& CVariant::operator=(const bool& v)
{
    VerifyType(GetType() == eDB_Bit);
    *((CDB_Bit*)GetData()) = v;
    return *this;
}

CVariant& CVariant::operator=(const CTime& v)
{
    switch(GetType()) {
    case eDB_DateTime:
        *((CDB_DateTime*)GetData()) = v;
        break;
    case eDB_SmallDateTime:
        *((CDB_SmallDateTime*)GetData()) = v;
        break;
    default:
        VerifyType(false);
    }
    return *this;
}

CVariant& CVariant::operator=(const CVariant& v)
{
    this->m_data->AssignValue(*(v.m_data));
    return *this;
}

bool CVariant::operator< (const CVariant& v) const 
{
    bool less = false;

    if( IsNull() || v.IsNull() ) {
        less = IsNull() && !v.IsNull();
    }
    else {
        if( GetType() != v.GetType() ) {
            throw CVariantException
                ("CVariant::operator<(): cannot compare different types");
        }

        switch( GetType() ) {
        case eDB_Char:
        case eDB_VarChar:
        case eDB_LongChar:
            less = GetString() < v.GetString();
            break;
        case eDB_TinyInt:
            less = GetByte() < v.GetByte();
            break;
        case eDB_SmallInt:      
            less = GetInt2() < v.GetInt2();
            break;
        case eDB_Int:
            less = GetInt4() < v.GetInt4();
            break;
        case eDB_Float:
            less = GetFloat() < v.GetFloat();
            break;
        case eDB_Double:
            less = GetDouble() < v.GetDouble();
            break;
        case eDB_DateTime:
        case eDB_SmallDateTime:
            less = GetCTime() < v.GetCTime();
            break;
        default:
            throw CVariantException
                ("CVariant::operator<(): type not supported");
        }
    }
    return less;
}


END_NCBI_SCOPE