weak_resource_ptr.h

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

#ifndef LEAN_SMART_WEAK_RESOURCE_PTR
#define LEAN_SMART_WEAK_RESOURCE_PTR

#include "../cpp0x.h"
#include "ref_counter.h"
#include "resource_ptr.h"

namespace lean
{
namespace smart
{

template <class Resource>
class weak_resource_ptr
{
private:
    Resource *m_resource;

    typedef typename Resource::ref_counter_type ref_counter_type;
    ref_counter_type m_refCounter;

public:
    typedef Resource resource_type;
    typedef Resource* value_type;

    weak_resource_ptr(resource_type *resource = nullptr)
        : m_resource(resource),
        m_refCounter( (resource) ? resource->ref_counter() : ref_counter_type::null() ) { };
    template <class Resource2>
    weak_resource_ptr(Resource2 *resource)
        : m_resource(resource),
        m_refCounter( (m_resource) ? m_resource->ref_counter() : ref_counter_type::null() ) { };
    
    weak_resource_ptr(const weak_resource_ptr &right)
        : m_resource(right.m_resource),
        m_refCounter(right.m_refCounter) { };
    template <class Resource2>
    weak_resource_ptr(const weak_resource_ptr<Resource2> &right)
        : m_resource(right.m_resource),
        m_refCounter(right.m_refCounter) { };

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Resource2>
    weak_resource_ptr(weak_resource_ptr<Resource2> &&right)
        : m_resource(right.m_resource),
        m_refCounter(::std::move(right.m_refCounter))
    {
        right.m_resource = nullptr;
    }
#endif

    weak_resource_ptr& operator =(resource_type *resource)
    {
        if (m_resource != resource)
        {
            m_resource = resource;
            m_refCounter = (resource) ? resource->ref_counter() : ref_counter_type::null();
        }

        return *this;
    }
    
    weak_resource_ptr& operator =(const weak_resource_ptr &right)
    {
        if (m_resource != right.m_resource)
        {
            m_resource = right.m_resource;
            m_refCounter = right.m_refCounter;
        }

        return *this;
    }
    template <class Resource2>
    weak_resource_ptr& operator =(const weak_resource_ptr<Resource2> &right)
    {
        if (m_resource != right.m_resource)
        {
            m_resource = right.m_resource;
            m_refCounter = right.m_refCounter;
        }

        return *this;
    }

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Resource2>
    weak_resource_ptr& operator =(weak_resource_ptr<Resource2> &&right)
    {
        if (m_resource != right.m_resource)
        {
            m_resource = right.m_resource;
            right.m_resource = nullptr;

            m_refCounter = ::std::move(right.m_refCounter);
        }

        return *this;
    }
#endif

    LEAN_INLINE bool check() const
    {
        return (m_resource && m_refCounter.valid());
    }
    LEAN_INLINE resource_type* get(void) const
    {
        return (check()) ? m_resource : nullptr;
    }
    LEAN_INLINE resource_ptr<resource_type> lock() const
    {
        return resource_ptr<resource_type>(m_resource, m_refCounter);
    }
    LEAN_INLINE resource_type* get_unchecked(void) const { return m_resource; };

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

    LEAN_INLINE operator resource_type*() const { return get_unchecked(); };
    // WARNING: Meaning unclear, should enforce explicit method calls
    // However, this would require overloads for pointer comparison, ordering etc.

    LEAN_INLINE operator resource_ptr<resource_type>() const { return lock(); };
};

} // namespace

using smart::weak_resource_ptr;

} // namespace

#endif