resource_ptr.h

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

#ifndef LEAN_SMART_RESOURCE_PTR
#define LEAN_SMART_RESOURCE_PTR

#include "../cpp0x.h"
#include "../functional/variadic.h"

namespace lean
{
namespace smart
{

// Prototypes
template <class Counter, class Allocator>
class ref_counter;

template <class Resource>
LEAN_INLINE void destroy_resource(Resource *resource)
{
    delete resource;
}

template <class Resource, bool Critical = false>
class resource_ptr
{
    template <class Resource>
    friend class weak_resource_ptr;

private:
    Resource *m_resource;

    template <class Counter, class Allocator>
    static Resource* acquire(Resource *resource, const ref_counter<Counter, Allocator>& refCounter)
    {
        return (resource && refCounter.increment_checked())
            ? resource
            : nullptr;
    }

    static Resource* acquire(Resource *resource)
    {
        if (resource)
            resource->ref_counter().increment();

        return resource;
    }

    static void release(Resource *resource)
    {
        // Clean up, if this is the last reference
        if (resource && !resource->ref_counter().decrement())
            destroy_resource(resource);
    }

protected:
    template <class Counter, class Allocator>
    resource_ptr(Resource *resource, const ref_counter<Counter, Allocator>& refCounter)
        : m_resource( acquire(resource, refCounter) ) { };

public:
    typedef Resource resource_type;
    typedef Resource* value_type;

    resource_ptr(resource_type *resource = nullptr)
        : m_resource( acquire(resource) ) { };
    template <class Resource2>
    resource_ptr(Resource2 *resource)
        : m_resource( acquire(resource) ) { };

    enum bind_reference_t
    {
        bind_reference 
    };
    resource_ptr(Resource *resource, bind_reference_t)
        : m_resource(resource) { };

    resource_ptr(const resource_ptr &right)
        : m_resource( acquire(right.m_resource) ) { };
    template <class Resource2, bool Critical2>
    resource_ptr(const resource_ptr<Resource2, Critical2> &right)
        : m_resource( acquire(right.get()) ) { };

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Resource2, bool Critical2>
    resource_ptr(resource_ptr<Resource2, Critical2> &&right)
        : m_resource(right.unbind()) { }
#endif

    ~resource_ptr() throw()
    {
        release(m_resource);
    }

    static LEAN_INLINE resource_ptr<resource_type, true> bind(resource_type *resource)
    {
        return resource_ptr<resource_type, true>(resource, resource_ptr<resource_type, true>::bind_reference);
    }
    resource_type* unbind()
    {
        Resource *prevResource = m_resource;
        m_resource = nullptr;
        return prevResource;
    }
    resource_ptr<resource_type, true> transfer()
    {
        // Visual C++ won't inline delegating function calls
        return resource_ptr<resource_type, true>(unbind(), resource_ptr<resource_type, true>::bind_reference);
    }

    resource_ptr& operator =(resource_type *resource)
    {
        if (m_resource != resource)
        {
            Resource *prevResource = m_resource;
            m_resource = acquire(resource);
            release(prevResource);
        }

        return *this;
    }

    resource_ptr& operator =(const resource_ptr &right)
    {
        return (*this = right.m_resource);
    }
    template <class Resource2, bool Critical2>
    resource_ptr& operator =(const resource_ptr<Resource2, Critical2> &right)
    {
        return (*this = right.get());
    }

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Resource2, bool Critical2>
    resource_ptr& operator =(resource_ptr<Resource2, Critical2> &&right)
    {
        // Self-assignment would be wrong
        if (addressof(right) != static_cast<void*>(this))
        {
            Resource *prevResource = m_resource;
            m_resource = right.unbind();
            release(prevResource);
        }

        return *this;
    }
#endif

    LEAN_INLINE resource_type *const & get(void) const { return m_resource; };

    LEAN_INLINE resource_type& operator *() const { return *get(); };
    LEAN_INLINE resource_type* operator ->() const { return get(); };

    LEAN_INLINE operator resource_type*() const
    {
        LEAN_STATIC_ASSERT_MSG_ALT(!Critical,
            "Cannot implicitly cast critical reference, use unbind() for (insecure) storage.",
            Cannot_implicitly_cast_critical_reference__use_unbind_for_insecure_storage);
        return get();
    }
};

template <class Resource>
LEAN_INLINE resource_ptr<Resource, true> bind_resource(Resource *resource)
{
    // Visual C++ won't inline delegating function calls
    return resource_ptr<Resource, true>(resource, resource_ptr<Resource, true>::bind_reference);
}

template <class Resource>
LEAN_INLINE resource_ptr<Resource, true> secure_resource(Resource *resource)
{
    // Visual C++ won't inline delegating function calls
    return resource_ptr<Resource, true>(resource);
}

#ifdef DOXYGEN_READ_THIS

    template <class Resource>
    resource_ptr<Resource, true> new_resource(...);
#else
    #define LEAN_NEW_RESOURCE_FUNCTION_TPARAMS class Resource
    #define LEAN_NEW_RESOURCE_FUNCTION_DECL inline resource_ptr<Resource, true> new_resource
    #define LEAN_NEW_RESOURCE_FUNCTION_BODY(call) { return resource_ptr<Resource, true>( new Resource##call, resource_ptr<Resource, true>::bind_reference ); }
    LEAN_VARIADIC_PERFECT_FORWARDING_T(LEAN_NEW_RESOURCE_FUNCTION_DECL, LEAN_NEW_RESOURCE_FUNCTION_TPARAMS, LEAN_NOTHING, LEAN_NEW_RESOURCE_FUNCTION_BODY)
#endif

} // namespace

using smart::resource_ptr;
using smart::bind_resource;
using smart::secure_resource;
using smart::new_resource;

} // namespace

#endif