scoped_ptr.h

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

#ifndef LEAN_SMART_SCOPED_PTR
#define LEAN_SMART_SCOPED_PTR

#include "../lean.h"
#include "../tags/noncopyable.h"
#include "../meta/dependent_false.h"
#include "../meta/strip.h"

namespace lean
{
namespace smart
{

template <class Type>
LEAN_INLINE void release_ptr(Type *object)
{
    if (sizeof(Type) > 0)
        delete object;
}

template <class Type>
LEAN_INLINE void release_array_ptr(Type *object)
{
    if (sizeof(Type) > 0)
        delete[] object;
}

template <class Type>
struct generic_ptr_policy
{
    static LEAN_INLINE void release(Type *object)
    {
        release_ptr(object);
    }
};
template <class Type>
struct generic_ptr_policy<Type[]>
{
    static LEAN_INLINE void release(Type *object)
    {
        release_array_ptr(object);
    }
};

template <class Type>
struct delete_ptr_policy
{
    static LEAN_INLINE void release(Type *object)
    {
        if (sizeof(Type) > 0)
            delete object;
    }
};
template <class Type>
struct delete_ptr_policy<Type[]>
{
    static LEAN_INLINE void release(Type *object)
    {
        if (sizeof(Type) > 0)
            delete[] object;
    }
};

template <class Type>
struct destroy_ptr_policy
{
    static LEAN_INLINE void release(Type *object)
    {
        if (object)
            object->destroy();
    }
};
template <class Type>
struct destroy_ptr_policy<Type[]>;

template <class Type>
struct release_ptr_policy
{
    static LEAN_INLINE void release(Type *object)
    {
        if (object)
            object->release();
    }
};
template <class Type>
struct release_ptr_policy<Type[]>;

template < class Type, class ReleasePolicy = generic_ptr_policy<Type> >
class scoped_ptr : public noncopyable
{
public:
    typedef typename lean::strip_array<Type>::type object_type;
    typedef object_type* value_type;

private:
    value_type m_object;

public:
    explicit scoped_ptr(object_type *object = nullptr)
        : m_object( object ) { };
    template <class Type2>
    explicit scoped_ptr(Type2 *object)
        : m_object( object ) { };

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Type2>
    scoped_ptr(scoped_ptr<Type2> &&right)
        : m_object( right.detatch() ) { }
#endif
    
    LEAN_INLINE ~scoped_ptr()
    {
        ReleasePolicy::release(m_object);
    }

    LEAN_INLINE object_type* detatch()
    {
        value_type prevObject = m_object;
        m_object = nullptr;
        return prevObject;
    }

    scoped_ptr& operator =(object_type *object)
    {
        // Self-assignment would be wrong
        if(object != m_object)
        {
            value_type prevObject = m_object;
            m_object = object;
            ReleasePolicy::release(prevObject);
        }
        
        return *this;
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class Type2>
    scoped_ptr& operator =(scoped_ptr<Type2> &&right)
    {
        // Self-assignment would be wrong
        if (addressof(right) != static_cast<void*>(this))
        {
            value_type prevObject = m_object;
            m_object = right.detatch();
            ReleasePolicy::release(prevObject);
        }

        return *this;
    }
#endif

    LEAN_INLINE object_type*const& get() const { return m_object; }

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

    LEAN_INLINE operator object_type*() const { return get(); }
};

} // namespace

using smart::scoped_ptr;

} // namespace

#endif