RefCounted.h

/************************************************************************
    filename:   CEGUIRefCounted.h
    created:    Wed Mar 1 2006
    author:     Paul D Turner <paul@cegui.org.uk>
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIRefCounted_h_
#define _CEGUIRefCounted_h_

// Start of CEGUI namespace section
namespace CEGUI
{
template<typename T>
class RefCounted
{
public:
    RefCounted() :
        d_object(0),
        d_count(0)
    {
    }

    RefCounted(T* ob) :
        d_object(ob),
        // use system heap for this! no CEGUI_NEW_PT!
        d_count((ob != 0) ? new unsigned int(1) : 0)
    {
    }

    RefCounted(const RefCounted<T>& other) :
        d_object(other.d_object),
        d_count(other.d_count)
    {
        if (d_count)
            addRef();
    }

    ~RefCounted()
    {
        if (d_object)
            release();
    }

    RefCounted<T>& operator=(const RefCounted<T>& other)
    {
        if (*this != other)
        {
            if (d_object)
                release();

            d_object = other.d_object;
            d_count = d_object ? other.d_count : 0;

            if (d_count)
                addRef();
        }

        return *this;
    }

    bool operator==(const RefCounted<T>& other) const
    {
        return d_object == other.d_object;
    }

    bool operator!=(const RefCounted<T>& other) const
    {
        return d_object != other.d_object;
    }

    const T& operator*() const
    {
        return *d_object;
    }

    T& operator*()
    {
        return *d_object;
    }

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

    T* operator->()
    {
        return d_object;
    }

    bool isValid() const
    {
        return d_object != 0;
    }

private:
    void addRef()
    {
        ++*d_count;
    }

    void release()
    {
        if (!--*d_count)
        {
            // use CEGUI allocators for the object
            CEGUI_DELETE_AO d_object;

            // use system heap for this! no CEGUI_DELETE_PT!
            delete d_count;
            d_object = 0;
            d_count = 0;
        }
    }

    T* d_object;            
    unsigned int* d_count;  
};

} // End of  CEGUI namespace section

#endif  // end of guard _CEGUIRefCounted_h_