src/Resource/smart_ptr.h

Go to the documentation of this file.

#ifndef SMART_PTR_H
#define SMART_PTR_H

#if 0

        #define DEB(x) x
#else

        #define DEB(x)
#endif
#if 0

        #define DEB2(x) x
#else

        #define DEB2(x)
#endif

#define CONFIG_USE_BOOST_POINTERS
#ifdef CONFIG_USE_BOOST_POINTERS

#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#define SmartPtr boost::shared_ptr

#define SmartPtrDelete(target)  void boost::checked_delete<target>(target* x);

#else

#define SmartPtrDelete(target)  class SmartPtr<target>

class SmartPtrCount
{
        int m_refCount;

public:
        SmartPtrCount()
                : m_refCount( 1 )
        {
                DEB( printf("SmartPtrCount ctor...\n"));
        }

        virtual ~SmartPtrCount()
        {
                DEB( printf("SmartPtrCount dtor...\n"));
        }

        void IncRef() { m_refCount ++ ; }

        void DecRef() { m_refCount -- ; }
        int  GetRefCount() { return m_refCount; }
};

template <class T>
class SmartPtr
{
        T* m_data;
        SmartPtrCount* m_ref;

public:
        SmartPtr(T* ptr)
        {
                DEB( printf("SmartPtr T* ctor...\n"));
                // create a fresh copy
                CreateFresh( ptr );
        }
        
        SmartPtr()
                : m_data(NULL)
        {
                DEB( printf("SmartPtr ctor...\n"));
                m_ref = new SmartPtrCount();
        }

        SmartPtr(const SmartPtr& rhs)
                : m_data(NULL),
                m_ref(NULL)
        {
                DEB( printf("SmartPtr SmartPtr ctor...\n"));
                *this = rhs;
        }
        
        template<class Y>
        SmartPtr(SmartPtr<Y> const& rhs) 
                : m_data(rhs.m_data),
                m_ref(rhs.m_ref)
        {
                DEB( printf("SmartPtr SmartPtr<Y> ctor...\n"));
                m_ref->IncRef();
        }

        SmartPtr& operator=(const SmartPtr& rhs)
        {
                DEB2( printf("SmartPtr = operator...\n"));
                
                // increase the reference count
                if( m_ref == rhs.m_ref )
                {
                        DEB2( printf("m_ref = rhs.m_ref\n") );
                        return *this;
                }

                // Delete previous reference 
                DeleteRefCount();

                // TODO: What to do here?
                if( !rhs.m_ref )
                {
                        DEB2( printf("!rhs.m_ref\n") );
                        return *this;
                }
                
                DEB2( printf("no returns so far\n") );
                
                m_data = rhs.m_data;
                m_ref = rhs.m_ref;
                m_ref->IncRef();
                return *this;
        }

        virtual ~SmartPtr()
        {
                DEB( printf("SmartPtr dtor...\n"));
                DeleteRefCount();
        }

        void reset(T* ptr = 0)
        {       
                DeleteRefCount();
                CreateFresh( ptr );
        }

        T* get() const
        {
                return m_data;
        }

        T* operator->() const 
        {
                return m_data;
        }

        T& operator*() const
        {
                return *(m_data);
        }

        bool operator!() const
        {
                return (!m_ref || !m_data);
        }

        operator bool() const
        {
                return m_ref && m_data;
        }
        
        void print() const
        {
                printf("%d: %p (%p)\n", m_ref->GetRefCount(), m_data, this);
        }

private:
        void DeleteRefCount()
        {
                DEB2( printf("DeleteRefCount()\n") );
                // decrease the ref count (or delete pointer if it is 1)
                if( m_ref )
                {
                        DEB2( printf("m_ref\n") );
                        if( m_ref->GetRefCount() <= 1 )
                        {
                                DEB2( printf("m_ref->GetRefCount() <= 1\n") );
                                delete m_ref;
                                m_ref = NULL;
                                delete m_data;
                                m_data = NULL;
                        }
                        else
                        {
                                DEB2( printf("m_ref->GetRefCount() = %d\n", m_ref->GetRefCount()) );
                                m_ref->DecRef();
                        }
                }
                else
                {
                        DEB2( printf("!m_ref\n") );
                }
        };

        void CreateFresh(T* ptr)
        {
                m_ref = new SmartPtrCount();
                m_data = ptr;
        }
        
        template<class Y> friend class SmartPtr;
};

#endif // CONFIG_USE_BOOST_POINTERS
#endif // SMART_PTR_H

---