SmartPointers.h

Go to the documentation of this file.

#ifndef __LDK_SMARTPOINTERS_HH__
#define __LDK_SMARTPOINTERS_HH__

//   Copyright (C) 2003-2006 Lorien Dunn.
//
//   Contact: loriendunn AT users DOT sourceforge DOT net
//
//   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.
//


#include "LDK/Memory.h"
#include "LDK/Object.h"

namespace LDK
{



template <class T>
class SmartPointerBase
{
public:
    typedef T  Type;
    typedef T* PointerType;
    typedef T& ReferenceType;
protected:
    PointerType mPtr;

    SmartPointerBase(PointerType p=NULL) : mPtr(p) {}

    class Tester
    {
    private:
        void operator delete(void*);
    public:
        Tester() {}
    };

public:
    inline static PointerType pointer(const SmartPointerBase& rhs) { return rhs.mPtr; }

    inline operator Tester*() const
    {
        if(!mPtr)
            return NULL;
        static Tester test;
        return &test;
    }

    inline PointerType operator->()
    {
        assert(mPtr);
        return mPtr;
    }

    inline ReferenceType operator*()
    {
        assert(mPtr);
        return *mPtr;
    }

    inline PointerType operator->() const
    {
        assert(mPtr);
        return mPtr;
    }

    inline ReferenceType operator*()  const
    {
        assert(mPtr);
        return *mPtr;
    }

    inline bool operator!() const // Enables "if (!sp) ..."
    {
        return mPtr == NULL;
    }

    inline friend bool operator==(const SmartPointerBase& lhs, const SmartPointerBase& rhs)
    {
        return pointer(lhs) == pointer(rhs);
    }

    template <typename U>
    inline friend bool operator==(const SmartPointerBase& lhs, const U* rhs)
    {
        return pointer(lhs) == rhs;
    }

    template <typename U>
    inline friend bool operator==(const U* lhs, const SmartPointerBase& rhs)
    {
        return pointer(rhs) == lhs;
    }

    inline friend bool operator!=(const SmartPointerBase& lhs, const SmartPointerBase& rhs)
    {
        return pointer(lhs) != pointer(rhs);
    }

    template <typename U>
    inline friend bool operator!=(const SmartPointerBase& lhs, const U* rhs)
    {
        return pointer(lhs) != rhs;
    }

    template <typename U>
    inline friend bool operator!=(const U* lhs, const SmartPointerBase& rhs)
    {
        return pointer(rhs) != lhs;
    }
};

template <class T>
class IntrusiveSmartPointer : public SmartPointerBase<T>
{
    inline static void incRefCount(IntrusiveSmartPointer& rhs)
    {
        if(rhs.mPtr)
            Object::incRef(*rhs.mPtr);
    }

    inline static void decRefCount(IntrusiveSmartPointer& rhs)
    {
        if(rhs.mPtr)
            if(Object::decRef(*rhs.mPtr)==0)
                rhs.mPtr = NULL;
    }

public:

    typedef typename SmartPointerBase<T>::PointerType PointerType;

    inline static size_t refCount(const IntrusiveSmartPointer& s)
    {
        return Object::refCount(*s.mPtr);
    }

    inline IntrusiveSmartPointer(PointerType p=NULL) :
     SmartPointerBase<T>(p)
    {
        incRefCount(*this);
    }

    inline IntrusiveSmartPointer(const IntrusiveSmartPointer& rhs)
     : SmartPointerBase<T>(rhs.mPtr)
    {
        incRefCount(*this);
    }

    inline ~IntrusiveSmartPointer()
    {
        decRefCount(*this);
    }

    inline IntrusiveSmartPointer& operator=(const IntrusiveSmartPointer& rhs)
    {
        decRefCount(*this);
        SmartPointerBase<T>::mPtr = rhs.mPtr;
        incRefCount(*this);
        return *this;
    }
};

template <class T>
class SmartPointer  : public SmartPointerBase<T>
{
protected:
    mutable size_t* mRefCountPtr;

    inline static void incRefCount(SmartPointer& rhs)
    {
        assert(rhs.mRefCountPtr);
        ++(*rhs.mRefCountPtr);
    }

    inline static void decRefCount(SmartPointer& rhs)
    {
        assert(rhs.mRefCountPtr);
        if(--(*rhs.mRefCountPtr) == 0)
        {
            LDK::destroy(rhs.mRefCountPtr);
            rhs.mRefCountPtr = NULL;
            if(rhs.mPtr)
            {
                LDK::destroy(rhs.mPtr);
                rhs.mPtr = NULL;
            }
        }
    }

public:

    typedef typename SmartPointerBase<T>::PointerType PointerType;

    inline static size_t refCount(const SmartPointer& s) { return *s.mRefCountPtr; }

    inline SmartPointer(PointerType p=NULL) :
     SmartPointerBase<T>(NULL)
    {
        mRefCountPtr = LDK_CREATE1(size_t,1);
        SmartPointerBase<T>::mPtr = p;
    }

    inline SmartPointer(const SmartPointer& rhs)
     : SmartPointerBase<T>(rhs.mPtr)
     , mRefCountPtr(rhs.mRefCountPtr)
    {
        incRefCount(*this);
    }

    inline ~SmartPointer()
    {
        decRefCount(*this);
    }

    inline SmartPointer& operator=(const SmartPointer& rhs)
    {
        decRefCount(*this);
        mRefCountPtr = rhs.mRefCountPtr;
        SmartPointerBase<T>::mPtr = rhs.mPtr;
        incRefCount(*this);
        return *this;
    }
};

template <class T>
class NewSmartPointer  : public SmartPointerBase<T>
{
protected:
    mutable size_t* mRefCountPtr;

    inline static void incRefCount(NewSmartPointer& rhs)
    {
        assert(rhs.mRefCountPtr);
        ++(*rhs.mRefCountPtr);
    }

    inline static void decRefCount(NewSmartPointer& rhs)
    {
        assert(rhs.mRefCountPtr);
        if(--(*rhs.mRefCountPtr) == 0)
        {
            LDK::destroy(rhs.mRefCountPtr);
            rhs.mRefCountPtr = NULL;
            if(rhs.mPtr)
            {
                delete rhs.mPtr;
                rhs.mPtr = NULL;
            }
        }
    }

public:

    typedef typename SmartPointerBase<T>::PointerType PointerType;

    inline static size_t refCount(const NewSmartPointer& s) { return *s.mRefCountPtr; }

    inline NewSmartPointer(PointerType p=NULL)
    {
        mRefCountPtr = LDK_CREATE1(size_t,1);
        SmartPointerBase<T>::mPtr = p;
    }

    inline NewSmartPointer(const NewSmartPointer& rhs)
     : SmartPointerBase<T>(rhs.mPtr)
     , mRefCountPtr(rhs.mRefCountPtr)
    {
        incRefCount(*this);
    }

    inline ~NewSmartPointer()
    {
        decRefCount(*this);
    }

    inline NewSmartPointer& operator=(const NewSmartPointer& rhs)
    {
        decRefCount(*this);
        mRefCountPtr = rhs.mRefCountPtr;
        SmartPointerBase<T>::mPtr = rhs.mPtr;
        incRefCount(*this);
        return *this;
    }
};

template <class T>
class RawSmartPointer  : public SmartPointerBase<T>
{
protected:
    mutable size_t* mRefCountPtr;

    inline static void incRefCount(RawSmartPointer& rhs)
    {
        assert(rhs.mRefCountPtr);
        ++(*rhs.mRefCountPtr);
    }

    inline static void decRefCount(RawSmartPointer& rhs)
    {
        assert(rhs.mRefCountPtr);
        if(--(*rhs.mRefCountPtr) == 0)
        {
            LDK::destroy(rhs.mRefCountPtr);
            rhs.mRefCountPtr = NULL;
            LDK::dealloc(rhs.mPtr);
            rhs.mPtr = NULL;
        }
    }

public:

    typedef typename SmartPointerBase<T>::PointerType PointerType;

    inline static size_t refCount(const RawSmartPointer& s) { return *s.mRefCountPtr; }

    inline RawSmartPointer(PointerType p=NULL)
    {
        mRefCountPtr = LDK_CREATE1(size_t,1);
        SmartPointerBase<T>::mPtr = p;
    }

    inline RawSmartPointer(const RawSmartPointer& rhs)
     : SmartPointerBase<T>(rhs.mPtr)
     , mRefCountPtr(rhs.mRefCountPtr)
    {
        incRefCount(*this);
    }

    inline ~RawSmartPointer()
    {
        decRefCount(*this);
    }

    inline RawSmartPointer& operator=(const RawSmartPointer& rhs)
    {
        decRefCount(*this);
        mRefCountPtr = rhs.mRefCountPtr;
        SmartPointerBase<T>::mPtr = rhs.mPtr;
        incRefCount(*this);
        return *this;
    }
};


}// namespace LDK


#endif //__LDK_SMARTPOINTERS_HH__

---