RefCountPtr.h

Go to the documentation of this file.

#ifndef REFCOUNTPTR_H_
#define REFCOUNTPTR_H_

#include "SttclMutex.h"
#include <stdlib.h>

namespace sttcl
{

namespace internal
{
template<class MutexType>
class RefCountPtrBase
{
public:
        typedef void (*ReleaseFunc)(void* ptr);

        ~RefCountPtrBase()
        {
                decrementRefCount();
        }


protected:

        struct PtrRef
        {
                void* pointee;
                int refcount;
                MutexType refcountMutex;
                ReleaseFunc releaseFunc;

                PtrRef(void* argPointee, ReleaseFunc argReleaseFunc)
                : pointee(argPointee)
                , refcount(0)
                , refcountMutex()
                , releaseFunc(argReleaseFunc)
                {
                }

                ~PtrRef()
                {
                }
        };

        RefCountPtrBase()
        : ptrRef(0)
        {
        }

        RefCountPtrBase(void* argPointee, ReleaseFunc argReleaseFunc)
        : ptrRef(0)
        {
                if(argPointee)
                {
                        ptrRef = new PtrRef(argPointee,argReleaseFunc);
                        incrementRefCount();
                }
        }

        RefCountPtrBase(const RefCountPtrBase& rhs)
        : ptrRef(rhs.ptrRef)
        {
                incrementRefCount();
        }

        RefCountPtrBase& operator=(const RefCountPtrBase<MutexType>& rhs)
        {
                if(ptrRef && ptrRef != rhs.ptrRef)
                {
                        decrementRefCount();
                }
                ptrRef = rhs.ptrRef;
                incrementRefCount();
                return *this;
        }

        void incrementRefCount();
        void decrementRefCount();

        mutable PtrRef* ptrRef;
};

template
< class MutexType
>
void RefCountPtrBase<MutexType>::incrementRefCount()
{
        if(ptrRef)
        {
                sttcl::internal::AutoLocker<MutexType> lock(ptrRef->refcountMutex);
                ++(ptrRef->refcount);
        }
}

template
< class MutexType
>
void RefCountPtrBase<MutexType>::decrementRefCount()
{
        if(ptrRef)
        {
                bool destroy = false;
                { sttcl::internal::AutoLocker<MutexType> lock(ptrRef->refcountMutex);
                        --(ptrRef->refcount);
                        if(ptrRef->refcount <= 0)
                        {
                                if(ptrRef->releaseFunc)
                                {
                                        (*ptrRef->releaseFunc)(ptrRef->pointee);
                                        ptrRef->pointee = 0;
                                }
                                destroy = true;
                        }
                }
                if(destroy)
                {
                        delete ptrRef;
                        ptrRef = 0;
                }
        }
}
}

template
< typename T
, class MutexType = internal::SttclMutex<STTCL_DEFAULT_MUTEXIMPL>
>
class RefCountPtr
: public sttcl::internal::RefCountPtrBase<MutexType>
{
public:

        RefCountPtr()
        : sttcl::internal::RefCountPtrBase<MutexType>()
        {
        }

        RefCountPtr(T* argPointee, typename sttcl::internal::RefCountPtrBase<MutexType>::ReleaseFunc argReleaseFunc = RefCountPtr<T,MutexType>::release)
        : sttcl::internal::RefCountPtrBase<MutexType>(argPointee,argReleaseFunc)
        {
        }

        template<typename U>
        RefCountPtr(U* argPointee, typename sttcl::internal::RefCountPtrBase<MutexType>::ReleaseFunc argReleaseFunc = RefCountPtr<T,MutexType>::release)
        : sttcl::internal::RefCountPtrBase<MutexType>(static_cast<T*>(argPointee),argReleaseFunc)
        {
        }

        RefCountPtr(const RefCountPtr<T,MutexType>& rhs)
        : sttcl::internal::RefCountPtrBase<MutexType>(rhs)
        {
        }

        template<typename U>
        RefCountPtr(const RefCountPtr<U,MutexType>& rhs)
        : sttcl::internal::RefCountPtrBase<MutexType>(rhs)
        {
                T* dummy = static_cast<T*>(rhs.get());
                (void)dummy;
        }

        ~RefCountPtr()
        {
        }

        RefCountPtr& operator=(const RefCountPtr<T,MutexType>& rhs)
        {
                sttcl::internal::RefCountPtrBase<MutexType>::operator=(rhs);
                return *this;
        }

        template<typename U>
        RefCountPtr& operator=(const RefCountPtr<U,MutexType>& rhs)
        {
                T* dummy = static_cast<T*>(rhs.get());
                (void)dummy;
                sttcl::internal::RefCountPtrBase<MutexType>::operator=(rhs);
                return *this;
        }

        T* get() const
        {
                if(sttcl::internal::RefCountPtrBase<MutexType>::ptrRef)
                {
                        return (T*)(sttcl::internal::RefCountPtrBase<MutexType>::ptrRef->pointee);
                }
                return 0;
        }

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

        T* operator->()
        {
                if(sttcl::internal::RefCountPtrBase<MutexType>::ptrRef)
                {
                        return reinterpret_cast<T*>(sttcl::internal::RefCountPtrBase<MutexType>::ptrRef->pointee);
                }
                return 0;
        }

        T& operator*()
        {
                static T dummy;
                if(sttcl::internal::RefCountPtrBase<MutexType>::ptrRef)
                {
                        return *(reinterpret_cast<T*>(sttcl::internal::RefCountPtrBase<MutexType>::ptrRef->pointee));
                }
                return dummy;
        }

private:
        static void release(void* ptr);
};

template
< typename T
, class MutexType
>
void RefCountPtr<T,MutexType>::release(void* ptr)
{
        delete reinterpret_cast<T*>(ptr);
}

template<class MutexType>
class RefCountPtr<void,MutexType>
{
        static void release(void* ptr)
        {
//              free(ptr);
        }
};

} /* namespace sttcl */
#endif /* REFCOUNTPTR_H_ */