Subversion Repositories AndroidProjects

#ifndef __SEXY_SMARTPTR_H__
#define __SEXY_SMARTPTR_H__
#include "Common.h"

#pragma pack(push,8) // need 8 byte alignment for InterlockedIncrement

namespace Sexy
{

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

class RefCount
{
private:
        mutable long mRefCount;

protected:
        // The compiler allows a derived destructor to be called if it's not explicitly declared
        // even if the parent destructor is private, so I make the parent destructor protected so that
        // derived classes can make their destructors protected as well.  (They get an error if the
        // parent destructor is private.)
        virtual ~RefCount() {}

public:
        RefCount() : mRefCount(0) {}

        const RefCount* CreateRef() const
        {
                InterlockedIncrement(&mRefCount);
                return this;
        }
       
        void Release()
        {
                if(InterlockedDecrement(&mRefCount)<=0)
                        delete this;
        }

        // You might want to assign one reference counted object to another simply to copy
        // the member variables of one to the other, but you certainly don't want to copy
        // the reference counts!
        RefCount(const RefCount&) : mRefCount(0) {}
        RefCount& operator=(const RefCount&) { return *this; }

        unsigned long GetRefCount() { return mRefCount; }      
};

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

// Const smart pointer.  Automatically performs reference counting on objects which
// implement the CreateRef and Release interface.  Allows const access to underlying object.
template <class T> class ConstSmartPtr
{
protected:
        T *p;

public:
        ConstSmartPtr() : p(NULL) {}

        // Copy constructor.  Assign and add reference to underlying object.
        ConstSmartPtr(const T* theObject) : p((T*)(theObject?theObject->CreateRef():NULL)) {}
        ConstSmartPtr(const ConstSmartPtr& theCopy) : p((T*)(theCopy?theCopy.p->CreateRef():NULL)){}

        // Destructor.  Remove reference to underlying object.
        ~ConstSmartPtr() { if(p!=NULL) p->Release(); }

        // Arrow operator allows ConstSmartPtr to be treated like actual pointer.
        const T* operator->() const { return p; }

        // Type case operator allows ConstSmartPtr to be cast to const T*,
        operator const T*() const { return p; }

        // Assignment operator.  Release old underlying object if not null.  Add reference to new object.
        const T* operator=(const T* thePtr)
        {
                if(p!=thePtr) // prevent self-assignment
                {
                        if(p!=NULL) p->Release();
                        p = (T*)(thePtr?thePtr->CreateRef():NULL);
                }

                return thePtr;
        }      

        const ConstSmartPtr& operator=(const ConstSmartPtr& theCopy)
        {
                operator=(theCopy.get());
                return *this;
        }

        // Allow comparions just like normal pointer.
        bool operator==(const T* thePtr) const { return p==thePtr; }
        bool operator!=(const T* thePtr) const { return p!=thePtr; }
        bool operator<(const T *thePtr) const { return p < thePtr; }

        // Accessor to actual object
        const T* get() const { return p; }

        struct Comp { bool operator()(const ConstSmartPtr &a, const ConstSmartPtr &b) const { return a.get()<b.get(); } };
};


// Smart pointer.  Automatically performs reference counting on objects which
// implement the CreateRef and Release interface.  Allows non-const access to underlying object.
template <class T> class SmartPtr : public ConstSmartPtr<T>
{
public:
        SmartPtr() {}
        SmartPtr(T* theObject) : ConstSmartPtr<T>(theObject){}
        SmartPtr(const SmartPtr& theCopy) : ConstSmartPtr<T>(theCopy.p) {}

        const SmartPtr& operator=(const SmartPtr& theCopy)
        {
                ConstSmartPtr<T>::operator=(theCopy.get());
                return *this;
        }

        T* operator=(T* thePtr)
        {
                ConstSmartPtr<T>::operator =(thePtr);
                return thePtr;
        }


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

        T* get() const { return p; }
};

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

typedef SmartPtr<RefCount> RefCountPtr;

} // namespace Sexy

#pragma pack(pop)

// Helper macro to forward declare reference counted classes along with their smart pointer definitions
#define SEXY_PTR_FORWARD(X) class X; typedef SmartPtr<X> X##Ptr
#define SEXY_PTR_FORWARDNS(X) class X; typedef Sexy::SmartPtr<X> X##Ptr

#endif