_com_ptr_t< _IIID > Class Template Reference

#include <comip.h>

Public Types
typedef _IIID	ThisIIID
typedef _IIID::Interface	Interface

Public Member Functions
template<typename _OtherIID >
	_com_ptr_t (const _com_ptr_t< _OtherIID > &p)
template<typename _InterfaceType >
	_com_ptr_t (_InterfaceType *p)
template<>
	_com_ptr_t (_In_ LPSTR str)
template<>
	_com_ptr_t (_In_ LPWSTR str)
template<>
	_com_ptr_t (_com_ptr_t *p)
	_com_ptr_t () throw ()
	_com_ptr_t (int null)
	_com_ptr_t (const _com_ptr_t &cp) throw ()
template<>
	_com_ptr_t (Interface *pInterface) throw ()
	_com_ptr_t (Interface *pInterface, bool fAddRef) throw ()
	_com_ptr_t (const _variant_t &varSrc)
	_com_ptr_t (const CLSID &clsid, IUnknown *pOuter=NULL, DWORD dwClsContext=CLSCTX_ALL)
	_com_ptr_t (LPCWSTR str, IUnknown *pOuter=NULL, DWORD dwClsContext=CLSCTX_ALL)
	_com_ptr_t (LPCSTR str, IUnknown *pOuter=NULL, DWORD dwClsContext=CLSCTX_ALL)
template<typename _OtherIID >
_com_ptr_t &	operator= (const _com_ptr_t< _OtherIID > &p)
template<typename _InterfaceType >
_com_ptr_t &	operator= (_InterfaceType *p)
template<>
_com_ptr_t &	operator= (Interface *pInterface) throw ()
_com_ptr_t &	operator= (const _com_ptr_t &cp) throw ()
_com_ptr_t &	operator= (int null)
_com_ptr_t &	operator= (const _variant_t &varSrc)
	~_com_ptr_t () throw ()
void	Attach (Interface *pInterface) throw ()
void	Attach (Interface *pInterface, bool fAddRef) throw ()
Interface *	Detach () throw ()
	operator Interface * () const throw ()
	operator Interface & () const
Interface &	operator* () const
Interface **	operator& () throw ()
Interface *	operator-> () const
	operator bool () const throw ()
template<typename _OtherIID >
bool	operator== (const _com_ptr_t< _OtherIID > &p) const
template<typename _InterfaceType >
bool	operator== (_InterfaceType *p) const
template<>
bool	operator== (Interface *p) const
template<>
bool	operator== (const _com_ptr_t &p) const throw ()
bool	operator== (int null) const
template<typename _OtherIID >
bool	operator!= (const _com_ptr_t< _OtherIID > &p) const
template<typename _InterfaceType >
bool	operator!= (_InterfaceType *p) const
bool	operator!= (int null) const
template<typename _OtherIID >
bool	operator< (const _com_ptr_t< _OtherIID > &p) const
template<typename _InterfaceType >
bool	operator< (_InterfaceType *p) const
template<typename _OtherIID >
bool	operator> (const _com_ptr_t< _OtherIID > &p) const
template<typename _InterfaceType >
bool	operator> (_InterfaceType *p) const
template<typename _OtherIID >
bool	operator<= (const _com_ptr_t< _OtherIID > &p) const
template<typename _InterfaceType >
bool	operator<= (_InterfaceType *p) const
template<typename _OtherIID >
bool	operator>= (const _com_ptr_t< _OtherIID > &p) const
template<typename _InterfaceType >
bool	operator>= (_InterfaceType *p) const
void	Release ()
void	AddRef ()
Interface *	GetInterfacePtr () const throw ()
Interface *&	GetInterfacePtr () throw ()
HRESULT	CreateInstance (const CLSID &rclsid, IUnknown *pOuter=NULL, DWORD dwClsContext=CLSCTX_ALL) throw ()
HRESULT	CreateInstance (LPCWSTR clsidString, IUnknown *pOuter=NULL, DWORD dwClsContext=CLSCTX_ALL) throw ()
HRESULT	CreateInstance (LPCSTR clsidStringA, IUnknown *pOuter=NULL, DWORD dwClsContext=CLSCTX_ALL) throw ()
HRESULT	GetActiveObject (const CLSID &rclsid) throw ()
HRESULT	GetActiveObject (LPCWSTR clsidString) throw ()
HRESULT	GetActiveObject (LPCSTR clsidStringA) throw ()
template<typename _InterfaceType >
HRESULT	QueryInterface (const IID &iid, _InterfaceType *&p) throw ()
template<typename _InterfaceType >
HRESULT	QueryInterface (const IID &iid, _InterfaceType **p) throw ()

Static Public Member Functions
static const IID &	GetIID () throw ()

Private Member Functions
void	_Release () throw ()
void	_AddRef () throw ()
template<typename _InterfacePtr >
HRESULT	_QueryInterface (_InterfacePtr p) throw ()
template<typename _InterfacePtr >
int	_CompareUnknown (_InterfacePtr p) const
HRESULT	QueryStdInterfaces (const _variant_t &varSrc) throw ()

Private Attributes
Interface *	m_pInterface

Member Typedef Documentation

template<typename _IIID>

typedef _IIID::Interface _com_ptr_t< _IIID >::Interface

template<typename _IIID>

typedef _IIID _com_ptr_t< _IIID >::ThisIIID

Constructor & Destructor Documentation

template<typename _IIID>

template<typename _OtherIID >

_com_ptr_t< _IIID >::_com_ptr_t ( const _com_ptr_t< _OtherIID > &  p )

inline

        : m_pInterface(NULL)
    {
        HRESULT hr = _QueryInterface(p);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }
    }

template<typename _IIID>

template<typename _InterfaceType >

_com_ptr_t< _IIID >::_com_ptr_t ( _InterfaceType *  p )

inline

        : m_pInterface(NULL)
    {
        HRESULT hr = _QueryInterface(p);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }
    }

template<typename _IIID>

template<>

_com_ptr_t< _IIID >::_com_ptr_t ( _In_ LPSTR  str )

inline

    {
        new(this) _com_ptr_t(static_cast<LPCSTR> (str), NULL);
    }

template<typename _IIID>

template<>

_com_ptr_t< _IIID >::_com_ptr_t ( _In_ LPWSTR  str )

inline

    {
        new(this) _com_ptr_t(static_cast<LPCWSTR> (str), NULL);
    }

template<typename _IIID>

template<>

_com_ptr_t< _IIID >::_com_ptr_t ( _com_ptr_t< _IIID > *  p )

inlineexplicit

        : m_pInterface(NULL)
    {
        if (p == NULL) {
            _com_issue_error(E_POINTER);
        }
        else {
            m_pInterface = p->m_pInterface;
            AddRef();
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( ) throw ( )

inline

        : m_pInterface(NULL)
    {
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( int  null )

inline

        : m_pInterface(NULL)
    {
        if (null != 0) {
            _com_issue_error(E_POINTER);
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( const _com_ptr_t< _IIID > &  cp ) throw ( )

inline

        : m_pInterface(cp.m_pInterface)
    { 
        _AddRef(); 
    }

template<typename _IIID>

template<>

_com_ptr_t< _IIID >::_com_ptr_t ( Interface *  pInterface ) throw ( )

inline

        : m_pInterface(pInterface)
    { 
        _AddRef(); 
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( Interface *  pInterface, bool  fAddRef  ) throw ( )

inline

        : m_pInterface(pInterface)
    {
        if (fAddRef) {
            _AddRef();
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( const _variant_t &  varSrc )

inline

        : m_pInterface(NULL)
    {
        HRESULT hr = QueryStdInterfaces(varSrc);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( const CLSID &  clsid, IUnknown *  pOuter = NULL, DWORD  dwClsContext = CLSCTX_ALL  )

inlineexplicit

        : m_pInterface(NULL)
    {
        HRESULT hr = CreateInstance(clsid, pOuter, dwClsContext);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( LPCWSTR  str, IUnknown *  pOuter = NULL, DWORD  dwClsContext = CLSCTX_ALL  )

inlineexplicit

        : m_pInterface(NULL)
    {
        HRESULT hr = CreateInstance(str, pOuter, dwClsContext);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::_com_ptr_t ( LPCSTR  str, IUnknown *  pOuter = NULL, DWORD  dwClsContext = CLSCTX_ALL  )

inlineexplicit

        : m_pInterface(NULL)
    {
        HRESULT hr = CreateInstance(str, pOuter, dwClsContext);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }
    }

template<typename _IIID>

_com_ptr_t< _IIID >::~_com_ptr_t ( ) throw ( )

inline

    { 
        _Release(); 
    }

Member Function Documentation

template<typename _IIID>

void _com_ptr_t< _IIID >::_AddRef ( ) throw ( )

inlineprivate

    {
        if (m_pInterface != NULL) {
            m_pInterface->AddRef();
        }
    }

template<typename _IIID>

template<typename _InterfacePtr >

int _com_ptr_t< _IIID >::_CompareUnknown ( _InterfacePtr  p ) const

inlineprivate

    {
        IUnknown* pu1 = NULL;
        IUnknown* pu2 = NULL;

        if (m_pInterface != NULL) {
            HRESULT hr = m_pInterface->QueryInterface(__uuidof(IUnknown), reinterpret_cast<void**>(&pu1));

            if (FAILED(hr)) {
                pu1 = NULL;
                _com_issue_error(hr);
            }
            else {
                pu1->Release();
            }
        }

        if (p != NULL) {
            HRESULT hr = p->QueryInterface(__uuidof(IUnknown), reinterpret_cast<void**>(&pu2));

            if (FAILED(hr)) {
                pu2 = NULL;
                _com_issue_error(hr);
            }
            else {
                pu2->Release();
            }
        }

        if (pu1 == pu2)
        {
            return 0;
        }

        return (pu1 > pu2) ? 1 : -1;
    }

template<typename _IIID>

template<typename _InterfacePtr >

HRESULT _com_ptr_t< _IIID >::_QueryInterface ( _InterfacePtr  p ) throw ( )

inlineprivate

    {
        HRESULT hr;

        // Can't QI NULL
        //
        if (p != NULL) {
            // Query for this interface
            //
            Interface* pInterface;
            hr = p->QueryInterface(GetIID(), reinterpret_cast<void**>(&pInterface));

            // Save the interface without AddRef()ing.
            //
            Attach(SUCCEEDED(hr)? pInterface: NULL);
        }
        else {
            operator=(static_cast<Interface*>(NULL));
            hr = E_NOINTERFACE;
        }

        return hr;
    }

template<typename _IIID>

void _com_ptr_t< _IIID >::_Release ( ) throw ( )

inlineprivate

    {
        if (m_pInterface != NULL) {
            m_pInterface->Release();
        }
    }

template<typename _IIID>

void _com_ptr_t< _IIID >::AddRef ( )

inline

    { 
        if (m_pInterface == NULL) {
            _com_issue_error(E_POINTER);
        }
        else {
            m_pInterface->AddRef();
        }
    }

template<typename _IIID>

void _com_ptr_t< _IIID >::Attach ( Interface *  pInterface ) throw ( )

inline

    {
        _Release();
        m_pInterface = pInterface;
    }

template<typename _IIID>

void _com_ptr_t< _IIID >::Attach ( Interface *  pInterface, bool  fAddRef  ) throw ( )

inline

    {
        _Release();
        m_pInterface = pInterface;

        if (fAddRef) {
            if (pInterface == NULL) {
                _com_issue_error(E_POINTER);
            } 
            else {
                pInterface->AddRef();
            }
        }
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::CreateInstance ( const CLSID &  rclsid, IUnknown *  pOuter = NULL, DWORD  dwClsContext = CLSCTX_ALL  ) throw ( )

inline

    {
        HRESULT hr;

        _Release();

        if (dwClsContext & (CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER)) {
            IUnknown* pIUnknown;
            hr = CoCreateInstance(rclsid, pOuter, dwClsContext, __uuidof(IUnknown), reinterpret_cast<void**>(&pIUnknown));

            if (SUCCEEDED(hr)) {
                hr = OleRun(pIUnknown);

                if (SUCCEEDED(hr)) {
                    hr = pIUnknown->QueryInterface(GetIID(), reinterpret_cast<void**>(&m_pInterface));
                }

                pIUnknown->Release();
            }
        }
        else {
            hr = CoCreateInstance(rclsid, pOuter, dwClsContext, GetIID(), reinterpret_cast<void**>(&m_pInterface));
        }

        if (FAILED(hr)) {
            // just in case refcount = 0 and dtor gets called
            m_pInterface = NULL;
        }

        return hr;
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::CreateInstance ( LPCWSTR  clsidString, IUnknown *  pOuter = NULL, DWORD  dwClsContext = CLSCTX_ALL  ) throw ( )

inline

    {
        if (clsidString == NULL) {
            return E_INVALIDARG;
        }

        CLSID clsid;
        HRESULT hr;

        if (clsidString[0] == L'{') {
            hr = CLSIDFromString(const_cast<LPWSTR> (clsidString), &clsid);
        }
        else {
            hr = CLSIDFromProgID(const_cast<LPWSTR> (clsidString), &clsid);
        }

        if (FAILED(hr)) {
            return hr;
        }

        return CreateInstance(clsid, pOuter, dwClsContext);
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::CreateInstance ( LPCSTR  clsidStringA, IUnknown *  pOuter = NULL, DWORD  dwClsContext = CLSCTX_ALL  ) throw ( )

inline

    {
        if (clsidStringA == NULL) {
            return E_INVALIDARG;
        }

        int size = lstrlenA(clsidStringA) + 1;
        int destSize = MultiByteToWideChar(CP_ACP, 0, clsidStringA, size, NULL, 0);

        if (destSize == 0) {
            return HRESULT_FROM_WIN32(GetLastError());
        }

        LPWSTR clsidStringW;
        clsidStringW = static_cast<LPWSTR>(_malloca(destSize * sizeof(WCHAR)));

        if (clsidStringW == NULL) {
            return E_OUTOFMEMORY;
        }

        if (MultiByteToWideChar(CP_ACP, 0, clsidStringA, size, clsidStringW, destSize) == 0) {
           _freea(clsidStringW);
           return HRESULT_FROM_WIN32(GetLastError());
        }

        HRESULT hr=CreateInstance(clsidStringW, pOuter, dwClsContext);
        _freea(clsidStringW);
        return hr;
    }

template<typename _IIID>

Interface* _com_ptr_t< _IIID >::Detach ( ) throw ( )

inline

    {
        Interface* const old = m_pInterface;
        m_pInterface = NULL;
        return old;
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::GetActiveObject ( const CLSID &  rclsid ) throw ( )

inline

    {
        _Release();

        IUnknown* pIUnknown;

        HRESULT hr = ::GetActiveObject(rclsid, NULL, &pIUnknown);

        if (SUCCEEDED(hr)) {
            hr = pIUnknown->QueryInterface(GetIID(), reinterpret_cast<void**>(&m_pInterface));

            pIUnknown->Release();
        }

        if (FAILED(hr)) {
            // just in case refcount = 0 and dtor gets called
            m_pInterface = NULL;
        }

        return hr;
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::GetActiveObject ( LPCWSTR  clsidString ) throw ( )

inline

    {
        if (clsidString == NULL) {
            return E_INVALIDARG;
        }

        CLSID clsid;
        HRESULT hr;

        if (clsidString[0] == '{') {
            hr = CLSIDFromString(const_cast<LPWSTR> (clsidString), &clsid);
        }
        else {
            hr = CLSIDFromProgID(const_cast<LPWSTR> (clsidString), &clsid);
        }

        if (FAILED(hr)) {
            return hr;
        }

        return GetActiveObject(clsid);
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::GetActiveObject ( LPCSTR  clsidStringA ) throw ( )

inline

    {
        if (clsidStringA == NULL) {
            return E_INVALIDARG;
        }

        int size = lstrlenA(clsidStringA) + 1;
        int destSize = MultiByteToWideChar(CP_ACP, 0, clsidStringA, size, NULL, 0);

        LPWSTR clsidStringW;
        __try {
            clsidStringW = static_cast<LPWSTR>(_alloca(destSize * sizeof(WCHAR)));
        }
        __except (GetExceptionCode() == STATUS_STACK_OVERFLOW) {
            clsidStringW = NULL;
        }

        if (clsidStringW == NULL) {
            return E_OUTOFMEMORY;
        }

        if (MultiByteToWideChar(CP_ACP, 0, clsidStringA, size, clsidStringW, destSize) == 0) {
            return HRESULT_FROM_WIN32(GetLastError());
        }

        return GetActiveObject(clsidStringW);
    }

template<typename _IIID>

static const IID& _com_ptr_t< _IIID >::GetIID ( ) throw ( )

inlinestatic

    { 
        return ThisIIID::GetIID(); 
    }

template<typename _IIID>

Interface* _com_ptr_t< _IIID >::GetInterfacePtr ( ) const throw ( )

inline

    { 
        return m_pInterface; 
    }

template<typename _IIID>

Interface*& _com_ptr_t< _IIID >::GetInterfacePtr ( ) throw ( )

inline

    { 
        return m_pInterface; 
    }

template<typename _IIID>

_com_ptr_t< _IIID >::operator bool ( ) const throw ( )

inline

    { 
        return m_pInterface != NULL; 
    }

template<typename _IIID>

_com_ptr_t< _IIID >::operator Interface & ( ) const

inline

    { 
        if (m_pInterface == NULL) {
            _com_issue_error(E_POINTER);
        }

        return *m_pInterface; 
    }

template<typename _IIID>

_com_ptr_t< _IIID >::operator Interface * ( ) const throw ( )

inline

    { 
        return m_pInterface; 
    }

template<typename _IIID>

template<typename _OtherIID >

bool _com_ptr_t< _IIID >::operator!= ( const _com_ptr_t< _OtherIID > &  p ) const

inline

    {
        return !(operator==(p));
    }

template<typename _IIID>

template<typename _InterfaceType >

bool _com_ptr_t< _IIID >::operator!= ( _InterfaceType *  p ) const

inline

    {
        return !(operator==(p));
    }

template<typename _IIID>

bool _com_ptr_t< _IIID >::operator!= ( int  null ) const

inline

    {
        return !(operator==(null));
    }

template<typename _IIID>

Interface** _com_ptr_t< _IIID >::operator& ( ) throw ( )

inline

    {
        _Release();
        m_pInterface = NULL;
        return &m_pInterface;
    }

template<typename _IIID>

Interface& _com_ptr_t< _IIID >::operator* ( ) const

inline

    { 
        if (m_pInterface == NULL) {
            _com_issue_error(E_POINTER);
        }

        return *m_pInterface; 
    }

template<typename _IIID>

Interface* _com_ptr_t< _IIID >::operator-> ( ) const

inline

    { 
        if (m_pInterface == NULL) {
            _com_issue_error(E_POINTER);
        }

        return m_pInterface; 
    }

template<typename _IIID>

template<typename _OtherIID >

bool _com_ptr_t< _IIID >::operator< ( const _com_ptr_t< _OtherIID > &  p ) const

inline

    {
        return _CompareUnknown(p) < 0;
    }

template<typename _IIID>

template<typename _InterfaceType >

bool _com_ptr_t< _IIID >::operator< ( _InterfaceType *  p ) const

inline

    {
        return _CompareUnknown(p) < 0;
    }

template<typename _IIID>

template<typename _OtherIID >

bool _com_ptr_t< _IIID >::operator<= ( const _com_ptr_t< _OtherIID > &  p ) const

inline

    {
        return _CompareUnknown(p) <= 0;
    }

template<typename _IIID>

template<typename _InterfaceType >

bool _com_ptr_t< _IIID >::operator<= ( _InterfaceType *  p ) const

inline

    {
        return _CompareUnknown(p) <= 0;
    }

template<typename _IIID>

template<typename _OtherIID >

_com_ptr_t& _com_ptr_t< _IIID >::operator= ( const _com_ptr_t< _OtherIID > &  p )

inline

    {
        HRESULT hr = _QueryInterface(p);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }

        return *this;
    }

template<typename _IIID>

template<typename _InterfaceType >

_com_ptr_t& _com_ptr_t< _IIID >::operator= ( _InterfaceType *  p )

inline

    {
        HRESULT hr = _QueryInterface(p);
    
        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }

        return *this;
    }

template<typename _IIID>

template<>

_com_ptr_t& _com_ptr_t< _IIID >::operator= ( Interface *  pInterface ) throw ( )

inline

    {
        if (m_pInterface != pInterface) {
            Interface* pOldInterface = m_pInterface;

            m_pInterface = pInterface;

            _AddRef();

            if (pOldInterface != NULL) {
                pOldInterface->Release();
            }
        }

        return *this;
    }

template<typename _IIID>

_com_ptr_t& _com_ptr_t< _IIID >::operator= ( const _com_ptr_t< _IIID > &  cp ) throw ( )

inline

    { 
        return operator=(cp.m_pInterface); 
    }

template<typename _IIID>

_com_ptr_t& _com_ptr_t< _IIID >::operator= ( int  null )

inline

    {
        if (null != 0) {
            _com_issue_error(E_POINTER);
        }

        return operator=(reinterpret_cast<Interface*>(NULL));
    }

template<typename _IIID>

_com_ptr_t& _com_ptr_t< _IIID >::operator= ( const _variant_t &  varSrc )

inline

    {
        HRESULT hr = QueryStdInterfaces(varSrc);

        if (FAILED(hr) && (hr != E_NOINTERFACE)) {
            _com_issue_error(hr);
        }

        return *this;
    }

template<typename _IIID>

template<typename _OtherIID >

bool _com_ptr_t< _IIID >::operator== ( const _com_ptr_t< _OtherIID > &  p ) const

inline

    {
        return _CompareUnknown(p) == 0;
    }

template<typename _IIID>

template<typename _InterfaceType >

bool _com_ptr_t< _IIID >::operator== ( _InterfaceType *  p ) const

inline

    {
        return _CompareUnknown(p) == 0;
    }

template<typename _IIID>

template<>

bool _com_ptr_t< _IIID >::operator== ( Interface *  p ) const

inline

    {
        return (m_pInterface == p) 
                    ? true
                    : _CompareUnknown(p) == 0;
    }

template<typename _IIID>

template<>

bool _com_ptr_t< _IIID >::operator== ( const _com_ptr_t< _IIID > &  p ) const throw ( )

inline

    {
        return operator==(p.m_pInterface);
    }

template<typename _IIID>

bool _com_ptr_t< _IIID >::operator== ( int  null ) const

inline

    {
        if (null != 0) {
            _com_issue_error(E_POINTER);
        }

        return m_pInterface == NULL;
    }

template<typename _IIID>

template<typename _OtherIID >

bool _com_ptr_t< _IIID >::operator> ( const _com_ptr_t< _OtherIID > &  p ) const

inline

    {
        return _CompareUnknown(p) > 0;
    }

template<typename _IIID>

template<typename _InterfaceType >

bool _com_ptr_t< _IIID >::operator> ( _InterfaceType *  p ) const

inline

    {
        return _CompareUnknown(p) > 0;
    }

template<typename _IIID>

template<typename _OtherIID >

bool _com_ptr_t< _IIID >::operator>= ( const _com_ptr_t< _OtherIID > &  p ) const

inline

    {
        return _CompareUnknown(p) >= 0;
    }

template<typename _IIID>

template<typename _InterfaceType >

bool _com_ptr_t< _IIID >::operator>= ( _InterfaceType *  p ) const

inline

    {
        return _CompareUnknown(p) >= 0;
    }

template<typename _IIID>

template<typename _InterfaceType >

HRESULT _com_ptr_t< _IIID >::QueryInterface ( const IID &  iid, _InterfaceType *&  p  ) throw ( )

inline

    {
        if (m_pInterface != NULL) {
            return m_pInterface->QueryInterface(iid, reinterpret_cast<void**>(&p));
        }

        return E_POINTER;
    }

template<typename _IIID>

template<typename _InterfaceType >

HRESULT _com_ptr_t< _IIID >::QueryInterface ( const IID &  iid, _InterfaceType **  p  ) throw ( )

inline

    {
        return QueryInterface(iid, *p);
    }

template<typename _IIID>

HRESULT _com_ptr_t< _IIID >::QueryStdInterfaces ( const _variant_t &  varSrc ) throw ( )

inlineprivate

    {
        if (V_VT(&varSrc) == VT_DISPATCH) {
            return _QueryInterface(V_DISPATCH(&varSrc));
        }

        if (V_VT(&varSrc) == VT_UNKNOWN) {
            return _QueryInterface(V_UNKNOWN(&varSrc));
        }

        // We have something other than an IUnknown or an IDispatch.
        // Can we convert it to either one of these?
        // Try IDispatch first
        //
        VARIANT varDest;
        VariantInit(&varDest);

        HRESULT hr = VariantChangeType(&varDest, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc)), 0, VT_DISPATCH);
        if (SUCCEEDED(hr)) {
            hr = _QueryInterface(V_DISPATCH(&varDest));
        }

        if (hr == E_NOINTERFACE) {
            // That failed ... so try IUnknown
            //
            VariantInit(&varDest);
            hr = VariantChangeType(&varDest, const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc)), 0, VT_UNKNOWN);
            if (SUCCEEDED(hr)) {
                hr = _QueryInterface(V_UNKNOWN(&varDest));
            }
        }

        VariantClear(&varDest);
        return hr;
    }

template<typename _IIID>

void _com_ptr_t< _IIID >::Release ( )

inline

    {
        if (m_pInterface == NULL) {
            _com_issue_error(E_POINTER);
        }
        else {
            m_pInterface->Release();
            m_pInterface = NULL;
        }
    }

Member Data Documentation

template<typename _IIID>

Interface* _com_ptr_t< _IIID >::m_pInterface

private

---

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

• VS2013/inc/comip.h