com_ptr.h

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

#ifndef LEAN_SMART_COM_PTR
#define LEAN_SMART_COM_PTR

#include "../lean.h"
#include "../meta/dependent_false.h"

namespace lean
{
namespace smart
{

template <class COMType>
LEAN_INLINE void acquire_com(COMType &object)
{
    object.AddRef();
}
template <class COMType>
LEAN_INLINE void release_com(COMType *object)
{
    if (object)
        object->Release();
}

template <class COMType, bool Critical = false>
class com_ptr
{
private:
    COMType *m_object;

    static COMType* acquire(COMType *object)
    {
        if (object)
            acquire_com(*object);

        return object;
    }

    static void release(COMType *object)
    {
        release_com(object);
    }

public:
    typedef COMType com_type;
    typedef COMType* value_type;

    com_ptr(com_type *object = nullptr)
        : m_object( acquire(object) ) { };
    template <class COMType2>
    com_ptr(COMType2 *object)
        : m_object( acquire(object) ) { };

    enum bind_reference_t
    {
        bind_reference 
    };
    com_ptr(COMType *object, bind_reference_t)
        : m_object(object) { };

    com_ptr(const com_ptr &right)
        : m_object( acquire(right.m_object) ) { };
    template <class COMType2, bool Critical2>
    com_ptr(const com_ptr<COMType2, Critical2> &right)
        : m_object( acquire(right.get()) ) { };

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class COMType2, bool Critical2>
    com_ptr(com_ptr<COMType2, Critical2> &&right)
        : m_object(right.unbind()) { }
#endif
    
    ~com_ptr() throw()
    {
        release(m_object);
    }

    static LEAN_INLINE com_ptr<com_type, true> bind(com_type *object)
    {
        return com_ptr<com_type, true>(object, com_ptr<com_type, true>::bind_reference);
    }
    LEAN_INLINE com_type* unbind()
    {
        COMType *preObject = m_object;
        m_object = nullptr;
        return preObject;
    }
    LEAN_INLINE com_ptr<com_type, true> transfer()
    {
        // Visual C++ won't inline delegating function calls
        return com_ptr<com_type, true>(unbind(), com_ptr<com_type, true>::bind_reference);
    }

    com_ptr& operator =(com_type *object)
    {
        // Do not check for redundant assignment
        // -> The code handles redundant assignment just fine
        // -> Checking generates up to twice the code due to unfortunate compiler optimization application order
        COMType *prevObject = m_object;
        m_object = acquire(object);
        release(prevObject);
    
        return *this;
    }

    com_ptr& operator =(const com_ptr &right)
    {
        return (*this = right.m_object);
    }
    template <class COMType2, bool Critical2>
    com_ptr& operator =(const com_ptr<COMType2, Critical2> &right)
    {
        return (*this = right.get());
    }

#ifndef LEAN0X_NO_RVALUE_REFERENCES

    template <class COMType2, bool Critical2>
    com_ptr& operator =(com_ptr<COMType2, Critical2> &&right)
    {
        // Self-assignment would be wrong
        if (right.get() != m_object)
        {
            COMType *prevObject = m_object;
            m_object = right.unbind();
            release(prevObject);
        }

        return *this;
    }
#endif

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

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

    LEAN_INLINE operator com_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();
    };

    LEAN_INLINE com_type** rebind()
    {
        *this = nullptr;
        return &m_object;
    }
};

template <class COMType>
LEAN_INLINE com_ptr<COMType, true> bind_com(COMType *object)
{
    // Visual C++ won't inline delegating function calls
    return com_ptr<COMType, true>(object, com_ptr<COMType, true>::bind_reference);
}

} // namespace

using smart::com_ptr;

using smart::bind_com;

} // namespace

#endif