windows-xp/Source/XPSP1/NT/inetsrv/query/h/tblvarnt.hxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1994 - 1999
//
//  File:       tblvarnt.hxx
//
//  Contents:   Helper class for PROPVARIANTs in tables
//
//  Classes:    CTableVariant - PROPVARIANT wrapper; adds useful methods
//
//  History:    28 Jan 1994     AlanW    Created
//
//--------------------------------------------------------------------------

#pragma once

#include <tblalloc.hxx>


// A few useful defines and inline funcs.

#define BSTRLEN(bstrVal)        *((ULONG *) bstrVal - 1)

inline BOOL IsLPWSTR(VARTYPE vt) { return VT_LPWSTR == vt;}
inline BOOL IsLPSTR(VARTYPE vt)  { return VT_LPSTR == vt;}

inline BOOL IsVector(VARTYPE vt) { return 0 != ( vt & VT_VECTOR );}
inline BOOL IsArray(VARTYPE vt)  { return 0 != ( vt & VT_ARRAY );}
inline BOOL IsVectorOrArray(VARTYPE vt)
{
    return 0 != ( vt & (VT_VECTOR | VT_ARRAY));
}

inline BOOL StatusSuccess(DBSTATUS status)
{
    return (status == DBSTATUS_S_OK ||
            status == DBSTATUS_S_ISNULL ||
            status == DBSTATUS_S_TRUNCATED ||
            status == DBSTATUS_S_DEFAULT);
}



//+-------------------------------------------------------------------------
//
//  Class:      CTableVariant
//
//  Purpose:    Wraps PROPVARIANT struct, adding useful methods.
//
//  Interface:
//
//  Notes:      Because the underlying base data *is* a variant, this
//              class cannot have any non-static members (including
//              a vtable).
//
//              This class now deals only with PROPVARIANT. If conversion
//              to other OLE-DB types or Automation variant types is needed,
//              use COLEDBVaraint class (which derives from this class).
//
//              The class is also used to extend the PROPVARIANT for use
//              internally in tables.  For internal storage, the
//              PROPVARIANT.reserved2 field is used to store the total
//              size of variable data pointed to by the variant.
//              Also, the pointers within internal variants may
//              be offsets to storage.  There are three cases of
//              the way offsets may be stored.
//
//              The pointer inside the internal variant structure
//              itself (to a vector, string, blob or UUID) is an
//              offset based from the variable data allocator used
//              to allocate the space.
//
//              For vectors which contain pointers (e.g., vectors of
//              strings), the pointers are stored as offsets based from
//              the vector's address.
//
//              For vectors of variants, the above two rules apply to
//              each embedded variant.  The rules apply recursively to
//              embedded variants which are vectors of variant.
//
//              Use of these rules permits the variable data of a variant
//              to be treated as a unit and to be block copied from place
//              to place without affecting the internally stored offsets.
//
//  History:    21 Mar 1994     AlanW       Created
//              09 Jan 1998     VikasMan    Mofified the class to deal ONLY
//                                          with PROPVARIANTs. Moved rest of
//                                          the functionality in the
//                                          COLEDBVaraiant class
//              01 Sep 1999     KLam        Reinstated FixDataPointers used
//                                          for Win64 Clients -> Win32 Servers
//              04 Nov 1999     KLam        Added VarDataSize32
//                                          for Win64 Servers -> Win32 Clients
//
//--------------------------------------------------------------------------

class   CTableVariant: public tagPROPVARIANT {

public:
    //
    //  varntData is indexed by variant type, and gives the width,
    //  alignment constraints and other information for a scalar
    //  variant type.
    //
    struct VARNT_DATA {
        USHORT  width;                  // width in bytes of data
        USHORT  alignment;              // required alignment of data
        USHORT  flags;                  // flags about variants
    };
    static const VARNT_DATA varntData[], varntExtData[];
    static const unsigned cVarntData, cVarntExtData;

#ifdef _WIN64
    static const VARNT_DATA varntData32[], varntExtData32[];
#endif

    enum varntDataFlags {
        CanBeVector = 1,        // vector forms are permitted
        ByRef = 2,              // variant data has pointer to real data
        CntRef = 4,             // variant data has count followed by pointer
        StoreDirect = 8,        // variant form is indirect, store as fixed
        MultiSize = 0x10,       // used for chapters and bookmarks, for data
                                // like UI1 that is inline in client output
        SimpleType = 0x20,      // simple inline datatype, like VT_I4
        OAType = 0x40,          // valid type for automation VARIANT
    };

    static BOOL IsSimpleType( VARTYPE vtype )
    {
        const VARNT_DATA & rvarInfo = _FindVarType( vtype );

        return ( 0 != ( rvarInfo.flags & SimpleType ) );
    }

    static BOOL IsSimpleOAType( VARTYPE vtype )
    {
        const VARNT_DATA & rvarInfo = _FindVarType( vtype );

        return ( (SimpleType|OAType) == ( rvarInfo.flags & (SimpleType|OAType ) ) );
    }

    static BOOL CanBeVectorType( VARTYPE vtype )
    {
        const VARNT_DATA & rvarInfo = _FindVarType( vtype );

        return ( 0 != ( rvarInfo.flags & CanBeVector ) );
    }

    // NOTE: in NT5, VARIANT can include additional types.  This operates on
    //       the traditional types so old clients can understand the variants
    //       we produce.
    static BOOL IsOAType( VARTYPE vtype )
    {
        const VARNT_DATA & rvarInfo = _FindVarType( vtype );

        return ( 0 != ( rvarInfo.flags & OAType ) );
    }

    static BOOL IsByRef( VARTYPE vtype )
    {
        const VARNT_DATA & rvarInfo = _FindVarType( vtype );
        return ( 0 != ( rvarInfo.flags & ByRef ) );
    }

    //
    //  Return information about a variant's base type
    //
    static void VartypeInfo(VARTYPE vtype, USHORT& rcbWidth,
                            USHORT& rcbAlign, USHORT& rgfFlags) {
        const VARNT_DATA& rvarInfo = _FindVarType(vtype);

        rcbWidth  = rvarInfo.width;
        rcbAlign = rvarInfo.alignment;
        rgfFlags  = rvarInfo.flags;

        if (vtype & VT_VECTOR) {
            rgfFlags |= CntRef;
        }
        return;
    }

    //
    // Check if a type is stored in-line in a table row.
    //
    static BOOL TableIsStoredInline( USHORT fFlags, VARTYPE vtype )
    {
        if (vtype & (VT_ARRAY | VT_VECTOR | VT_BYREF) ||
            vtype == VT_VARIANT ||
            (fFlags & (CntRef | ByRef) && ! (fFlags & StoreDirect)))
            return FALSE;

        return TRUE;
    }

    static void Free(BYTE *          pbData,
                     VARTYPE         vtData,
                     PVarAllocator & rPool);

    //
    //  Return TRUE iff the variant's type is valid for a property.
    //
    BOOL IsValidType(void) const
    {
        // NOTE: we don't expect VT_BYREF in our stored variants
        if ( (vt & ~(VT_TYPEMASK | VT_VECTOR | VT_ARRAY)) != 0 ||
             (vt & (VT_VECTOR | VT_ARRAY)) == (VT_VECTOR | VT_ARRAY) )
            return FALSE;

        const VARNT_DATA& rvarInfo = _FindVarType(vt);

        if (vt & VT_VECTOR)
            return ((rvarInfo.flags & CanBeVector) == CanBeVector);

        if (vt & VT_ARRAY)
            return ((rvarInfo.flags & (OAType|CanBeVector)) != 0);

        return rvarInfo.width != 0;
    }

    //
    //  Return TRUE iff the variant contains a pointer at offset 8
    //
    BOOL VariantPointerInFirstWord (void) const
    {
        return ( (vt & (VT_ARRAY | VT_BYREF)) != 0 ||
                 ( (vt & VT_VECTOR) == 0 &&
                   (_FindVarType(vt).flags & ByRef) == ByRef) );
//      return ((vt == VT_CLSID) ||
//              (vt == VT_LPWSTR) ||
//              (vt == VT_LPSTR) ||
//              (vt == VT_BSTR) ||
//              (vt == VT_CF) ||
//              (vt == VT_STREAM) ||
//              (vt == VT_STREAMED_OBJECT) ||
//              (vt == VT_STORAGE) ||
//              (vt == VT_STORED_OBJECT));
    }

    //
    //  Return TRUE iff the variant contains a pointer at offset 0xC
    //
    BOOL VariantPointerInSecondWord (void) const
    {
        return ( (vt & VT_VECTOR) == VT_VECTOR ||
                 ( (vt & (VT_ARRAY | VT_BYREF)) == 0 &&
                   (_FindVarType(vt).flags & CntRef) == CntRef) );
    }

    //
    //  Copy data stored outside the variant structure itself
    //

    void        Copy(   CTableVariant* pvarntDest,
                        PVarAllocator &rVarAllocator,
                        USHORT cbDest,
                        BYTE* pbBias = 0) const;

    void        OffsetsToPointers(PVarAllocator &rPool)
    {
        if ( VariantPointerInFirstWord() )
            pszVal = (LPSTR) rPool.OffsetToPointer((ULONG_PTR) pszVal);
        else if ( VariantPointerInSecondWord() )
            blob.pBlobData = (BYTE *) rPool.OffsetToPointer((ULONG_PTR) blob.pBlobData);
    }

    DBSTATUS    CopyOrCoerce( BYTE *           pbDest,
                              DBLENGTH         cbDest,
                              VARTYPE          vtDest,
                              DBLENGTH &       rcbDstLen,
                              PVarAllocator &  rVarAllocator) const;

    //
    //  Compute variable data size
    //
    ULONG       VarDataSize (void) const;

#ifdef _WIN64
    //
    //  Convert offsets to pointers in variable data (32server->64client)
    //
    void        FixDataPointers( BYTE* pbBias, CFixedVarAllocator *pAlloc );

    //
    //  Compute variable data size for 32 bit
    //
    ULONG       VarDataSize32 ( BYTE *pbBase,
                                ULONG_PTR ulpOffset ) const;

    //
    // Compute the size of a safearray for 32 bit
    //
    static ULONG       SaComputeSize32 ( VARTYPE vt,
                                         SAFEARRAY & saSrc,
                                         BYTE *pbBase,
                                         ULONG_PTR ulpOffset );

    //
    //  Return information about a variant's base type
    //
    static void VartypeInfo32( VARTYPE vtype, USHORT& rcbWidth,
                               USHORT& rcbAlign, USHORT& rgfFlags) {
        const VARNT_DATA& rvarInfo = _FindVarType32(vtype);

        rcbWidth  = rvarInfo.width;
        rcbAlign = rvarInfo.alignment;
        rgfFlags  = rvarInfo.flags;

        if (vtype & VT_VECTOR) {
            rgfFlags |= CntRef;
        }
        return;
    }

#endif

    //
    //  Initialize a variant from base parts
    //
    void        Init( VARTYPE vt,
                      BYTE* pbData = 0,
                      ULONG cbData = 0);

protected:
    enum { ulCoercionCodePage = CP_ACP };

    DBSTATUS    _StoreString(BYTE *               pbDstBuf,
                             DBLENGTH             cbDstBuf,
                             VARTYPE              vtDst,
                             DBLENGTH &           rcbDstLen,
                             PVarAllocator &      rPool) const;

    DBSTATUS    _StoreDecimal(DECIMAL *           pDecimal,
                              LONG                lElem = 0) const;

    DBSTATUS    _StoreInteger(VARTYPE             vtDst,
                              BYTE *              pbDstBuf,
                              LONG                lElem = 0) const;
    DBSTATUS    _StoreIntegerUnSignedToSigned(  VARTYPE  vtDst,
                                                BYTE *   pbDstBuf,
                                                LONG     lElem = 0) const;
    DBSTATUS    _StoreIntegerSignedToSigned(    VARTYPE  vtDst,
                                                BYTE *   pbDstBuf,
                                                LONG     lElem = 0) const;
    DBSTATUS    _StoreIntegerUnSignedToUnSigned(VARTYPE  vtDst,
                                                BYTE *   pbDstBuf,
                                                LONG     lElem = 0) const;
    DBSTATUS    _StoreIntegerSignedToUnSigned(  VARTYPE  vtDst,
                                                BYTE *   pbDstBuf,
                                                LONG     lElem = 0) const;

private:
    void        SetDataSize (ULONG cbVarData);
    void        ResetDataSize ();

    VOID *      CopyData( PVarAllocator &rVarAllocator,
                          USHORT cbDest,
                          BYTE* pbBias = 0) const;

    static const USHORT _wInternalSig;
    inline BOOL _IsInternalVariant( void ) const;
    static inline const VARNT_DATA& _FindVarType( VARTYPE vt );

#ifdef _WIN64
    static inline const VARNT_DATA& _FindVarType32( VARTYPE vt );
#endif

    DBSTATUS    _GetUL8Value(ULONGLONG * ul8Value, LONG lElem = 0L) const;
    DBSTATUS    _GetL8Value(LONGLONG * l8Value, LONG lElem = 0L ) const;

};

const USHORT minExtVariantType = 128;

#ifdef _WIN64

//+-------------------------------------------------------------------------
//
//  Method:     CTableVariant::_FindVarType32, inline private
//
//  Synopsis:   Return a 32 bit description of a variant given its type
//
//  Arguments:  [vt] - the variant type to be looked up
//
//  Returns:    VARNT_DATA& - a reference to the variant type information
//
//--------------------------------------------------------------------------

inline const CTableVariant::VARNT_DATA& CTableVariant::_FindVarType32(
    VARTYPE vtype
) {
    USHORT vtBase = vtype & VT_TYPEMASK;

    if (vtBase < cVarntData)
    {
        return varntData32[vtBase];
    }
    else if (vtBase >= minExtVariantType &&
             vtBase < minExtVariantType + cVarntExtData)
    {
        return varntExtData32[ vtBase - minExtVariantType ];
    }
    else
    {
        return varntData32[0];    // return ref. to VT_EMPTY info
    }
}

#endif // _WIN64

//+-------------------------------------------------------------------------
//
//  Method:     CTableVariant::_FindVarType, inline private
//
//  Synopsis:   Return a description of a variant given its type
//
//  Arguments:  [vt] - the variant type to be looked up
//
//  Returns:    VARNT_DATA& - a reference to the variant type information
//
//--------------------------------------------------------------------------

inline const CTableVariant::VARNT_DATA& CTableVariant::_FindVarType(
    VARTYPE vtype
) {
    USHORT vtBase = vtype & VT_TYPEMASK;

    if (vtBase < cVarntData)
    {
        return varntData[vtBase];
    }
    else if (vtBase >= minExtVariantType &&
             vtBase < minExtVariantType + cVarntExtData)
    {
        return varntExtData[ vtBase - minExtVariantType ];
    }
    else
    {
        return varntData[0];    // return ref. to VT_EMPTY info
    }
}


//+-------------------------------------------------------------------------
//
//  Method:     CTableVariant::_IsInternalVariant, inline private
//
//  Synopsis:   Return whether the variant is an internal form with
//              pointers stored as offsets and variable data embedded.
//
//  Arguments:  -None-
//
//  Returns:    BOOL - TRUE if the variant is in internal form.
//
//--------------------------------------------------------------------------

inline BOOL CTableVariant::_IsInternalVariant(
    void
) const {
    return (wReserved1 == _wInternalSig &&
            wReserved3 == _wInternalSig &&
            VT_DECIMAL != vt);
}

//+-------------------------------------------------------------------------
//
//  Method:     CTableVariant::SetDataSize, public
//
//  Synopsis:   Set variable data size for an internal variant
//
//  Arguments:  [cbVarData] - length of variable data associated with
//                      the variant.
//
//  Returns:    -Nothing-
//
//  Notes:      For variants which are stored internally in the table,
//              the size is computed once and stored in the wReserved2
//              field of the variant structure.
//
//--------------------------------------------------------------------------

inline void CTableVariant::SetDataSize (ULONG cbVarData)
{
    Win4Assert(cbVarData <= USHRT_MAX);

    if (vt != VT_DECIMAL)              // this uses the reserved fields
    {
        wReserved2 = (USHORT)cbVarData;

        //
        // Put a signature value in the variant to distinguish internal
        // vs. external variants.
        //
        wReserved1 = wReserved3 = _wInternalSig;
    }
}


inline void CTableVariant::ResetDataSize ()
{
    if (vt != VT_DECIMAL)
        wReserved1 = wReserved2 = wReserved3 = 0;
}



//+-------------------------------------------------------------------------
//
//  Member:     CTableVariant::_StoreDecimal, private
//
//  Synopsis:   Copy variant integer data, coercing to VT_DECIMAL
//
//  Arguments:  [pDec]      -- destination buffer
//              [lElem]     -- element of vector to convert
//
//  Returns:    status for copy
//
//  History:    25 Nov 1996     AlanW   Created
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_StoreDecimal( DECIMAL *   pDec,
                                              LONG        lElem ) const
{
    ULONGLONG ul8Value = 0;

    Win4Assert( (vt & VT_TYPEMASK) != VT_DECIMAL );

    DBSTATUS DstStatus = _GetUL8Value (&ul8Value, lElem);

    if (DBSTATUS_S_OK == DstStatus)
    {
        pDec->scale = 0;
        pDec->sign = 0;
        pDec->Hi32 = 0;
        pDec->Lo64 = ul8Value;
    }
    else if ( DBSTATUS_E_CANTCONVERTVALUE == DstStatus )
    {
        LONGLONG l8Value;
        DstStatus = _GetL8Value (&l8Value, lElem);

        if (DBSTATUS_S_OK == DstStatus)
        {
            pDec->scale = 0;
            pDec->Hi32 = 0;
            if ( l8Value < 0 )
            {
                pDec->sign = DECIMAL_NEG;
                pDec->Lo64 = -l8Value;
            }
            else
            {
                pDec->sign = 0;
                pDec->Lo64 = l8Value;
            }
        }
    }

    return DstStatus;
} //_StoreDecimal


//+-------------------------------------------------------------------------
//
//  Member:     CTableVariant::_StoreIntegerUnSignedToSigned, private
//
//  Synopsis:   Copy variant integer data, coerce if possible
//
//  Arguments:  [vtDst]         -- type of the destination
//              [pbDstBuf]      -- destination buffer
//              [lElem]         -- element of vector to convert
//
//  Returns:    status for copy
//
//  History:    24 Jul 1995     dlee    Created
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_StoreIntegerUnSignedToSigned(
                                                            VARTYPE  vtDst,
                                                            BYTE *   pbDstBuf,
                                                            LONG     lElem ) const
{
    ULONGLONG ul8Value = 0;
    DBSTATUS DstStatus = _GetUL8Value(&ul8Value, lElem);

    // Store the ULONGLONG assuming alignment verified at accessor creation
    if (DBSTATUS_S_OK == DstStatus)
    {
        switch ( vtDst )
        {
        case VT_I1 :
            * (signed char *) pbDstBuf = (signed char) ul8Value;
            if ( ul8Value > SCHAR_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        case VT_I2 :
            * (short *) pbDstBuf = (short) ul8Value;
            if ( ul8Value > SHRT_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        case VT_I4 :
        case VT_INT :
            * (long *) pbDstBuf = (long) ul8Value;
            if ( ul8Value > LONG_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        case VT_I8 :
            * (LONGLONG *) pbDstBuf = (LONGLONG) ul8Value;
            if ( ul8Value > _I64_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        default:
            //tbDebugOut(( DEB_WARN, "US bad dst type %4x\n", vtDst ));
            DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
            break;
        }
    }

    return DstStatus;
} //_StoreIntegerUnSignedToSigned

//+-------------------------------------------------------------------------
//
//  Member:     CTableVariant::_StoreIntegerUnSignedToUnSigned, private
//
//  Synopsis:   Copy variant integer data, coerce if possible
//
//  Arguments:  [vtDst]         -- type of the destination
//              [pbDstBuf]      -- destination buffer
//              [lElem]         -- element of vector to convert
//
//  Returns:    status for copy
//
//  History:    24 Jul 1995     dlee    Created
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_StoreIntegerUnSignedToUnSigned(
                                                              VARTYPE  vtDst,
                                                              BYTE *   pbDstBuf,
                                                              LONG     lElem ) const
{
    ULONGLONG ul8Value;
    DBSTATUS DstStatus = _GetUL8Value(&ul8Value, lElem);

    // Store the ULONGLONG assuming alignment verified at accessor creation
    if (DBSTATUS_S_OK == DstStatus)
    {
        switch ( vtDst )
        {
        case VT_UI1 :
            * (unsigned char *) pbDstBuf = (char) ul8Value;
            if ( ul8Value > UCHAR_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;

        case VT_UI2 :
            * (unsigned short *) pbDstBuf = (unsigned short) ul8Value;
            if ( ul8Value > USHRT_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;

        case VT_UI4 :
        case VT_UINT :
            * (unsigned long *) pbDstBuf = (unsigned long) ul8Value;
            if ( ul8Value > ULONG_MAX )
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;

        case VT_UI8 :
            * (ULONGLONG *) pbDstBuf = ul8Value;
            break;

        default:
            //tbDebugOut(( DEB_WARN, "UU bad dst type %4x\n", vtDst ));
            DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
            break;
        }
    }

    return DstStatus;
} //_StoreIntegerUnSignedToUnSigned

//+-------------------------------------------------------------------------
//
//  Member:     CTableVariant::_StoreIntegerSignedToUnSigned, private
//
//  Synopsis:   Copy variant integer data, coerce if possible
//
//  Arguments:  [vtDst]         -- type of the destination
//              [pbDstBuf]      -- destination buffer
//              [lElem]         -- element of vector to convert
//
//  Returns:    status for copy
//
//  History:    24 Jul 1995     dlee    Created
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_StoreIntegerSignedToUnSigned(
                                                            VARTYPE  vtDst,
                                                            BYTE *   pbDstBuf,
                                                            LONG     lElem ) const
{
    LONGLONG l8Value;
    DBSTATUS DstStatus = _GetL8Value( &l8Value, lElem ) ;

    // Store the LONGLONG assuming alignment verified at accessor creation
    if (DBSTATUS_S_OK == DstStatus)
    {
        if ( l8Value < 0 )
            DstStatus = DBSTATUS_E_SIGNMISMATCH;
        else
        {
            switch ( vtDst )
            {
            case VT_UI1 :
                * (unsigned char *) pbDstBuf = (unsigned char) l8Value;
                if ( l8Value > UCHAR_MAX )
                    DstStatus = DBSTATUS_E_DATAOVERFLOW;
                break;
            case VT_UI2 :
                * (unsigned short *) pbDstBuf = (unsigned short) l8Value;
                if ( l8Value > USHRT_MAX )
                    DstStatus = DBSTATUS_E_DATAOVERFLOW;
                break;
            case VT_UI4 :
            case VT_UINT :
                * (unsigned long *) pbDstBuf = (unsigned long) l8Value;
                if ( l8Value > ULONG_MAX )
                    DstStatus = DBSTATUS_E_DATAOVERFLOW;
                break;
            case VT_UI8 :
                * (ULONGLONG *) pbDstBuf = (ULONGLONG) l8Value;
                break;
            default:
                //tbDebugOut(( DEB_WARN, "SU bad dst type %4x\n", vtDst ));
                DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
                break;
            }
        }
    }

    return DstStatus;
} //_StoreIntegerSignedToUnSigned

//+-------------------------------------------------------------------------
//
//  Member:     CTableVariant::_StoreIntegerSignedToSigned, private
//
//  Synopsis:   Copy variant integer data, coerce if possible
//
//  Arguments:  [vtDst]         -- type of the destination
//              [pbDstBuf]      -- destination buffer
//              [lElem]         -- element of vector to convert
//
//  Returns:    status for copy
//
//  History:    24 Jul 1995     dlee    Created
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_StoreIntegerSignedToSigned(
                                                          VARTYPE  vtDst,
                                                          BYTE *   pbDstBuf,
                                                          LONG     lElem ) const
{
    LONGLONG l8Value = 0;
    DBSTATUS DstStatus = _GetL8Value ( &l8Value, lElem );


    // Store the ULONGLONG assuming alignment verified at accessor creation
    if (DBSTATUS_S_OK == DstStatus)
    {
        switch ( vtDst )
        {
        case VT_I1 :
            * (signed char *) pbDstBuf = (signed char) l8Value;
            if (l8Value < SCHAR_MIN || l8Value > SCHAR_MAX)
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        case VT_I2 :
            * (short *) pbDstBuf = (short) l8Value;
            if (l8Value < SHRT_MIN || l8Value > SHRT_MAX)
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        case VT_I4 :
            * (long *) pbDstBuf = (long) l8Value;
            if (l8Value < LONG_MIN || l8Value > LONG_MAX)
                DstStatus = DBSTATUS_E_DATAOVERFLOW;
            break;
        case VT_I8 :
            * (LONGLONG *) pbDstBuf = l8Value;
            break;
        default:
            //tbDebugOut(( DEB_WARN, "SS bad dst type %4x\n", vtDst ));
            DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
            break;
        }
    }

    return DstStatus;
} //_StoreIntegerSignedToSigned


//+-------------------------------------------------------------------------
//
//  Member:     CTableVariant::_StoreInteger, private
//
//  Synopsis:   Copy variant integer data, coerce if possible
//
//  Arguments:  [vtDst]         -- type of the destination
//              [pbDstBuf]      -- destination buffer
//              [lElem]         -- element of vector to convert
//
//  Returns:    status for copy
//
//  History:    24 Jul 1995     dlee    Rewrote to support unsigned values
//
//--------------------------------------------------------------------------

inline BOOL isSignedInteger( VARTYPE vt )
{
    return ( VT_I1  == vt ||
             VT_I2  == vt ||
             VT_I4  == vt ||
             VT_INT == vt ||
             VT_I8  == vt ||
             VT_BOOL == vt );
} //isSignedInteger

inline DBSTATUS CTableVariant::_StoreInteger(
                                            VARTYPE  vtDst,
                                            BYTE *   pbDstBuf,
                                            LONG     lElem ) const
{
    // vt is the type of the source of the data

    Win4Assert( vt == VT_I1       ||
                vt == VT_UI1      ||
                vt == VT_I2       ||
                vt == VT_UI2      ||
                vt == VT_I4       ||
                vt == VT_UI4      ||
                vt == VT_I8       ||
                vt == VT_UI8      ||
                vt == VT_INT      ||
                vt == VT_UINT     ||
                vt == VT_BOOL     ||
                vt == VT_ERROR    ||
                vt == VT_HRESULT  ||
                vt == VT_FILETIME ||
                vt == VT_EMPTY    ||         // empty if object is deleted
                vt == (VT_I1   | VT_VECTOR) ||
                vt == (VT_UI1  | VT_VECTOR) ||
                vt == (VT_I2   | VT_VECTOR) ||
                vt == (VT_UI2  | VT_VECTOR) ||
                vt == (VT_I4   | VT_VECTOR) ||
                vt == (VT_UI4  | VT_VECTOR) ||
                vt == (VT_I8   | VT_VECTOR) ||
                vt == (VT_UI8  | VT_VECTOR) ||
                vt == (VT_BOOL | VT_VECTOR) ||
                vt == (VT_ERROR | VT_VECTOR) ||
                vt == (VT_FILETIME | VT_VECTOR));

    BOOL fSrcSigned = isSignedInteger( vt & VT_TYPEMASK );
    BOOL fDstSigned = isSignedInteger( vtDst );

    if ( fSrcSigned && fDstSigned )
        return _StoreIntegerSignedToSigned( vtDst, pbDstBuf, lElem );
    else if ( fSrcSigned && !fDstSigned )
        return _StoreIntegerSignedToUnSigned( vtDst, pbDstBuf, lElem );
    else if ( !fSrcSigned && fDstSigned )
        return _StoreIntegerUnSignedToSigned( vtDst, pbDstBuf, lElem );
    else
        return _StoreIntegerUnSignedToUnSigned( vtDst, pbDstBuf, lElem );

} //_StoreInteger

//+-------------------------------------------------------------------------
//
//  Method:     CTableVariant::_GetL8Value, private
//
//  Synopsis:   Converts the variant value to a LONGLONG
//
//  Arguments:  [*l8Value] - LONGLONG value on return
//              [lElem] - for vector variants, the element whose value is
//                        to be converted
//
//  Returns:    DBSTATUS
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_GetL8Value(LONGLONG * l8Value, LONG lElem ) const
{
    *l8Value = 0;
    DBSTATUS DstStatus = DBSTATUS_S_OK;

    Win4Assert((lElem == 0) || (vt & DBTYPE_VECTOR));

    switch ( vt )  // type of the source
    {
    case VT_I1:
        *l8Value = (CHAR)bVal;
        break;

    case VT_I2:
    case VT_BOOL:
        *l8Value = iVal;
        break;

    case VT_I4:
    case VT_INT :
        *l8Value = lVal;
        break;

    case VT_I8:
        *l8Value = hVal.QuadPart;
        break;

    case VT_EMPTY:
    case VT_NULL :
        DstStatus = DBSTATUS_S_ISNULL;
        break;

    case VT_I1 | VT_VECTOR: // no i1 vector struct definition use UI1 and cast
        *l8Value = (CHAR)caub.pElems[lElem];
        break;

    case VT_I2 | VT_VECTOR:
        *l8Value = cai.pElems[lElem];
        break;

    case VT_I4 | VT_VECTOR:
        *l8Value = cal.pElems[lElem];
        break;

    case VT_I8 | VT_VECTOR:
        *l8Value = cah.pElems[lElem].QuadPart;
        break;

    default:
        //tbDebugOut(( DEB_WARN, "_GetL8Value bad src type %4x\n", vt ));
        DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
        break;
    }
    return DstStatus;
}

//+-------------------------------------------------------------------------
//
//  Method:     CTableVariant::_GetUL8Value, private
//
//  Synopsis:   Converts the variant value to a ULONGLONG
//
//  Arguments:  [*ul8Value] - ULONGLONG value on return
//              [lElem] - for vector variants, the element whose value is
//                        to be converted
//
//  Returns:    DBSTATUS
//
//--------------------------------------------------------------------------

inline DBSTATUS CTableVariant::_GetUL8Value(ULONGLONG * ul8Value, LONG lElem ) const
{
    *ul8Value = 0;
    DBSTATUS DstStatus = DBSTATUS_S_OK;

    Win4Assert((lElem == 0) || (vt & DBTYPE_VECTOR));

    switch ( vt )  // type of the source
    {
    case VT_UI1:
        *ul8Value = bVal;
        break;

    case VT_UI2:
        *ul8Value = uiVal;
        break;

    case VT_UI4:
    case VT_UINT :
    case VT_ERROR :
    case VT_HRESULT :
        *ul8Value = ulVal;
        break;

    case VT_UI8:
    case VT_FILETIME :
        *ul8Value = uhVal.QuadPart;
        break;

    case VT_EMPTY:
    case VT_NULL :
        DstStatus = DBSTATUS_S_ISNULL;
        break;

    case VT_UI1 | VT_VECTOR:
        *ul8Value = caub.pElems[lElem];
        break;

    case VT_UI2 | VT_VECTOR:
        *ul8Value = caui.pElems[lElem];
        break;

    case VT_BOOL | VT_VECTOR :
        *ul8Value = cabool.pElems[lElem];
        break;

    case VT_UI4 | VT_VECTOR:
        *ul8Value = caul.pElems[lElem];
        break;

    case VT_ERROR | VT_VECTOR:
        *ul8Value = cascode.pElems[lElem];
        break;

    case VT_UI8 | VT_VECTOR:
        *ul8Value = cauh.pElems[lElem].QuadPart;
        break;

    case VT_FILETIME | VT_VECTOR:
        *ul8Value = ((ULARGE_INTEGER *)(&cafiletime.pElems[lElem]))->QuadPart;
        break;

    default:
        //tbDebugOut(( DEB_WARN, "_GetUL8Value bad src type %4x\n", vt ));
        DstStatus = DBSTATUS_E_CANTCONVERTVALUE;
        break;
    }
    return DstStatus;

}