sharedptr.h

Go to the documentation of this file.

/*
**  ClanLib SDK
**  Copyright (c) 1997-2005 The ClanLib Team
**
**  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.
**
**  Note: Some of the libraries ClanLib link to may have additional
**  requirements or restrictions.
**
**  File Author(s):
**
**    Magnus Norddahl
*/


#ifndef header_sharedptr
#define header_sharedptr

#include "mutex.h"

class CL_UnknownSharedPtr_Generic
{
public:
        CL_UnknownSharedPtr_Generic() : ref_count(1), mutex(0) { return; }

        virtual ~CL_UnknownSharedPtr_Generic() { return; }

public:
        //: reference count:
        unsigned int ref_count;

        //: Pointer to mutex object, if thread safe.
        CL_Mutex *mutex;
};

class CL_UnknownSharedPtr;

template <typename TEvil>
class CL_SharedPtr_Generic : public CL_UnknownSharedPtr_Generic
{
public:
        CL_SharedPtr_Generic() : ptr(0) { return; }

public:
        //: Pointer to new-allocated data:
        TEvil *ptr;
};

template <typename T, typename TEvil>
class CL_SharedPtr_Deleter : public CL_SharedPtr_Generic<T>
{
public:
        CL_SharedPtr_Deleter(TEvil *e, CL_Mutex *mutex = 0) { this->ptr = e; this->mutex = mutex; }

        ~CL_SharedPtr_Deleter() { delete this->ptr; }
};

//: Shared pointer class (automatically deletes data when all CL_SharedPtrs to data are gone).
//- !group=Core/System!
//- !header=core.h!
//- <p> Use CL_SharedPtr when you have data that's intended to be shared between
//- multiple users without each user needing an individual copy. </p>
//- <p> Note that CL_SharedPtr uses a very simple reference counting system, so is susecptible
//- to circular loop issues. </p>
//- <p> If a mutex object is attached to the CL_SharedPtr, it will guard its reference count
//- with a mutex, making it threadsafe.</p>
template <typename T, typename U = T>
class CL_SharedPtr
{
public:
        //: Constructs a CL_SharedPtr.
        //param impl: A pointer which was the return value of a 'new' call.
        //- <p> After the CL_SharedPtr has been constructed based on a passed pointer,
        //- the CL_SharedPtr takes full control over that data. The original pointer shouldn't
        //- be used to access or delete the data anymore; instead, use the CL_SharedPtr. </p>
        CL_SharedPtr() : impl(0) { return; }

        CL_SharedPtr(const CL_SharedPtr<T, U>& other) : impl(other.impl) { increment(); }

        CL_SharedPtr(const CL_UnknownSharedPtr& other) : impl(0)
        {
                if (other.impl)
                {
                        impl = dynamic_cast<CL_SharedPtr_Generic<T>*>(other.impl)
                        increment();
                }
        }

        template <typename D>
        explicit CL_SharedPtr(D* ptr, CL_Mutex *mutex = 0) : impl(0)
        {
                if (ptr)
                        impl = new CL_SharedPtr_Deleter<T, D>(ptr, mutex);
        }

        explicit CL_SharedPtr(CL_SharedPtr_Generic<T> *impl) : impl(impl) { increment(); }
        
        ~CL_SharedPtr() { decrement(); }
        
public:
        //: Returns true if this CL_SharedPtr is not dereferencable.
        bool is_null() const { return impl ? (impl->ptr == 0) : true; }

        //: Returns number of references (including this one) to the data cache.
        //- <p> Returns 0 if this pointer is null. </p>
        int get_ref_count() const { if (impl == 0) return 0; return impl->ref_count; }
        
        //: Gives access to the pointer itself.
        //- <p> Be careful not to keep the returned pointer around after doing any
        //- non-const operations on the CL_LazyCopyPtr; it could be invalid
        //- after that.</p>
        U* get() { return (U*) ((impl != 0) ? impl->ptr : 0); }

        const U* get() const { return (const U*) ((impl != 0) ? impl->ptr : 0); }

        //: Returns the pointer.
        operator U*() { return get(); }

        //: Returns the pointer.
        operator const U*() const { return get(); }

        //: Pointer equality check operator.
        //- <p> This will return true if the CL_SharedPtrs point to the same data. It doesn't
        //- check the data itself for equality. </p>
        bool operator==(const T* other) const { return other == ((impl != 0) ? impl->ptr : 0); }

        bool operator==(const CL_SharedPtr<T, U>& other) const { return other.impl == impl; }

public:
        //: Copy assignment operator.
        CL_SharedPtr<T, U>& operator=(const CL_SharedPtr<T, U>& other)
        {
                if (other.impl != impl)
                {
                        decrement();
                        impl = other.impl;
                        increment();
                }
                return *this;
        }

        CL_SharedPtr<T, U>& operator=(const CL_UnknownSharedPtr& other)
        {
                if (other.impl != impl)
                {
                        decrement();
                        if (other.impl)
                        {
                                impl = dynamic_cast<CL_SharedPtr_Generic<T>*>(other.impl)
                                increment();
                        }
                }
                return *this;
        }

        //: Dereferencing operator.
        U& operator*() { return *((U*) impl->ptr); }

        U const& operator*() const { return *((const U*) impl->ptr); }
        
        //: Indirect member access operator.
        U* operator->() { return (U*) impl->ptr; }

        U const* operator->() const { return (const U*) impl->ptr; }

        CL_SharedPtr_Generic<T> *get_impl() { return impl; }

private:
        // Shared data:
        CL_SharedPtr_Generic<T> *impl;
        
        //: Increases the ref count
        void increment()
        {
                if (impl != 0)
                {
                        CL_MutexSection lock(impl->mutex);
                        ++impl->ref_count;
                }
        }
        
        //: Decreases the ref count, deletes entry and sets ptr to 0 if ptr_ref_count reaches zero
        void decrement()
        {
                if (impl != 0)
                {
                        CL_MutexSection lock(impl->mutex);
                        if (--impl->ref_count == 0)
                        {
                                lock.unlock();
                                delete impl;
                                impl = 0;
                        }
                }
        }

        friend class CL_UnknownSharedPtr;
};

//: Unknown shared pointer class.
//- <p>This class allows different types of shared pointers to be dynamically cast to each other.</p>
//- !group=Core/System!
//- !header=core.h!
class CL_UnknownSharedPtr
{
public:
        CL_UnknownSharedPtr() : impl(0) { return; }

        template <typename T, typename U>
        explicit CL_UnknownSharedPtr(const CL_SharedPtr<T, U>& other) : impl(other.impl) { increment(); }

        ~CL_UnknownSharedPtr() { decrement(); }

public:
        //: Returns true if this shared pointer is not dereferencable.
        bool is_null() const { return impl ? false : true; }

        //: Returns number of references (including this one) to the data cache.
        //- <p> Returns 0 if this pointer is null. </p>
        int get_ref_count() const { if (impl == 0) return 0; return impl->ref_count; }

        //: Pointer equality check operator.
        bool operator==(const CL_UnknownSharedPtr& other) const { return other.impl == impl; }

        template <typename T, typename U>
        bool operator==(const CL_SharedPtr<T, U>& other) const { return other.impl == impl; }

public:
        //: Copy assignment operator.
        template <typename T, typename U>
        CL_UnknownSharedPtr& operator=(const CL_SharedPtr<T, U>& other)
        {
                if (other.impl != impl)
                {
                        decrement();
                        impl = other.impl;
                        increment();
                }
                return *this;
        }

private:
        // Shared data:
        CL_UnknownSharedPtr_Generic *impl;
        
        //: Increases the ref count
        void increment()
        {
                if (impl != 0)
                {
                        CL_MutexSection lock(impl->mutex);
                        ++impl->ref_count;
                }
        }
        
        //: Decreases the ref count, deletes entry and sets ptr to 0 if ptr_ref_count reaches zero
        void decrement()
        {
                if (impl != 0)
                {
                        CL_MutexSection lock(impl->mutex);
                        if (--impl->ref_count == 0)
                        {
                                lock.unlock();
                                delete impl;
                                impl = 0;
                        }
                }
        }
};

#endif

---