cloneable_obj.h

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

#ifndef LEAN_SMART_CLONEABLE_OBJ
#define LEAN_SMART_CLONEABLE_OBJ

#include "../cpp0x.h"
#include "../meta/conditional.h"

namespace lean
{
namespace smart
{

template <class Cloneable>
LEAN_INLINE Cloneable* clone_cloneable(const Cloneable &cloneable)
{
    return static_cast<Cloneable*>( cloneable.clone() );
}
template <class Cloneable>
LEAN_INLINE void destroy_cloneable(Cloneable *cloneable)
{
    if (cloneable)
        cloneable->destroy();
}

template <class Cloneable, bool PointerSemantics = false>
class cloneable_obj
{
private:
    Cloneable *m_cloneable;

    static Cloneable* acquire(const Cloneable &cloneable)
    {
        return static_cast<Cloneable*>( clone_cloneable(cloneable) );
    }

    static Cloneable* acquire(const Cloneable *cloneable)
    {
        return (cloneable)
            ? acquire(*cloneable)
            : nullptr;
    }

    static void release(const Cloneable *cloneable)
    {
        destroy_cloneable(cloneable);
    }

public:
    typedef Cloneable value_type;
    typedef typename conditional_type<PointerSemantics, value_type, const value_type>::type maybe_const_value_type;

    cloneable_obj(const value_type &cloneable)
        : m_cloneable( acquire(cloneable) ) { };
    cloneable_obj(const cloneable_obj &right)
        : m_cloneable( acquire(right.m_cloneable) ) { };
    cloneable_obj(const value_type *cloneable)
        : m_cloneable( acquire(cloneable) )
    {
        LEAN_STATIC_ASSERT_MSG_ALT(PointerSemantics,
            "Construction from pointer only available for pointer semantics.",
            Construction_from_pointer_only_available_for_pointer_semantics);
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    cloneable_obj(cloneable_obj &&right)
        : m_cloneable(std::move(right.m_cloneable))
    {
        // Warning: this "breaks" the other object
        right.m_cloneable = nullptr;
    }
#endif

    ~cloneable_obj() throw()
    {
        release(m_cloneable);
    }

    static LEAN_INLINE cloneable_obj null()
    {
        LEAN_STATIC_ASSERT_MSG_ALT(PointerSemantics,
            "Null objects only available for pointer semantics.",
            Null_objects_only_available_for_pointer_semantics);

        // Warning: this object is effectively "broken"
        return cloneable_obj(nullptr);
    }

    cloneable_obj& operator =(const value_type &cloneable)
    {
        Cloneable *prevCloneable = m_cloneable;
        m_cloneable = acquire(cloneable);
        release(prevCloneable);
        
        return *this;
    }
    cloneable_obj& operator =(const value_type *cloneable)
    {
        LEAN_STATIC_ASSERT_MSG_ALT(PointerSemantics,
            "Pointer assignment only available for pointer semantics.",
            Pointer_assignment_only_available_for_pointer_semantics);

        Cloneable *prevCloneable = m_cloneable;
        m_cloneable = acquire(cloneable);
        release(prevCloneable);
        
        return *this;
    }
    cloneable_obj& operator =(const cloneable_obj &right)
    {
        if (m_cloneable != right.m_cloneable)
        {
            Cloneable *prevCloneable = m_cloneable;
            m_cloneable = acquire(right.m_cloneable);
            release(prevCloneable);
        }
        
        return *this;
    }
#ifndef LEAN0X_NO_RVALUE_REFERENCES

    cloneable_obj& operator =(cloneable_obj &&right)
    {
        if (m_cloneable != right.m_cloneable)
        {
            Cloneable *prevCloneable = m_cloneable;
            
            m_cloneable = std::move(right.m_cloneable);
            // Warning: this "breaks" the other object
            right.m_cloneable = nullptr;

            release(prevCloneable);
        }
        return *this;
    }
#endif

    value_type& get(void) { LEAN_ASSERT(m_cloneable); return *m_cloneable; };
    maybe_const_value_type& get(void) const { LEAN_ASSERT(m_cloneable); return *m_cloneable; };
    value_type* getptr(void) { return m_cloneable; };
    maybe_const_value_type* getptr(void) const { return m_cloneable; };
    bool valid() const { return (m_cloneable != nullptr); };

    value_type& operator *() { return get(); };
    maybe_const_value_type& operator *() const { return get(); };
    value_type* operator ->() { LEAN_ASSERT(m_cloneable); return m_cloneable; };
    maybe_const_value_type* operator ->() const { LEAN_ASSERT(m_cloneable); return m_cloneable; };

    operator value_type&() { return get(); };
    operator maybe_const_value_type&() const { return get(); };
};

} // namespace

using smart::cloneable_obj;

} // namespace

#endif