p6comptr.h

Go to the documentation of this file.

#ifndef P6COMPTR_H__
#define P6COMPTR_H__ 1

#include "p6runtimeapi.h"

#ifdef __cplusplus
namespace P6R {

   template<typename I>
   class p6ComPtrNoAddrefRelease : public I
   {
      P6NOEXPORT P6R::P6INT32 P6STDCALL addref() = 0;
      P6NOEXPORT P6R::P6INT32 P6STDCALL release() = 0;
   };

   template<typename I> class p6ComPtrBase
   {
   protected:

      p6ComPtrBase(I *pRawPtr = NULL)
      : m_pRaw(pRawPtr)
      { 
         if(m_pRaw) { m_pRaw->addref(); }
      }

      P6VOID release()
      {
         //P6R::p6ICom* pTmp = m_pRaw;
         I* pTmp = m_pRaw;
         
         m_pRaw = NULL;
         if(pTmp) {
            pTmp->release();
         }
      }

   //private:
      // This causes compilation errors with stlpd_std::list<> on windows VC++ 2005
      // We'd like to make this private to prevent people from doing the wrong
      // thing with address of.  Using this operator can cause leaks when p6ComPtr
      // has already been assigned an interface pointer.  The pointer will
      // not be released before it is potentially overwritten. addressofWithRelease() 
      // should be used instead.
      //const p6ComPtrBase<I>* operator&() const { return this; } 

   public:
      typedef I element_type;

      ~p6ComPtrBase() { release(); }
      
      operator I*()                             const { return static_cast<I*>(m_pRaw); }
      I& operator*()                            const { P6ASSERT(NULL != m_pRaw); return *static_cast<I*>(m_pRaw); }
      p6ComPtrNoAddrefRelease<I> * operator->() const { return (p6ComPtrNoAddrefRelease<I>*) m_pRaw; }
      P6BOOL operator==(I* pI)                  const { return (pI == m_pRaw)    ? P6TRUE:P6FALSE; }
      P6BOOL operator!=(I* pI)                  const { return (pI != m_pRaw)    ? P6TRUE:P6FALSE; }
      P6BOOL operator<(I* pI)                   const { return (m_pRaw < pI)     ? P6TRUE:P6FALSE; }
      P6BOOL operator!()                        const { return (NULL == m_pRaw)  ? P6TRUE:P6FALSE; }

      inline I** addressof()
      {
         return reinterpret_cast<I**>(&m_pRaw);
      }

      inline I** addressofWithRelease()
      {
         release(); 
         return reinterpret_cast<I**>(&m_pRaw);
      }

      inline P6VOID swap(I** ppIface)
      {
         I *tmp = *ppIface;
         *ppIface = reinterpret_cast<I*>(m_pRaw);
         m_pRaw   = tmp;
      }

      inline P6VOID swap(p6ComPtrBase<I> &rhs)
      {
         I *tmp = rhs.m_pRaw;
         rhs.m_pRaw  = m_pRaw;
         m_pRaw      = tmp;
      }

      inline I* get() const
      {
         return reinterpret_cast<I*>(m_pRaw);
      }

      void attach(I* pIface)
      {
         release();
         m_pRaw = pIface;
      }

      inline I* detach()
      {
         I* p = m_pRaw;
         m_pRaw = NULL;
         return p;
      }

      inline P6VOID detach(I** ppIface)
      {
         *ppIface = NULL;
         this->swap(ppIface);
      }
      
      inline P6R::P6ERR createInstance(P6R::p6ICom *pOuter,const P6REFCID cid,const P6REFIID riid)
      {
         release();
         return p6CreateInstance(pOuter,cid,riid,reinterpret_cast<P6VOID**>(&m_pRaw));
      }

      inline P6R::P6ERR getRuntimeIface(const P6REFIID riid)
      {
         release();
         return p6GetRuntimeIface(riid,reinterpret_cast<P6VOID**>(&m_pRaw));
      }
      
      template<typename Q> P6R::P6ERR queryInterface(const P6REFIID riid,Q** ppIface)
      {
         P6ASSERT(NULL != m_pRaw);
         return m_pRaw->queryInterface(riid,reinterpret_cast<P6VOID**>(ppIface));
      }
      
   protected:
      I  *m_pRaw;
   };

   template<typename I> class p6ComPtr : public p6ComPtrBase<I>
   {
   public:
      typedef I element_type;
      explicit p6ComPtr(I* ip = NULL) : p6ComPtrBase<I>(ip)
      { }

      p6ComPtr(const P6REFCID rclsid,const P6REFIID riid,P6R::P6ERR *pErr = NULL) : p6ComPtrBase<I>(NULL)
      { 
         P6ERR err = p6ComPtrBase<I>::createInstance(NULL,rclsid,riid);
         P6ASSERT(eOk == err);
         if(pErr) (*pErr) = err;
      }

      p6ComPtr(const P6REFIID riid,P6R::P6ERR *pErr = NULL)
      {
         P6ERR err = p6ComPtrBase<I>::getRuntimeIface(riid);
         P6ASSERT(eOk == err);
         if(pErr) (*pErr) = err;
      }

      p6ComPtr(p6ICom *pCom,const P6REFIID riid,P6R::P6ERR *pErr = NULL) : p6ComPtrBase<I>(0)
      {
         p6ComPtr<I> tmp;
         P6R::P6ERR err = pCom->queryInterface(riid,(P6VOID**)tmp.addressof());
         P6ASSERT(eOk == err);
         if(pErr) (*pErr) = err;
         if(P6SUCCEEDED(err)) p6ComPtrBase<I>::swap(tmp);
      }
      
      p6ComPtr(const p6ComPtr<I>& rSI) : p6ComPtrBase<I>(rSI.m_pRaw)
      { }

      p6ComPtr<I>& operator=(I* ip)
      {
         if(*this != ip) {
            p6ComPtr<I> tmp(ip);
            this->swap(tmp);
         }
         return *this;
      }

      p6ComPtr<I>& operator=(const p6ComPtr<I>& cp)
      {
         if(*this!=cp) {
            p6ComPtr<I> tmp(cp);
            this->swap(tmp);
         }
         return *this;
      }
   };

   template<typename Interface> 
   P6VOID swap(p6ComPtr<Interface>& left,p6ComPtr<Interface>& right)
   {  left.swap(right); }

   template<> class p6ComPtr<p6ICom> : public p6ComPtrBase<p6ICom>
   {
   public:
      typedef p6ICom element_type;

      p6ComPtr()
         :  p6ComPtrBase<p6ICom>(NULL)
      {
      }
      
      explicit p6ComPtr(p6ICom *pI)
         : p6ComPtrBase<p6ICom>(pI)
      {
      }
      
      p6ComPtr(const p6ComPtr<p6ICom> &smartPtr)
         : p6ComPtrBase<p6ICom>(smartPtr.m_pRaw)
      {
      }

      operator p6ICom*() const
      {
         return get();
      }

      p6ComPtr<p6ICom>& operator=(p6ICom* ip)
      {
         if(*this != ip) {
            p6ComPtr<p6ICom> tmp(ip);
            this->swap(tmp);
         }
         return *this;
      }

      p6ComPtr<p6ICom>& operator=(const p6ComPtr<p6ICom>& cp)
      {
         if(*this!=cp) {
            p6ComPtr<p6ICom> tmp(cp);
            this->swap(tmp);
         }
         return *this;
      }
   };


#define VALIDATECOMPTR(type,smartComPtr) IID_##type, reinterpret_cast<P6R::P6VOID**>(static_cast<type**>((smartComPtr).addressofWithRelease()))


} // namespace
#endif // __cplusplus

#endif