#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 ()

	_com_ptr_t (_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= (_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>

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

inline

         : m_pInterface(cp.m_pInterface)
     {
         cp.m_pInterface = nullptr;
     }

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 = NULL;
             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;
         }
 
         size_t const size = strlen(clsidStringA) + 1;
 
         if (size > INT_MAX) {
             return E_INVALIDARG;
         }
 
         int const destSize = MultiByteToWideChar(CP_ACP, 0, clsidStringA, static_cast<int>(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, static_cast<int>(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;
         }
 
         size_t const size = strlen(clsidStringA) + 1;
 
         if (size > INT_MAX) {
             return E_INVALIDARG;
         }
 
         int const destSize = MultiByteToWideChar(CP_ACP, 0, clsidStringA, static_cast<int>(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, static_cast<int>(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 != nullptr) {
                 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=	(	_com_ptr_t< _IIID > &&	cp	)
throw	(
	)

inline

     {
         if (m_pInterface != cp.m_pInterface) {
             Interface* pOldInterface = m_pInterface;
 
             m_pInterface = cp.m_pInterface;
             cp.m_pInterface = nullptr;
 
             if (pOldInterface != nullptr) {
                 pOldInterface->Release();
             }
         }
 
         return *this;
     }

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:

VS2015/inc/comip.h

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation