smartptr.h

Go to the documentation of this file.

/*
 *  Important Note: 
 *  This code originally comes from www.codeproject.com
 *  and was written by Sandu Turcan (idlsoft@hotmail.com)
 *  The code has been modified, with permission, and in this
 *  version is covered by the terms of the following licence:
 *
 *  Copyright (c) 2003, Matt Beard
 *
 *  This software is provided 'as-is', without any express or implied warranty.
 *  In no event will the authors be held liable for any damages arising from
 *  the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *    1. The origin of this software must not be misrepresented; you must
 *       not claim that you wrote the original software. If you use this
 *       software in a product, an acknowledgment in the product
 *       documentation would be appreciated but is not required.
 *  
 *    2. Altered source versions must be plainly marked as such, and must
 *       not be misrepresented as being the original software.
 *  
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#ifndef MXFLIB__SMARTPTR_H
#define MXFLIB__SMARTPTR_H

// Pointer debug enable and disable
//#define PTRDEBUG( x ) x
#define PTRDEBUG( x )

// Pointer checking enable and disable (takes a lot of CPU time)
// If this is enabled the application code must instantiate and check PtrCheckList
//#define PTRCHECK( x ) x
#define PTRCHECK( x )


// Ensure we know NULL
#include <stdlib.h>

namespace mxflib 
{
    // Forward declaration of SmartPtr to allow it to be befreinded
    template <class T> class SmartPtr;

    // Forward declare ParentPtr to allow it to be used in RefCount<>
    template <class T> class ParentPtr;


    template <class T> class IRefCount 
    {
        // Allow SmartPtr access to our internals
        friend class SmartPtr<T>;
        
        // Allow ParentPtr access to our internals
        friend class ParentPtr<T>;

    protected:
        // A number of pure virtual functions that the reference counter needs
        
        virtual void __IncRefCount() = 0;               
        virtual void __DecRefCount() = 0;               
        virtual T * GetPtr() = 0;                       
        virtual IRefCount<T> * GetRef() = 0;            

        virtual void AddRef(ParentPtr<T> &Ptr) = 0;     
        virtual void DeleteRef(ParentPtr<T> &Ptr) = 0;  
        virtual void ClearParents(void) = 0;            
        
        virtual ~IRefCount() {};
    };

    // Definitions for running memory leak tests
    typedef std::pair<void*,std::string> PtrCheckListItemType;
    typedef std::list<PtrCheckListItemType> PtrCheckListType;
    PTRCHECK( extern PtrCheckListType PtrCheckList; )
}


namespace mxflib 
{


    template <class T> class RefCount : public IRefCount<T>
    {
    protected:
        int __m_counter;                                    

        typedef ParentPtr<T> LocalParent;                   
        typedef std::list<LocalParent*> LocalParentList;    
        LocalParentList *ParentPointers;                    

    protected:
        virtual void __IncRefCount()
        {
            __m_counter++;

            PTRDEBUG( debug("%p Increment count -> %p\n", this, __m_counter); )
        }

        virtual void __DecRefCount()
        {
            __m_counter--;

            PTRDEBUG( debug("%p Decrement count -> %d\n", this, __m_counter); )

            if(__m_counter<=0)
            {
                PTRDEBUG( debug("%p Destroying\n", this); )

                __DestroyRef();
            }
        }

        virtual T * GetPtr()
        {
            return ((T *)this);
        }

        virtual IRefCount<T>* GetRef()
        {
            return this;
        }


        virtual void __DestroyRef() 
        { 
            if(GetPtr()!=NULL)
            {
                // If we are "checking" locate and remove our entry
                PTRCHECK
                ( 
                    PtrCheckListType::iterator it = PtrCheckList.begin();
                    while(it != PtrCheckList.end())
                    {
                        if((*it).first == (void*)this)
                        {
                            PtrCheckList.erase(it);
                            break;
                        }
                        it++;
                    }
                )

                delete GetPtr();
            }
        }

        virtual void AddRef(ParentPtr<T> &Ptr)
        {
            PTRDEBUG( debug("Adding ParentPtr(%p) to %p\n", &Ptr, this); )
            
            if(!ParentPointers) ParentPointers = new LocalParentList;
            ParentPointers->push_back(&Ptr);
        }

        virtual void DeleteRef(ParentPtr<T> &Ptr)
        {
            if(ParentPointers)
            {
                typename LocalParentList::iterator it = ParentPointers->begin();
                while(it != ParentPointers->end())
                {
                    if((*it) == &Ptr)
                    {
                        PTRDEBUG( debug("Deleting ParentPtr(%p) from %p\n", &Ptr, this); )
                        ParentPointers->erase(it);
                        return;
                    }
                    it++;
                }
            }
            error("Tried to clear ParentPtr(%p) from %p but that ParentPtr does not exist\n", &Ptr, this);
        }

    protected:
        RefCount()
        {
            // If we are "checking" add entry to the list
            // We add to the start of the list as this gives the best chance of finding the
            // item quickly when it is deleted (most objects are first-in-last-out)
            PTRCHECK( PtrCheckList.push_front(PtrCheckListItemType((void*)this, PrintInfo())); )

            // No references yet!
            __m_counter = 0;

            // No parent pointers (yet) reference this item
            ParentPointers = NULL;

            PTRDEBUG( debug("%p Build new (zero) count\n", this); )
        }


        virtual ~RefCount() 
        {
            if(ParentPointers) ClearParents(); 
        }

        virtual void ClearParents(void);

        PTRCHECK
        (
        public:
            virtual std::string PrintInfo(void)
            {
                char buffer[1024];
                sprintf(&buffer[0], "Item size = %d :", sizeof(T));
                for(int i=0; i<min(sizeof(T), 64); i++) sprintf(&buffer[strlen(buffer)], " %02x", ((UInt8*)(this))[i]);
                return std::string(buffer);
            }

            void SetDebug(std::string str)
            {
                PtrCheckListType::iterator it = PtrCheckList.begin();
                while(it != PtrCheckList.end())
                {
                    if((*it).first == (void*)this)
                    {
                        PTRDEBUG( debug("Setting text to (%s)\n", str.c_str()); )
                        (*it).second = str;
                        return;
                    }
                    it++;
                }
            }
        )
    };

    // Clear all parent pointers
    template <class T> void mxflib::RefCount<T>::ClearParents(void)
    {
        if(ParentPointers)
        {
            typename LocalParentList::iterator it = ParentPointers->begin();
            while(it != ParentPointers->end())
            {
                (*it)->ClearFromParent();
                it++;
            }

            delete ParentPointers;
        }
    }
}


namespace mxflib
{

    template <class T> class SmartPtr 
    {
    protected:
        IRefCount<T> *__m_refcount;     

        PTRDEBUG( std::string DebugName; )
        

        class __RefCounter : public RefCount<T>
        {
        private:
            T *__m_ptr;                 
        protected:
            virtual T * GetPtr() const { return __m_ptr; }


            virtual void __DestroyRef() { delete this; }

        public:
            __RefCounter(T *ptr)
            {
                __m_ptr = ptr;
            }

            virtual ~__RefCounter()
            {
                RefCount<T>::__DestroyRef();
            }
        };


/*  DRAGONS: Removed to allow kludge to fix gcc 3.3.x bug
        void __Assign(void *ptr)
        {
            if(ptr==NULL)
                __Assign((IRefCount<T> *)NULL);
            else
            {
                __Assign(new __RefCounter(static_cast<T *>(ptr)));
            }
        }
*/

/*  DRAGONS:  KLUDGE to fix gcc 3.3.x bug - remove generic assign and force all smart pointer targets to be derived from IRefCount<> */
/*  DRAGONS:  If this klidge is undone ParentPtr will need updating to ensure it works with non-RefCount versions */


        virtual void __Assign(IRefCount<T> *refcount)
        {
            PTRDEBUG( if(DebugName.size()) debug("%s changing from %p to %p\n", DebugName.c_str(), __m_refcount, refcount); )

            // Attach us to the new object first
            // This is important in case we are assigned to
            // the same thing we are already attatched to,
            // in which case detatching first could cause
            // our object to be deleted!!
            if(refcount!=NULL) refcount->__IncRefCount();

            // Record what we were attached to
            IRefCount<T> *oldref = __m_refcount;

            // Make the new attachment
            __m_refcount = refcount;

            // Break the old attachment
            if(oldref!=NULL) oldref->__DecRefCount();
        }

    public:
        SmartPtr()
        {
            __m_refcount = NULL;
        }

        SmartPtr(IRefCount<T> * ptr)
        {
            __m_refcount = NULL;
            __Assign(ptr);
        }

        SmartPtr(const SmartPtr<T> &sp)
        {
            __m_refcount = NULL;
            __Assign(sp.__m_refcount);
        }

        virtual ~SmartPtr()
        {
            __Assign((IRefCount<T> *)NULL);
        }

        T *GetPtr() const
        {
            if(__m_refcount==NULL) return NULL;
            return __m_refcount->GetPtr();
        }

        IRefCount<T> *GetRef() const
        {
            if(__m_refcount==NULL) return NULL;
            return __m_refcount->GetRef();
        }

        SmartPtr & operator = (const SmartPtr<T> &sp) {__Assign(sp.__m_refcount); return *this;}

        SmartPtr & operator = (IRefCount<T> * ptr) {__Assign(ptr); return *this;}

        T * operator ->()
        {
            ASSERT(GetPtr()!=NULL);
            return GetPtr();
        }

        const T * operator ->() const
        {
            ASSERT(GetPtr()!=NULL);
            return (const T*)GetPtr();
        }

        operator T* () const
        {
            return GetPtr();
        }

        bool operator !()
        {
            return GetPtr()==NULL;
        }

        bool operator ==(const SmartPtr &sp)
        {
            return GetPtr()==sp.GetPtr();
        }

        bool operator !=(const SmartPtr &sp)
        {
            return GetPtr()!=sp.GetPtr();
        }

        bool operator<(SmartPtr &Other) { return this.operator<(*Other->GetPtr()); }


        template <class U> U* Cast(U*) { return dynamic_cast<U*>(GetPtr()); } 

        PTRDEBUG( void SetDebugName(std::string Name) { DebugName = Name; } )
    };
}


namespace mxflib
{

    // DRAGONS: Strict C++ compilers (such as GCC 3.4.x) require members of superclass templates to be referenced by this-> to remove possilbe ambiguities
    template<class T> class ParentPtr : public SmartPtr<T>
    {
    protected:

        virtual void __Assign(IRefCount<T> *refcount)
        {
            PTRDEBUG( debug("Assigning parent pointer at %p to %p\n", this, refcount); )

            // Remove us from the old parent's list of parent pointers
            if(this->__m_refcount) this->__m_refcount->DeleteRef(*this);

            // Make the new attachment
            this->__m_refcount = refcount;

            // Add us to the new parent's list of parent pointers (so we will be cleared if it is deleted)
            if(refcount) refcount->AddRef(*this);
        }

    public:
        ParentPtr()
        {
            this->__m_refcount = NULL;
        }

        ParentPtr(SmartPtr<T> ptr)
        {
            this->__m_refcount = NULL;
            __Assign(ptr.GetRef());
        }

        ParentPtr(IRefCount<T> * ptr)
        {
            this->__m_refcount = NULL;
            __Assign(ptr);
        }

        ParentPtr(const ParentPtr &rhs)
        {
            this->__m_refcount = NULL;
            __Assign(rhs.GetRef());
        }

        ~ParentPtr()
        {
            // Remove us from the old parent's list of parent pointers
            if(this->__m_refcount) (this->__m_refcount)->DeleteRef(*this);

            this->__m_refcount = NULL;
        }

        ParentPtr & operator=(const SmartPtr<T> &sp) { __Assign(sp.GetRef()); return *this;}

        ParentPtr & operator=(const ParentPtr<T> &sp) { __Assign(sp.__m_refcount); return *this;}

        ParentPtr & operator=(T *Ptr) { __Assign((IRefCount<T>*)Ptr); return *this; }

        void Clear(void) 
        {
            // Remove us from the old parent's list of parent pointers
            if(this->__m_refcount) this->__m_refcount->DeleteRef(*this);

            this->__m_refcount = NULL; 
        }


        void ClearFromParent(void) { this->__m_refcount = NULL; };
    };
}

         
#define SmartPtr_Cast(Ptr, Type) ( Ptr.Cast((Type*)NULL) )

#endif // MXFLIB__SMARTPTR_H

---