p6refcounted.h

Go to the documentation of this file.

#ifndef P6REFCOUNTED_H__
#define P6REFCOUNTED_H__ 1

#ifdef __cplusplus
namespace P6R {
extern "C" {
#endif

   #undef INTERFACE
   #define INTERFACE p6IRefCounted
   P6DECLAREIF(p6IRefCounted)
   {
      P6DECLCOMMETHOD_(P6INT32,addref)(P6THIS) P6PURE;
      P6DECLCOMMETHOD_(P6INT32,release)(P6THIS) P6PURE;
   };

#ifdef __cplusplus
} // extern "C"

   template<typename I> class p6RefCountedBase
   {
   protected:
      p6RefCountedBase()
      : m_pRaw(NULL)
      { }

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

      void release()
      {
         if(m_pRaw) {
            P6R::p6IRefCounted* pTmp = m_pRaw;
            m_pRaw            = NULL;
            pTmp->release();
         }
      }

   private:
      //I** operator &() { return reinterpret_cast<I**>(&m_pRaw); } 

   public:
      typedef I element_type;

      ~p6RefCountedBase() { release(); }

      operator I*()                 const { return static_cast<I*>(m_pRaw); }
      I& operator*()                const { P6ASSERT(NULL != m_pRaw); return *static_cast<I*>(m_pRaw); }
      I* operator->()               const { P6ASSERT(NULL != m_pRaw); return static_cast<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; }


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

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

      inline void swap(I** pRaw)
      {
         I *tmp = *pRaw;
         *pRaw    = reinterpret_cast<I*>(m_pRaw);
         m_pRaw   = tmp;
      }

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

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

      void attach(I* pIface)
      {
         release();
         m_pRaw = pIface;
      }
      
      I* detach()
      {
         I* p = m_pRaw;
         m_pRaw = NULL;
         return p;
      }
      
      void detach(I** ppIface)
      {
         *ppIface = NULL;
         swap(ppIface);
      }

   protected:
      I                    *m_pRaw;
      //P6R::p6IRefCounted *m_pRaw;

   };


   template<typename I> class p6RefCounted : public p6RefCountedBase<I>
   {
   public:
      typedef I element_type;
      explicit p6RefCounted(I* ip = 0) : p6RefCountedBase<I>(ip)
      { }

      p6RefCounted(const p6RefCounted<I>& rSI) : p6RefCountedBase<I>(rSI.m_pRaw)
      { }

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

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


} // namespace
#endif // __cplusplus
#endif