pimpl_ptr.h

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

#ifndef LEAN_PIMPL_PIMPL_PTR
#define LEAN_PIMPL_PIMPL_PTR

#include "../tags/noncopyable.h"

namespace lean
{
namespace pimpl
{

struct pimpl_delete_policy
{
    template <class Implementation>
    static void destroy(Implementation *impl)
    {
        if (sizeof(Implementation) > 0)
            delete impl;
    }
};

template <class Implementation, class ImplementationBase = Implementation, class DestroyPolicy = pimpl_delete_policy>
class pimpl_ptr : public noncopyable
{
private:
    ImplementationBase *m_impl;

    static LEAN_INLINE void delete_impl(const ImplementationBase *impl)
    {
        // Check, if implementation class fully defined
        delete_full_impl( impl, static_cast<const Implementation*>(nullptr) );
    }
    static LEAN_INLINE void delete_full_impl(const ImplementationBase *base, const ImplementationBase*)
    {
        // Overload resolution suggests that implementation class is fully defined
        DestroyPolicy::destroy( static_cast<const Implementation*>(base) );
    }
    static LEAN_INLINE void delete_full_impl(const ImplementationBase *base, const void*)
    {
        // Overload resolution suggests that implementation definition is incomplete
        DestroyPolicy::destroy( base );
    }

public:
    typedef Implementation implementation_type;
    typedef ImplementationBase base_type;

    LEAN_INLINE pimpl_ptr(Implementation *impl)
        : m_impl(impl) { }
    LEAN_INLINE pimpl_ptr(pimpl_ptr &&right)
        : m_impl(right.m_impl)
    {
        right.m_impl = nullptr;
    }
    LEAN_INLINE ~pimpl_ptr() throw()
    {
        delete_impl(m_impl);
    }

    pimpl_ptr& operator =(Implementation *impl)
    {
        if (impl != m_impl)
        {
            ImplementationBase *prevImpl = m_impl;
            m_impl = impl;
            delete_impl(prevImpl);
        }

        return *this;
    }
    pimpl_ptr& operator =(pimpl_ptr &&right)
    {
        if (right.m_impl != m_impl)
        {
            ImplementationBase *prevImpl = m_impl;
            
            m_impl = right.m_impl;
            right.m_impl = nullptr;
            
            delete_impl(prevImpl);
        }
        return *this;
    }

    Implementation* unbind()
    {
        Implementation *impl = getptr();
        m_impl = nullptr;
        return impl;
    }

    LEAN_INLINE Implementation* getptr(void) { return static_cast<Implementation*>(m_impl); }
    LEAN_INLINE const Implementation* getptr(void) const { return static_cast<const Implementation*>(m_impl); }
    LEAN_INLINE Implementation& get(void) { return *getptr(); }
    LEAN_INLINE const Implementation& get(void) const { return *getptr(); }

    LEAN_INLINE bool empty(void) { return (m_impl == nullptr); }
    
    LEAN_INLINE Implementation& operator *() { return get(); }
    LEAN_INLINE const Implementation& operator *() const { return get(); }
    LEAN_INLINE Implementation* operator ->() { return getptr(); }
    LEAN_INLINE const Implementation* operator ->() const { return getptr(); }
};

} // namespace

using pimpl::pimpl_ptr;

} // namespace

#endif