spl/RefCountPtr.h

/*
 *   This file is part of the Standard Portable Library (SPL).
 *
 *   SPL is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   SPL is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with SPL.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _refcountptr_h
#define _refcountptr_h

#include <spl/types.h>
#include <spl/Debug.h>
#include <spl/Exception.h>
#include <spl/threading/InterlockCounter.h>
#include <spl/Memory.h>

template<class Y>
struct _PtrHolder
{
private:
        bool m_threadSafe;
        mutable volatile short m_icount;
        mutable InterlockCounter m_tcount;

public:
        mutable Y* ptr;

        inline _PtrHolder (Y* rhs, bool threadSafe)
        : ptr(rhs), m_icount(1), m_tcount(1), m_threadSafe(threadSafe)
        {
        }

        inline void SetThreadSafeOn()
        {
                m_threadSafe = true;
        }

        inline void ValidateThis() const
        {
                ASSERT_MEM(this, sizeof(_PtrHolder<Y>));
        }

        inline int Count() const
        {
                if (m_threadSafe)
                {
                        return (int)m_tcount;
                }
                return m_icount;
        }

        inline void Inc()
        {
                if (m_threadSafe)
                {
                        m_tcount++;
                }
                else
                {
                        m_icount++;
                }
        }

        inline int Dec()
        {
                if (m_threadSafe)
                {
                        m_tcount--;
                        return (int)m_tcount;
                }
                m_icount--;
                return m_icount;
        }
        
        inline bool IsThreadSafe() const
        {
                return m_threadSafe;
        }
};

template<class T>
class RefCountPtr : public IMemoryValidate
{
private:
        mutable _PtrHolder<T> *m_ptr;

        inline void _Dec()
        {
                if (NULL != m_ptr)
                {
                        ASSERT(m_ptr->Count() > 0);
                        if (0 == m_ptr->Dec())
                        {
                                delete m_ptr->ptr;
                                delete m_ptr;
                        }
                }
        }

public:
    typedef T element_type;

    // constructor
    explicit RefCountPtr (T* ptr, bool threadSafe = false)
        {
                if (NULL == ptr)
                {
                        m_ptr = NULL;
                        return;
                }
                ASSERT_PTR(ptr);
                m_ptr = new _PtrHolder<T>(ptr, threadSafe);
        }

    // copy constructors (with implicit conversion)
    // - note: nonconstant parameter
    RefCountPtr (const RefCountPtr<T>& rhs) 
        : m_ptr(rhs.m_ptr)
        {
                if (NULL != m_ptr)
                {
                        ASSERT(m_ptr->Count() > 0);
                        m_ptr->ValidateThis();
                        m_ptr->Inc();
                }
        }

    RefCountPtr ()
        : m_ptr(NULL)
        {
        }

        RefCountPtr(_PtrHolder<T> *ptr)
        : m_ptr(ptr)
        {
                if(NULL != ptr)
                {
                        m_ptr->Inc();
                }
        }

  //  // assignments (with implicit conversion)
  //  // - note: nonconstant parameter
    RefCountPtr<T>& operator =(const RefCountPtr<T>& rhs)
    {
                _Dec();
                
                if (NULL != (m_ptr = rhs.m_ptr))
                {
                        ASSERT_MEM(m_ptr, sizeof(_PtrHolder<T>));
                        m_ptr->Inc();
                }

        return *this;
    }
    
    RefCountPtr<T>& operator =(T *p)
    {
                _Dec();
                if (NULL == p)
                {
                        m_ptr = NULL;
                        return *this;
                }
                ASSERT_PTR(p);
                m_ptr = new _PtrHolder<T>(p, NULL == m_ptr ? false : m_ptr->IsThreadSafe());
                
                return *this;
    }

#ifndef _WINDOWS
        // gnu has stricter definition of const.
    // assignments (with implicit conversion)
    // - note: nonconstant parameter
    RefCountPtr<T>& operator= (RefCountPtr<T>& rhs)
    {
                return *this = (const RefCountPtr<T>&)rhs;
    }
#endif

    // destructor
    virtual ~RefCountPtr()
    {
                Release();
    }

        inline void SetThreadSafeOn()
        {
                ASSERT(NULL != m_ptr);
                m_ptr->SetThreadSafeOn();
        }

        inline int ReferenceCount() const
        {
                return NULL == m_ptr ? 0 : m_ptr->Count();
        }

        inline bool IsNull() const
        {
                return NULL == m_ptr || NULL == m_ptr->ptr;
        }

        inline bool IsNotNull() const
        {
                return !IsNull();
        }

        void Release()
        {
                if (NULL != m_ptr)
                {                       
                        m_ptr->ValidateThis();
                        ASSERT(m_ptr->Count() > 0);

                        if (0 == m_ptr->Dec())
                        {
                                delete m_ptr->ptr;
                                delete m_ptr;
                        }
                        m_ptr = NULL;
                }
        }

        T* Detach()
        {
                if(m_ptr == NULL)
                {
                        return NULL;
                }
                ASSERT(m_ptr->Count() == 1);
                T* ret = m_ptr->ptr;
                delete m_ptr;
                m_ptr = NULL;
                return ret;
        }

    // value access
    inline T* Get() const
    {
                if (NULL == m_ptr)
                {
                        return NULL;
                }
                ASSERT(m_ptr->Count() > 0);
        return m_ptr->ptr;
    }

        // This is for casting of pointers
        inline _PtrHolder<T> *GetHolder() const
        {
                ASSERT(NULL == m_ptr || m_ptr->Count() > 0);
                return m_ptr;
        }

    inline T& operator*() const
    {
                ASSERT(NULL != m_ptr);
                ASSERT(m_ptr->Count() > 0);
        return *m_ptr->ptr;
    }

    inline T* operator->() const
    {
                ASSERT(NULL != m_ptr);
                ASSERT(m_ptr->Count() > 0);
        return m_ptr->ptr;
    }

        inline operator T&() const
        {
                if (NULL == m_ptr)
                {
                        throw new Exception("NULL pointer");
                }
                ASSERT(m_ptr->Count() > 0);
        return *m_ptr->ptr;
        }

#if defined(DEBUG) || defined(_DEBUG)
        void CheckMem() const
        {
                if (NULL != m_ptr)
                {
                        DEBUG_NOTE_MEM(m_ptr);
                        DEBUG_NOTE_MEM(m_ptr->ptr);
                        ValidateType( m_ptr->ptr );
                }
        }

        void ValidateMem() const
        {
                if (NULL != m_ptr)
                {
                        m_ptr->ValidateThis();
                        ASSERT_MEM(m_ptr->ptr, sizeof(T));
                        ValidateType( m_ptr->ptr );
                }
        }
#endif
};

#endif