resource.h

/*****************************************************/
/* lean Smart                   (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_SMART_RESOURCE
#define LEAN_SMART_RESOURCE

#include "ref_counter.h"


#define LEAN_MAKE_RESOURCE \
    template <class Resource, bool Critical> \
    friend class lean::smart::resource_ptr; \
    template <class Resource> \
    friend class lean::smart::weak_resource_ptr;

#define LEAN_RENEW_RESOURCE LEAN_MAKE_RESOURCE \
    protected: \
        const lean_resource_base::ref_counter_type& ref_counter() const { return lean_resource_base::ref_counter(); } \
    public: \
        lean_resource_base::ref_counter_type::counter_type ref_count() const { return lean_resource_base::ref_count(); }


namespace lean
{
namespace smart
{

// Prototypes
template <class Resource, bool Critical>
class resource_ptr;
template <class Resource>
class weak_resource_ptr;

template < class Counter = long, class Allocator = std::allocator<Counter>, bool Lazy = false >
class resource
{
    LEAN_MAKE_RESOURCE

protected:
    typedef resource lean_resource_base;

    typedef ref_counter<Counter, Allocator> ref_counter_type;
    mutable ref_counter_type m_refCounter;

private:
    LEAN_NOINLINE void create_ref_counter() const
    {
        LEAN_ASSERT(m_refCounter.is_null());
        m_refCounter = ref_counter_type();
    }

protected:
    resource()
        : m_refCounter( Lazy ? ref_counter_type::null() : ref_counter_type() ) { }
    resource(const typename ref_counter_type::allocator_type& allocator)
        : m_refCounter(allocator) { }
    LEAN_INLINE resource(const resource& right) { }
    LEAN_INLINE resource& operator =(const resource& right) { return *this; }
#ifndef LEAN_OPTIMIZE_DEFAULT_DESTRUCTOR

    LEAN_INLINE ~resource() throw() { }
#endif

    const ref_counter_type& ref_counter() const
    {
        if (Lazy)
        {
            if (m_refCounter.is_null())
                create_ref_counter();
        }
        return m_refCounter;
    }

public:
    typename ref_counter_type::counter_type ref_count() const { return m_refCounter.count(); }
};

template < class Counter = long, class Allocator = std::allocator<Counter> >
class resource_interface
{
    LEAN_MAKE_RESOURCE

protected:
    LEAN_INLINE resource_interface& operator =(const resource_interface& right) { return *this; }

    typedef ref_counter<Counter, Allocator> ref_counter_type;
    virtual const ref_counter_type& ref_counter() const = 0;

public:
    virtual ~resource_interface() throw() { }

    virtual typename ref_counter_type::counter_type ref_count() const = 0;
};

} // namespace

using smart::resource;
using smart::resource_interface;

} // namespace

#endif