home / products / comet / documentation
Main Page | Modules | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

comet::variant_t Class Reference
[Com type wrappers.]

Wrapper for VARIANT type. More...

#include <variant.h>

List of all members.

com_ptr<Itf> conversion.

template<typename Itf>  variant_t (const com_ptr< Itf > &x) throw ()
template<typename Itf> variant_t & operator= (const com_ptr< Itf > &x) throw ()

Mathematical operators

 COMET_VARIANT_OPERATOR (+, Add)
 COMET_VARIANT_OPERATOR (-, Sub)
 COMET_VARIANT_OPERATOR (/, Div)
 COMET_VARIANT_OPERATOR (&, And)
 COMET_VARIANT_OPERATOR (|, Or)
 COMET_VARIANT_OPERATOR (^, Xor)
 COMET_VARIANT_OPERATOR (%, Mod)
variant_t operator- () const
void change_type (VARTYPE vartype) throw (com_error)
COMET_VARIANT_OPERATOR * Mul

Accessor Functions

const VARIANT & get () const throw ()
VARTYPE get_vt () const throw ()
VARTYPE get_vt (bool ignore_byref) const throw ()
VARIANT detach () throw ()
VARIANT in () const throw ()
 [in] adapter.
VARIANT * in_ptr () const throw ()
 [in] adapter.
VARIANT * out () throw ()
 [out] adapter.
VARIANT * inout () throw ()
 [in, out] adapter.
VARIANT detach (variant_t &v) throw ()
const variant_t & create_const_reference (const VARIANT &x)
variant_t & create_reference (VARIANT &x)

Public Member Functions

 variant_t () throw ()
 Default constructor.
 variant_t (const variant_t &v) throw (com_error)
 Copy constructor.
 variant_t (const variant_t &v, VARTYPE vartype) throw (com_error)
 VariantChangeType Constructor.
 variant_t (const variant_t &v, VARTYPE vartype, std::nothrow_t) throw (com_error)
 variant_t (const VARIANT &v) throw (com_error)
 Constructor.
 variant_t (const impl::auto_attach_t< VARIANT > &v) throw ()
 Attaching constructor.
 ~variant_t () throw ()
 Destructor.
void swap (variant_t &x) throw ()
 swap routine, fast with nothrow guarantee
variant_t & operator= (const variant_t &x) throw (com_error)
 Assignment operator.
bool is_string () const
 Is variant a BSTR.
bool is_object () const
 Is variant an IDispatch or IUnknown pointer?
bool is_empty () const throw ()
bool is_null () const throw ()
bool is_nothing () const throw ()
bool Conversion
 variant_t (bool x) throw ()
 operator bool () const throw ()
variant_t & operator= (bool x) throw ()
string Conversion
 variant_t (const bstr_t &s) throw (std::bad_alloc)
 variant_t (const wchar_t *s) throw (std::bad_alloc)
 variant_t (const std::wstring &s) throw (std::bad_alloc)
 variant_t (const std::string &s) throw (std::bad_alloc)
 variant_t (const char *x)
 variant_t (const impl::auto_attach_t< BSTR > &bstrVal)
bstr_t str () const
 operator bstr_t () const
 operator std::wstring () const
 operator std::string () const
variant_t & operator= (const bstr_t &s)
variant_t & operator= (const wchar_t *s)
variant_t & operator= (const char *s)
variant_t & operator= (const std::wstring &s)
variant_t & operator= (const std::string &s)
safearray Conversions
template<typename SAT>  variant_t (const safearray_t< SAT > &x)
template<typename SAT> variant_t & operator= (const safearray_t< SAT > &x) throw ()
 variant_t (const impl::auto_attach_t< SAFEARRAY * > &psa)
Numeric Conversions
 COMET_VARIANT_CONVERTERS_EXPLICIT (short, I2, as_short)
 operator short () const
 COMET_VARIANT_CONVERTERS_EXPLICIT (int, I4, as_int)
 operator int () const
 COMET_VARIANT_CONVERTERS_EXPLICIT (long, I4, as_long)
 operator long () const
 COMET_VARIANT_CONVERTERS_EXPLICIT (float, R4, as_float)
 operator float () const
 COMET_VARIANT_CONVERTERS_EXPLICIT (double, R8, as_double)
 operator double () const
 COMET_VARIANT_CONVERTERS_EXPLICIT (char, I1, as_char)
 COMET_VARIANT_CONVERTERS_EXPLICIT (unsigned char, UI1, as_uchar)
 COMET_VARIANT_CONVERTERS_EXPLICIT (unsigned short, UI2, as_ushort)
 COMET_VARIANT_CONVERTERS_EXPLICIT (unsigned int, UI4, as_uint)
 COMET_VARIANT_CONVERTERS_EXPLICIT (unsigned long, UI4, as_ulong)
 COMET_VARIANT_CONVERTERS_EXPLICIT (DECIMAL, DECIMAL, as_decimal)
wchar_t as_wchar_t () const
Currency Conversions
 variant_t (const currency_t &x) throw ()
 operator currency_t () const
currency_t as_curency () const
variant_t & operator= (const currency_t &x) throw ()
Date Conversions
 variant_t (const datetime_t &x) throw ()
 operator datetime_t () const
variant_t & operator= (const datetime_t &x) throw ()
Comparison operators
template<typename T> bool operator== (const T &x) const throw (com_error)
bool operator== (const variant_t &x) const throw (com_error)
template<typename T> bool operator!= (const T &x) const throw (com_error)
bool operator!= (const variant_t &x) const throw (com_error)
template<typename T> bool operator< (const T &x) const throw (com_error)
bool operator< (const variant_t &x) const throw (com_error)
template<typename T> bool operator<= (const T &x) const throw (com_error)
template<typename T> bool operator> (const T &x) const throw (com_error)
bool operator> (const variant_t &x) const throw (com_error)
bool operator<= (const variant_t &x) const throw (com_error)
template<typename T> bool operator>= (const T &x) const throw (com_error)
bool operator>= (const variant_t &x) const throw (com_error)

Static Public Member Functions

const variant_t & missing ()
 Return a variant constructed as missing.
const variant_t & nothing ()
 Return a variant contructed as nothing.
const variant_t & null ()
 Return a variant constructed as null (VT_NULL).

Friends

std::basic_ostream< char > & operator<< (std::basic_ostream< char > &os, const variant_t &val)
std::basic_ostream< wchar_t > & operator<< (std::basic_ostream< wchar_t > &os, const variant_t &val)

Detailed Description

Wrapper for VARIANT type.

variant_t is exception safe (basic and strong guarantee).

Constructor & Destructor Documentation

comet::variant_t::variant_t (  const variant_t &  v  )  throw (com_error) [inline]
 

Copy constructor.

Exceptions:
com_error Thrown if underlying VariantCopy fails.

comet::variant_t::variant_t (  const variant_t &  v,
VARTYPE  vartype
)  throw (com_error) [inline]
 

VariantChangeType Constructor.

Copies variant and changes to specified type.

Note:
Unlike the _variant_t of VC, variant_t uses Thread Locale for type changes instead of the user setting.
v
Variant to copy from
vartype
Type to change to.
Exceptions:
com_error Thrown if underlying VariantChangeTypeEx fails.

comet::variant_t::variant_t (  const VARIANT &  v  )  throw (com_error) [inline, explicit]
 

Constructor.

Exceptions:
com_error Thrown if underlying VariantCopy fails.

comet::variant_t::variant_t (  const impl::auto_attach_t< VARIANT > &  v  )  throw () [inline]
 

Attaching constructor.

Takes ownership of specified VARIANT.

Parameters:
v auto_attach wrapper variant to attach to the variant_t

comet::variant_t::~variant_t (   )  throw () [inline]
 

Destructor.

Note:
Be aware that the underlying call to VariantClear may fail. But since we are not allowed to throw any exceptions (Otherwise STL containers cannot guarantee exception safety) from within a destructor, a failing VariantClear will be ignored. Instead we assert for success in debug and ignore in release.

comet::variant_t::variant_t (  const impl::auto_attach_t< BSTR > &  bstrVal  )  [inline]
 

Attach a BSTR to a variant. 

                                bstr_t val = L"A large string";
                                variant_t(auto_attach(val.detach()));

comet::variant_t::variant_t (  const impl::auto_attach_t< SAFEARRAY * > &  psa  )  [inline]
 

Allow attaching a SAFEARRAY to a variant. 

     safearray_t<bstr_t> array;
     variant_t(auto_attach(array.detach()));

Member Function Documentation

VARIANT comet::variant_t::in (   )  const throw () [inline]
 

[in] adapter.

Used when calling raw interfaces that require an [in] VARIANT argument.

                                variant_t v;
                                HRESULT hr = pRawInterface->raw_Method(v.in());

Only use this wrapper when forced to deal with raw interface.

VARIANT* comet::variant_t::in_ptr (   )  const throw () [inline]
 

[in] adapter.

Used when calling raw interfaces that require an [in] VARIANT* argument.

                                variant_t v;
                                HRESULT hr = pRawInterface->raw_Method(v.in_ptr());

Only use this wrapper when forced to deal with raw interface.

VARIANT* comet::variant_t::inout (   )  throw () [inline]
 

[in, out] adapter.

Used when calling raw interfaces that require an [in, out] VARIANT * argument.

                                variant_t v;
                                HRESULT hr = pRawInterface->raw_MethodThatChangesVariant(v.inout());

Only use this wrapper when forced to deal with raw interface.

bool comet::variant_t::is_empty (   )  const throw () [inline]
 

Is variant empty. This compares strictly to VT_EMPTY.

bool comet::variant_t::is_nothing (   )  const throw () [inline]
 

! Is variant Nothing. Is this a NULL pointer, empty, or null. This returns true if the value would cleanly try_cast to a NULL com_ptr<IUnknown>.

bool comet::variant_t::is_null (   )  const throw () [inline]
 

Is variant 'NULL'. This compares strictly to VT_NULL.

const variant_t& comet::variant_t::missing (   )  [inline, static]
 

Return a variant constructed as missing.

(VT_ERROR with code DISP_E_PARAMNOTFOUND )

const variant_t& comet::variant_t::nothing (   )  [inline, static]
 

Return a variant contructed as nothing.

(VT_DISPATCH with value 0)

VARIANT* comet::variant_t::out (   )  throw () [inline]
 

[out] adapter.

Used when calling raw interfaces that require an [out] VARIANT * argument.

                                variant_t v;
                                HRESULT hr = pRawInterface->raw_MethodThatReturnsVariant(v.out());

Only use this wrapper when forced to deal with raw interface.

The documentation for this class was generated from the following file:
Copyright 2002 Sofus Mortensen. All rights reserved.