RefCountPtr.h

Go to the documentation of this file.

#ifndef MiscLib__REFCOUNTPTR_HEADER__
#define MiscLib__REFCOUNTPTR_HEADER__
 
namespace MiscLib
{
    template <class T>
    class RefCountPtr
    {
    public:
        RefCountPtr() : m_ptr(0)
        {
        }
 
        template <class P>
        RefCountPtr(P* ptr) : m_ptr(ptr)
        {
            if (m_ptr)
            {
                m_ptr->AddRef();
            }
        }
 
        RefCountPtr(const RefCountPtr<T>& ptr) : m_ptr(ptr.m_ptr)
        {
            if (m_ptr)
            {
                m_ptr->AddRef();
            }
        }
 
        template <class P>
        RefCountPtr(const RefCountPtr<P>& ptr) : m_ptr(ptr.m_ptr)
        {
            if (m_ptr)
            {
                m_ptr->AddRef();
            }
        }
 
        ~RefCountPtr()
        {
            if (m_ptr)
            {
                m_ptr->Release();
            }
        }
 
        void
        Release()
        {
            if (m_ptr)
            {
                m_ptr->Release();
                m_ptr = 0;
            }
        }
 
        template <class N>
        T*
        New()
        {
            if (m_ptr)
            {
                m_ptr->Release();
            }
            m_ptr = new N();
            return m_ptr;
        }
 
        RefCountPtr<T>&
        operator=(const RefCountPtr<T>& ptr)
        {
            if (m_ptr == ptr.m_ptr)
            {
                return *this;
            }
            if (m_ptr)
            {
                m_ptr->Release();
            }
            m_ptr = ptr.m_ptr;
            if (m_ptr)
            {
                m_ptr->AddRef();
            }
            return *this;
        }
 
        template <class P>
        RefCountPtr<T>&
        operator=(const RefCountPtr<P>& ptr)
        {
            if (m_ptr == ptr.m_ptr)
            {
                return *this;
            }
            if (m_ptr)
            {
                m_ptr->Release();
            }
            m_ptr = ptr.m_ptr;
            if (m_ptr)
            {
                m_ptr->AddRef();
            }
            return *this;
        }
 
        template <class P>
        RefCountPtr<T>&
        operator=(P* ptr)
        {
            if (m_ptr == ptr)
            {
                return *this;
            }
            if (m_ptr)
            {
                m_ptr->Release();
            }
            m_ptr = ptr;
            if (m_ptr)
            {
                m_ptr->AddRef();
            }
            return *this;
        }
 
        T*
        operator->()
        {
            return m_ptr;
        }
 
        const T*
        operator->() const
        {
            return m_ptr;
        }
 
        T&
        operator*()
        {
            return *m_ptr;
        }
 
        const T&
        operator*() const
        {
            return *m_ptr;
        }
 
        operator T*()
        {
            return m_ptr;
        }
 
        operator const T*() const
        {
            return m_ptr;
        }
 
        T*
        Ptr()
        {
            return m_ptr;
        }
 
        const T*
        Ptr() const
        {
            return m_ptr;
        }
 
        template <class P>
        bool
        operator==(const RefCountPtr<P>& ptr) const
        {
            return m_ptr == ptr.m_ptr;
        }
 
        template <class P>
        bool
        operator==(P* ptr) const
        {
            return m_ptr == ptr;
        }
 
    private:
        T* m_ptr;
    };
}; // namespace MiscLib
 
#endif