_variant_t Class Reference

#include <comutil.h>

Inheritance diagram for _variant_t:

Public Member Functions
	_variant_t () throw ()
	_variant_t (const VARIANT &varSrc)
	_variant_t (const VARIANT *pSrc)
	_variant_t (const _variant_t &varSrc)
	_variant_t (VARIANT &varSrc, bool fCopy)
	_variant_t (short sSrc, VARTYPE vtSrc=VT_I2)
	_variant_t (long lSrc, VARTYPE vtSrc=VT_I4)
	_variant_t (float fltSrc) throw ()
	_variant_t (double dblSrc, VARTYPE vtSrc=VT_R8)
	_variant_t (const CY &cySrc) throw ()
	_variant_t (const _bstr_t &bstrSrc)
	_variant_t (const wchar_t *pSrc)
	_variant_t (const char *pSrc)
	_variant_t (IDispatch *pSrc, bool fAddRef=true) throw ()
	_variant_t (bool boolSrc) throw ()
	_variant_t (IUnknown *pSrc, bool fAddRef=true) throw ()
	_variant_t (const DECIMAL &decSrc) throw ()
	_variant_t (BYTE bSrc) throw ()
	_variant_t (char cSrc) throw ()
	_variant_t (unsigned short usSrc) throw ()
	_variant_t (unsigned long ulSrc) throw ()
	_variant_t (int iSrc) throw ()
	_variant_t (unsigned int uiSrc) throw ()
	~_variant_t () throw ()
	operator short () const
	operator long () const
	operator float () const
	operator double () const
	operator CY () const
	operator _bstr_t () const
	operator IDispatch * () const
	operator bool () const
	operator IUnknown * () const
	operator DECIMAL () const
	operator BYTE () const
	operator VARIANT () const throw ()
	operator char () const
	operator unsigned short () const
	operator unsigned long () const
	operator int () const
	operator unsigned int () const
_variant_t &	operator= (const VARIANT &varSrc)
_variant_t &	operator= (const VARIANT *pSrc)
_variant_t &	operator= (const _variant_t &varSrc)
_variant_t &	operator= (short sSrc)
_variant_t &	operator= (long lSrc)
_variant_t &	operator= (float fltSrc)
_variant_t &	operator= (double dblSrc)
_variant_t &	operator= (const CY &cySrc)
_variant_t &	operator= (const _bstr_t &bstrSrc)
_variant_t &	operator= (const wchar_t *pSrc)
_variant_t &	operator= (const char *pSrc)
_variant_t &	operator= (IDispatch *pSrc)
_variant_t &	operator= (bool boolSrc)
_variant_t &	operator= (IUnknown *pSrc)
_variant_t &	operator= (const DECIMAL &decSrc)
_variant_t &	operator= (BYTE bSrc)
_variant_t &	operator= (char cSrc)
_variant_t &	operator= (unsigned short usSrc)
_variant_t &	operator= (unsigned long ulSrc)
_variant_t &	operator= (int iSrc)
_variant_t &	operator= (unsigned int uiSrc)
bool	operator== (const VARIANT &varSrc) const throw ()
bool	operator== (const VARIANT *pSrc) const throw ()
bool	operator!= (const VARIANT &varSrc) const throw ()
bool	operator!= (const VARIANT *pSrc) const throw ()
void	Clear ()
void	Attach (VARIANT &varSrc)
VARIANT	Detach () throw ()
VARIANT &	GetVARIANT () throw ()
VARIANT *	GetAddress ()
void	ChangeType (VARTYPE vartype, const _variant_t *pSrc=NULL)
void	SetString (const char *pSrc)

Constructor & Destructor Documentation

_variant_t::_variant_t ( ) throw ( )

inline

{
    ::VariantInit(this);
}

_variant_t::_variant_t ( const VARIANT &  varSrc )

inline

{
    ::VariantInit(this);
    _com_util::CheckError(::VariantCopy(this, const_cast<VARIANT*>(&varSrc)));
}

_variant_t::_variant_t ( const VARIANT *  pSrc )

inline

{
    if (pSrc == NULL) {
        _com_issue_error(E_POINTER);
    }
    else {
        ::VariantInit(this);
        _com_util::CheckError(::VariantCopy(this, const_cast<VARIANT*>(pSrc)));
    }
}

_variant_t::_variant_t ( const _variant_t &  varSrc )

inline

{
    ::VariantInit(this);
    _com_util::CheckError(::VariantCopy(this, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))));
}

_variant_t::_variant_t ( VARIANT &  varSrc, bool  fCopy  )

inline

{
    if (fCopy) {
        ::VariantInit(this);
        _com_util::CheckError(::VariantCopy(this, &varSrc));
    } 
    else {
        _COM_MEMCPY_S(this, sizeof(varSrc), &varSrc, sizeof(varSrc));
        V_VT(&varSrc) = VT_EMPTY;
    }
}

_variant_t::_variant_t ( short  sSrc, VARTYPE  vtSrc = VT_I2  )

inline

{
    if ((vtSrc != VT_I2) && (vtSrc != VT_BOOL)) {
        _com_issue_error(E_INVALIDARG);
        return;
    }

    if (vtSrc == VT_BOOL) {
        V_VT(this) = VT_BOOL;
        V_BOOL(this) = (sSrc ? VARIANT_TRUE : VARIANT_FALSE);
    }
    else {
        V_VT(this) = VT_I2;
        V_I2(this) = sSrc;
    }
}

_variant_t::_variant_t ( long  lSrc, VARTYPE  vtSrc = VT_I4  )

inline

{
    if ((vtSrc != VT_I4) && (vtSrc != VT_ERROR) && (vtSrc != VT_BOOL)) {
        _com_issue_error(E_INVALIDARG);
        return;
    }

    if (vtSrc == VT_ERROR) {
        V_VT(this) = VT_ERROR;
        V_ERROR(this) = lSrc;
    }
    else if (vtSrc == VT_BOOL) {
        V_VT(this) = VT_BOOL;
        V_BOOL(this) = (lSrc ? VARIANT_TRUE : VARIANT_FALSE);
    }
    else {
        V_VT(this) = VT_I4;
        V_I4(this) = lSrc;
    }
}

_variant_t::_variant_t ( float  fltSrc ) throw ( )

inline

{
    V_VT(this) = VT_R4;
    V_R4(this) = fltSrc;
}

_variant_t::_variant_t ( double  dblSrc, VARTYPE  vtSrc = VT_R8  )

inline

{
    if ((vtSrc != VT_R8) && (vtSrc != VT_DATE)) {
        _com_issue_error(E_INVALIDARG);
        return;
    }

    if (vtSrc == VT_DATE) {
        V_VT(this) = VT_DATE;
        V_DATE(this) = dblSrc;
    }
    else {
        V_VT(this) = VT_R8;
        V_R8(this) = dblSrc;
    }
}

_variant_t::_variant_t ( const CY &  cySrc ) throw ( )

inline

{
    V_VT(this) = VT_CY;
    V_CY(this) = cySrc;
}

_variant_t::_variant_t ( const _bstr_t &  bstrSrc )

inline

{
    V_VT(this) = VT_BSTR;

    BSTR bstr = static_cast<wchar_t*>(bstrSrc);
    if (bstr == NULL) {
        V_BSTR(this) = NULL;
    }
    else {
        V_BSTR(this) = ::SysAllocStringByteLen(reinterpret_cast<char*>(bstr),
                                               ::SysStringByteLen(bstr));
        if (V_BSTR(this) == NULL) {
            _com_issue_error(E_OUTOFMEMORY);
        }
    }
}

_variant_t::_variant_t ( const wchar_t *  pSrc )

inline

{
    V_VT(this) = VT_BSTR;

    V_BSTR(this) = ::SysAllocString(pSrc);

    if (V_BSTR(this) == NULL && pSrc != NULL) {
            _com_issue_error(E_OUTOFMEMORY);
    }
}

_variant_t::_variant_t ( const char *  pSrc )

inline

{
    V_VT(this) = VT_BSTR;
    V_BSTR(this) = _com_util::ConvertStringToBSTR(pSrc);
}

_variant_t::_variant_t ( IDispatch *  pSrc, bool  fAddRef = true  ) throw ( )

inline

{
    V_VT(this) = VT_DISPATCH;
    V_DISPATCH(this) = pSrc;

    // Need the AddRef() as VariantClear() calls Release(), unless fAddRef
    // false indicates we're taking ownership
    //
    if (fAddRef) {
        if (V_DISPATCH(this) != NULL) {
            V_DISPATCH(this)->AddRef();
        }
    }
}

_variant_t::_variant_t ( bool  boolSrc ) throw ( )

inline

{
    V_VT(this) = VT_BOOL;
    V_BOOL(this) = (boolSrc ? VARIANT_TRUE : VARIANT_FALSE);
}

_variant_t::_variant_t ( IUnknown *  pSrc, bool  fAddRef = true  ) throw ( )

inline

{
    V_VT(this) = VT_UNKNOWN;
    V_UNKNOWN(this) = pSrc;

    // Need the AddRef() as VariantClear() calls Release(), unless fAddRef
    // false indicates we're taking ownership
    //
    if (fAddRef) {
        if (V_UNKNOWN(this) != NULL) {
            V_UNKNOWN(this)->AddRef();
        }
    }
}

_variant_t::_variant_t ( const DECIMAL &  decSrc ) throw ( )

inline

{
    // Order is important here! Setting V_DECIMAL wipes out the entire VARIANT
    //
    V_DECIMAL(this) = decSrc;
    V_VT(this) = VT_DECIMAL;
}

_variant_t::_variant_t ( BYTE  bSrc ) throw ( )

inline

{
    V_VT(this) = VT_UI1;
    V_UI1(this) = bSrc;
}

_variant_t::_variant_t ( char  cSrc ) throw ( )

inline

{
    V_VT(this) = VT_I1;
    V_I1(this) = cSrc;
}

_variant_t::_variant_t ( unsigned short  usSrc ) throw ( )

inline

{
    V_VT(this) = VT_UI2;
    V_UI2(this) = usSrc;
}

_variant_t::_variant_t ( unsigned long  ulSrc ) throw ( )

inline

{
    V_VT(this) = VT_UI4;
    V_UI4(this) = ulSrc;
}

_variant_t::_variant_t ( int  iSrc ) throw ( )

inline

{
    V_VT(this) = VT_INT;
    V_INT(this) = iSrc;
}

_variant_t::_variant_t ( unsigned int  uiSrc ) throw ( )

inline

{
    V_VT(this) = VT_UINT;
    V_UINT(this) = uiSrc;
}

_variant_t::~_variant_t ( ) throw ( )

inline

{
    ::VariantClear(this);
}

Member Function Documentation

void _variant_t::Attach ( VARIANT &  varSrc )

inline

{
    //
    // Free up previous VARIANT
    //
    Clear();

    //
    // Give control of data to _variant_t
    //
    _COM_MEMCPY_S(this, sizeof(varSrc), &varSrc, sizeof(varSrc));
    V_VT(&varSrc) = VT_EMPTY;
}

void _variant_t::ChangeType ( VARTYPE  vartype, const _variant_t *  pSrc = NULL  )

inline

{
    //
    // If pDest is NULL, convert type in place
    //
    if (pSrc == NULL) {
        pSrc = this;
    }

    if ((this != pSrc) || (vartype != V_VT(this))) {
        _com_util::CheckError(::VariantChangeType(static_cast<VARIANT*>(this),
                                                  const_cast<VARIANT*>(static_cast<const VARIANT*>(pSrc)),
                                                  0, vartype));
    }
}

void _variant_t::Clear ( )

inline

{
    _com_util::CheckError(::VariantClear(this));
}

VARIANT _variant_t::Detach ( ) throw ( )

inline

{
    VARIANT varResult = *this;
    V_VT(this) = VT_EMPTY;

    return varResult;
}

VARIANT * _variant_t::GetAddress ( )

inline

{
    Clear();
    return (VARIANT*) this;
}

VARIANT & _variant_t::GetVARIANT ( ) throw ( )

inline

{
    return *(VARIANT*) this;
}

_variant_t::operator _bstr_t ( ) const

inline

{
    if (V_VT(this) == VT_BSTR) {
        return V_BSTR(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_BSTR, this);

    return V_BSTR(&varDest);
}

_variant_t::operator bool ( ) const

inline

{
    if (V_VT(this) == VT_BOOL) {
        return V_BOOL(this) ? true : false;
    }

    _variant_t varDest;
    varDest.ChangeType(VT_BOOL, this);

    return (V_BOOL(&varDest) == VARIANT_TRUE) ? true : false;
}

_variant_t::operator BYTE ( ) const

inline

{
    if (V_VT(this) == VT_UI1) {
        return V_UI1(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_UI1, this);

    return V_UI1(&varDest);
}

_variant_t::operator char ( ) const

inline

{
    if (V_VT(this) == VT_I1) {
        return V_I1(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_I1, this);

    return V_I1(&varDest);
}

_variant_t::operator CY ( ) const

inline

{
    if (V_VT(this) == VT_CY) {
        return V_CY(this); 
    }

    _variant_t varDest;
    varDest.ChangeType(VT_CY, this);

    return V_CY(&varDest);
}

_variant_t::operator DECIMAL ( ) const

inline

{
    if (V_VT(this) == VT_DECIMAL) {
        return V_DECIMAL(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_DECIMAL, this);

    return V_DECIMAL(&varDest);
}

_variant_t::operator double ( ) const

inline

{
    if (V_VT(this) == VT_R8) {
        return V_R8(this); 
    }

    _variant_t varDest;
    varDest.ChangeType(VT_R8, this);

    return V_R8(&varDest);
}

_variant_t::operator float ( ) const

inline

{
    if (V_VT(this) == VT_R4) {
        return V_R4(this); 
    }

    _variant_t varDest;
    varDest.ChangeType(VT_R4, this);

    return V_R4(&varDest);
}

_variant_t::operator IDispatch * ( ) const

inline

{
    if (V_VT(this) == VT_DISPATCH) {
        if (V_DISPATCH(this) != NULL) {
            V_DISPATCH(this)->AddRef();
        }
        return V_DISPATCH(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_DISPATCH, this);
    
    if (V_DISPATCH(&varDest) != NULL) {
        V_DISPATCH(&varDest)->AddRef();
    }

    return V_DISPATCH(&varDest);
}

_variant_t::operator int ( ) const

inline

{
    if (V_VT(this) == VT_INT) {
        return V_INT(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_INT, this);

    return V_INT(&varDest);
}

_variant_t::operator IUnknown * ( ) const

inline

{
    if (V_VT(this) == VT_UNKNOWN) {
        if (V_UNKNOWN(this) != NULL) {
            V_UNKNOWN(this)->AddRef();
        }
        return V_UNKNOWN(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_UNKNOWN, this);

    if (V_UNKNOWN(&varDest) != NULL) {
        V_UNKNOWN(&varDest)->AddRef();
    }

    return V_UNKNOWN(&varDest);
}

_variant_t::operator long ( ) const

inline

{
    if (V_VT(this) == VT_I4) {
        return V_I4(this); 
    }

    _variant_t varDest;
    varDest.ChangeType(VT_I4, this);

    return V_I4(&varDest);
}

_variant_t::operator short ( ) const

inline

{
    if (V_VT(this) == VT_I2) {
        return V_I2(this); 
    }

    _variant_t varDest;
    varDest.ChangeType(VT_I2, this);

    return V_I2(&varDest);
}

_variant_t::operator unsigned int ( ) const

inline

{
    if (V_VT(this) == VT_UINT) {
        return V_UINT(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_UINT, this);

    return V_UINT(&varDest);
}

_variant_t::operator unsigned long ( ) const

inline

{
    if (V_VT(this) == VT_UI4) {
        return V_UI4(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_UI4, this);

    return V_UI4(&varDest);
}

_variant_t::operator unsigned short ( ) const

inline

{
    if (V_VT(this) == VT_UI2) {
        return V_UI2(this);
    }

    _variant_t varDest;
    varDest.ChangeType(VT_UI2, this);

    return V_UI2(&varDest);
}

_variant_t::operator VARIANT ( ) const throw ( )

inline

{
    return *(VARIANT*) this;
}

bool _variant_t::operator!= ( const VARIANT &  varSrc ) const throw ( )

inline

{
    return !(*this == &varSrc);
}

bool _variant_t::operator!= ( const VARIANT *  pSrc ) const throw ( )

inline

{
    return !(*this == pSrc);
}

_variant_t & _variant_t::operator= ( const VARIANT &  varSrc )

inline

{
    _com_util::CheckError(::VariantCopy(this, const_cast<VARIANT*>(&varSrc)));

    return *this;
}

_variant_t & _variant_t::operator= ( const VARIANT *  pSrc )

inline

{
    if (pSrc == NULL) {
        _com_issue_error(E_POINTER);
    }
    else {
        _com_util::CheckError(::VariantCopy(this, const_cast<VARIANT*>(pSrc)));
    }

    return *this;
}

_variant_t & _variant_t::operator= ( const _variant_t &  varSrc )

inline

{
    _com_util::CheckError(::VariantCopy(this, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))));

    return *this;
}

_variant_t & _variant_t::operator= ( short  sSrc )

inline

{
    if (V_VT(this) == VT_I2) {
        V_I2(this) = sSrc;
    }
    else if (V_VT(this) == VT_BOOL) {
        V_BOOL(this) = (sSrc ? VARIANT_TRUE : VARIANT_FALSE);
    }
    else {
        // Clear the VARIANT and create a VT_I2
        //
        Clear();

        V_VT(this) = VT_I2;
        V_I2(this) = sSrc;
    }

    return *this;
}

_variant_t & _variant_t::operator= ( long  lSrc )

inline

{
    if (V_VT(this) == VT_I4) {
        V_I4(this) = lSrc;
    }
    else if (V_VT(this) == VT_ERROR) {
        V_ERROR(this) = lSrc;
    }
    else if (V_VT(this) == VT_BOOL) {
        V_BOOL(this) = (lSrc ? VARIANT_TRUE : VARIANT_FALSE);
    }
    else {
        // Clear the VARIANT and create a VT_I4
        //
        Clear();

        V_VT(this) = VT_I4;
        V_I4(this) = lSrc;
    }

    return *this;
}

_variant_t & _variant_t::operator= ( float  fltSrc )

inline

{
    if (V_VT(this) != VT_R4) {
        // Clear the VARIANT and create a VT_R4
        //
        Clear();

        V_VT(this) = VT_R4;
    }

    V_R4(this) = fltSrc;

    return *this;
}

_variant_t & _variant_t::operator= ( double  dblSrc )

inline

{
    if (V_VT(this) == VT_R8) {
        V_R8(this) = dblSrc;
    }
    else if(V_VT(this) == VT_DATE) {
        V_DATE(this) = dblSrc;
    }
    else {
        // Clear the VARIANT and create a VT_R8
        //
        Clear();

        V_VT(this) = VT_R8;
        V_R8(this) = dblSrc;
    }

    return *this;
}

_variant_t & _variant_t::operator= ( const CY &  cySrc )

inline

{
    if (V_VT(this) != VT_CY) {
        // Clear the VARIANT and create a VT_CY
        //
        Clear();

        V_VT(this) = VT_CY;
    }

    V_CY(this) = cySrc;

    return *this;
}

_variant_t & _variant_t::operator= ( const _bstr_t &  bstrSrc )

inline

{
    _COM_ASSERT(V_VT(this) != VT_BSTR || (BSTR) bstrSrc == NULL || V_BSTR(this) != (BSTR) bstrSrc);

    // Clear the VARIANT (This will SysFreeString() any previous occupant)
    //
    Clear();

    V_VT(this) = VT_BSTR;

    if (!bstrSrc) {
        V_BSTR(this) = NULL;
    }
    else {
        BSTR bstr = static_cast<wchar_t*>(bstrSrc);
        V_BSTR(this) = ::SysAllocStringByteLen(reinterpret_cast<char*>(bstr),
                                               ::SysStringByteLen(bstr));

        if (V_BSTR(this) == NULL) {
            _com_issue_error(E_OUTOFMEMORY);
        }
    }

    return *this;
}

_variant_t & _variant_t::operator= ( const wchar_t *  pSrc )

inline

{
    _COM_ASSERT(V_VT(this) != VT_BSTR || pSrc == NULL || V_BSTR(this) != pSrc);

    // Clear the VARIANT (This will SysFreeString() any previous occupant)
    //
    Clear();

    V_VT(this) = VT_BSTR;

    if (pSrc == NULL) {
        V_BSTR(this) = NULL;
    }
    else {
        V_BSTR(this) = ::SysAllocString(pSrc);

        if (V_BSTR(this) == NULL) {
            _com_issue_error(E_OUTOFMEMORY);
        }
    }

    return *this;
}

_variant_t & _variant_t::operator= ( const char *  pSrc )

inline

{
    _COM_ASSERT(V_VT(this) != (VT_I1 | VT_BYREF) || pSrc == NULL || V_I1REF(this) != pSrc);

    // Clear the VARIANT (This will SysFreeString() any previous occupant)
    //
    Clear();

    V_VT(this) = VT_BSTR;
    V_BSTR(this) = _com_util::ConvertStringToBSTR(pSrc);

    return *this;
}

_variant_t & _variant_t::operator= ( IDispatch *  pSrc )

inline

{
    _COM_ASSERT(V_VT(this) != VT_DISPATCH || pSrc == 0 || V_DISPATCH(this) != pSrc);

    // Clear the VARIANT (This will Release() any previous occupant)
    //
    Clear();

    V_VT(this) = VT_DISPATCH;
    V_DISPATCH(this) = pSrc;

    if (V_DISPATCH(this) != NULL) {
        // Need the AddRef() as VariantClear() calls Release()
        //
        V_DISPATCH(this)->AddRef();
    }

    return *this;
}

_variant_t & _variant_t::operator= ( bool  boolSrc )

inline

{
    if (V_VT(this) != VT_BOOL) {
        // Clear the VARIANT and create a VT_BOOL
        //
        Clear();

        V_VT(this) = VT_BOOL;
    }

    V_BOOL(this) = (boolSrc ? VARIANT_TRUE : VARIANT_FALSE);

    return *this;
}

_variant_t & _variant_t::operator= ( IUnknown *  pSrc )

inline

{
    _COM_ASSERT(V_VT(this) != VT_UNKNOWN || pSrc == NULL || V_UNKNOWN(this) != pSrc);

    // Clear VARIANT (This will Release() any previous occupant)
    //
    Clear();

    V_VT(this) = VT_UNKNOWN;
    V_UNKNOWN(this) = pSrc;

    if (V_UNKNOWN(this) != NULL) {
        // Need the AddRef() as VariantClear() calls Release()
        //
        V_UNKNOWN(this)->AddRef();
    }

    return *this;
}

_variant_t & _variant_t::operator= ( const DECIMAL &  decSrc )

inline

{
    if (V_VT(this) != VT_DECIMAL) {
        // Clear the VARIANT
        //
        Clear();
    }

    // Order is important here! Setting V_DECIMAL wipes out the entire VARIANT
    V_DECIMAL(this) = decSrc;
    V_VT(this) = VT_DECIMAL;

    return *this;
}

_variant_t & _variant_t::operator= ( BYTE  bSrc )

inline

{
    if (V_VT(this) != VT_UI1) {
        // Clear the VARIANT and create a VT_UI1
        //
        Clear();

        V_VT(this) = VT_UI1;
    }

    V_UI1(this) = bSrc;

    return *this;
}

_variant_t & _variant_t::operator= ( char  cSrc )

inline

{
    if (V_VT(this) != VT_I1) {
        // Clear the VARIANT and create a VT_I1
        //
        Clear();

        V_VT(this) = VT_I1;
    }

    V_I1(this) = cSrc;

    return *this;
}

_variant_t & _variant_t::operator= ( unsigned short  usSrc )

inline

{
    if (V_VT(this) != VT_UI2) {
        // Clear the VARIANT and create a VT_UI2
        //
        Clear();

        V_VT(this) = VT_UI2;
    }

    V_UI2(this) = usSrc;

    return *this;
}

_variant_t & _variant_t::operator= ( unsigned long  ulSrc )

inline

{
    if (V_VT(this) != VT_UI4) {
        // Clear the VARIANT and create a VT_UI4
        //
        Clear();

        V_VT(this) = VT_UI4;
    }

    V_UI4(this) = ulSrc;

    return *this;
}

_variant_t & _variant_t::operator= ( int  iSrc )

inline

{
    if (V_VT(this) != VT_INT) {
        // Clear the VARIANT and create a VT_INT
        //
        Clear();

        V_VT(this) = VT_INT;
    }

    V_INT(this) = iSrc;

    return *this;
}

_variant_t & _variant_t::operator= ( unsigned int  uiSrc )

inline

{
    if (V_VT(this) != VT_UINT) {
        // Clear the VARIANT and create a VT_UINT
        //
        Clear();

        V_VT(this) = VT_UINT;
    }

    V_UINT(this) = uiSrc;

    return *this;
}

bool _variant_t::operator== ( const VARIANT &  varSrc ) const throw ( )

inline

{
    return *this == &varSrc;
}

bool _variant_t::operator== ( const VARIANT *  pSrc ) const throw ( )

inline

{
    if (pSrc == NULL) {
        return false;
    }

    if (this == pSrc) {
        return true;
    }

    //
    // Variants not equal if types don't match
    //
    if (V_VT(this) != V_VT(pSrc)) {
        return false;
    }

    //
    // Check type specific values
    //
    switch (V_VT(this)) {
        case VT_EMPTY:
        case VT_NULL:
            return true;

        case VT_I2:
            return V_I2(this) == V_I2(pSrc);

        case VT_I4:
            return V_I4(this) == V_I4(pSrc);

        case VT_R4:
            return V_R4(this) == V_R4(pSrc);

        case VT_R8:
            return V_R8(this) == V_R8(pSrc);

        case VT_CY:
            return memcmp(&(V_CY(this)), &(V_CY(pSrc)), sizeof(CY)) == 0;

        case VT_DATE:
            return V_DATE(this) == V_DATE(pSrc);

        case VT_BSTR:
            return (::SysStringByteLen(V_BSTR(this)) == ::SysStringByteLen(V_BSTR(pSrc))) &&
                    (memcmp(V_BSTR(this), V_BSTR(pSrc), ::SysStringByteLen(V_BSTR(this))) == 0);

        case VT_DISPATCH:
            return V_DISPATCH(this) == V_DISPATCH(pSrc);

        case VT_ERROR:
            return V_ERROR(this) == V_ERROR(pSrc);

        case VT_BOOL:
            return V_BOOL(this) == V_BOOL(pSrc);

        case VT_UNKNOWN:
            return V_UNKNOWN(this) == V_UNKNOWN(pSrc);

        case VT_DECIMAL:
            return memcmp(&(V_DECIMAL(this)), &(V_DECIMAL(pSrc)), sizeof(DECIMAL)) == 0;

        case VT_UI1:
            return V_UI1(this) == V_UI1(pSrc);

        case VT_I1:
            return V_I1(this) == V_I1(pSrc);

        case VT_UI2:
            return V_UI2(this) == V_UI2(pSrc);

        case VT_UI4:
            return V_UI4(this) == V_UI4(pSrc);

        case VT_INT:
            return V_INT(this) == V_INT(pSrc);

        case VT_UINT:
            return V_UINT(this) == V_UINT(pSrc);

#if (_WIN32_WINNT >= 0x0501)
        case VT_I8:
            return V_I8(this) == V_I8(pSrc);

        case VT_UI8:
            return V_UI8(this) == V_UI8(pSrc);
#endif

        default:
            _com_issue_error(E_INVALIDARG);
            // fall through
    }

    return false;
}

void _variant_t::SetString ( const char *  pSrc )

inline

{
    operator=(pSrc);
}

---

The documentation for this class was generated from the following file:

• VS2015/inc/comutil.h