AutoRef.h

//
// Copyright (c) 2006-2014 Raphael David / CANTOR
//

#ifndef CMR_AUTO_REF_DEFINED
#define CMR_AUTO_REF_DEFINED

#include "Commore.h"
#include "RefObject.h"

namespace commore
{

    inline void  AutoRefBase::attach()
    {
        if (p_)
        {
            p_->attach();
        }
    }
    inline void  AutoRefBase::release()
    {
        if (p_)
        {
            p_->release();
            p_ = 0;
        }
    }

    inline void  IAutoRefBase::attach()
    {
        if (p_)
        {
            p_->nested_attach();
        }
    }
    inline void  IAutoRefBase::release()
    {
        if (p_)
        {
            p_->nested_release();
            p_ = 0;
        }
    }

    template <class E> class AutoRef : public AutoRefBase
    {
    public:
        AutoRef()
            : AutoRefBase(dynamic_cast<E*>(E::auto_create().get_()))
        {}
        AutoRef(const AChar* s)
            : AutoRefBase(dynamic_cast<E*>(RefFactory::lookup_create(E::factory_name(), s, dynamic_cast<E*>(E::auto_create(s).get_())).get_()))
        {}
        explicit   AutoRef(bool)
            : AutoRefBase(dynamic_cast<E*>(E::create().get_()))
        {}
        AutoRef(E* p)
            : AutoRefBase(dynamic_cast<E*>(p))
        {}
        AutoRef(RefObject* p)
            : AutoRefBase(dynamic_cast<E*>(p))
        {}
        AutoRef(const AutoRef& a)
            : AutoRefBase(a.get_())
        {}
        AutoRef(const AutoRefBase& a)
            : AutoRefBase(dynamic_cast<E*>(a.get_()))
        {}
        AutoRef& operator = (const AutoRef& a)
        {
            if ((void*)this != (void*)&a)
            {
                set_(a.get_());
            }
            return *this;
        }
        AutoRef& operator = (const AutoRefBase& a)
        {
            if ((void*)this != (void*)&a)
            {
                set_(dynamic_cast<E*>(a.get_()));
            }
            return *this;
        }
        AutoRef& operator = (RefObject* p)
        {
            set_(dynamic_cast<E*>(p));
            return *this;
        }
        operator bool () const
        {
            return get_() != 0;
        }

    public:
        bool  create(const AChar* s)
        {
            set_(dynamic_cast<E*>(RefFactory::lookup_create(E::factory_name(), s, dynamic_cast<E*>(E::create(s).get_())).get_()));
            return get() != 0;
        }
        bool create()
        {
            set_(dynamic_cast<E*>(E::create().get_()));
            return get() != 0;
        }
        bool  bind(const AChar* s)
        {
            set_(dynamic_cast<E*>(E::bind(s).get_()));
            return get() != 0;
        }
        bool  bind()
        {
            set_(dynamic_cast<E*>(E::bind().get_()));
            return get() != 0;
        }
        E* get() const
        {
            return (E*)get_();
        }
        E& operator*() const
        {
            return *get();
        }
        E* operator->() const
        {
            return get();
        }
        operator E* () const
        {
            return get();
        }
        bool operator == (const AutoRef& a) const
        {
            return get() == a.get();
        }
        bool operator != (const AutoRef& a) const
        {
            return get() != a.get();
        }
        bool operator < (const AutoRef& a) const
        {
            return get() < a.get();
        }
        bool is_bound() const
        {
            return get_() != 0;
        }
        void unbind()
        {
            set_(0);
        }
    };

    template <class E> class IAutoRef : public IAutoRefBase
    {
    public:
        IAutoRef()
            : IAutoRefBase(dynamic_cast<E*>(E::auto_create().get_()))       {}
        IAutoRef(const AChar* s)
            : IAutoRefBase(dynamic_cast<E*>(RefFactory::lookup_create(E::factory_name(), s, dynamic_cast<E*>(E::auto_create(s).get_())).get_()))  {}
        IAutoRef(bool)
            : IAutoRefBase(dynamic_cast<E*>(E::create().get_()))            {}
        IAutoRef(E* p)
            : IAutoRefBase(dynamic_cast<E*>(p))                             {}
        IAutoRef(RefObject* p)
            : IAutoRefBase(dynamic_cast<E*>(p))                             {}
        IAutoRef(const IAutoRef& a)
            : IAutoRefBase(a.get_())                                        {}
        IAutoRef(const IAutoRefBase& a)
            : IAutoRefBase(dynamic_cast<E*>(a.get_()))                      {}
        IAutoRef& operator = (const IAutoRef& a)
        {
            if ((void*)this != (void*)&a)
            {
                set_(a.get_());
            }
            return *this;
        }
        IAutoRef& operator = (const IAutoRefBase& a)
        {
            if ((void*)this != (void*)&a)
            {
                set_(dynamic_cast<E*>(a.get_()));
            }
            return *this;
        }
        //IAutoRef& operator = (E* p)                 { set_(p); return *this; }
        IAutoRef& operator = (RefObject* p)
        {
            set_(dynamic_cast<E*>(p));
            return *this;
        }
        operator bool () const
        {
            return get_() != 0;
        }

    public:
        bool  create(const AChar* s)
        {
            set_(dynamic_cast<E*>(RefFactory::lookup_create(E::factory_name(), s, dynamic_cast<E*>(E::create(s).get_())).get_()));
            return get() != 0;
        }
        bool  create()
        {
            set_(dynamic_cast<E*>(E::create().get_()));
            return get() != 0;
        }
        bool  bind()
        {
            set_(dynamic_cast<E*>(E::bind().get_()));
            return get() != 0;
        }
        bool  bind(const AChar* s)
        {
            set_(dynamic_cast<E*>(E::bind(s).get_()));
            return get() != 0;
        }
        E* get() const
        {
            return (E*)get_();
        }
        //E& operator*() const                         { return *get();}
        E* operator->() const
        {
            return get();
        }
        operator AutoRef<E> () const
        {
            return get();
        }
        bool operator == (const IAutoRef& a) const
        {
            return get() == a.get();
        }
        bool operator != (const IAutoRef& a) const
        {
            return get() != a.get();
        }
        bool is_bound() const
        {
            return get_() != 0;
        }
    };

};

#ifdef CMR_BSTREAM_INCLUDED
template<class X>
commore::OBStream& operator << (commore::OBStream& o, const commore::AutoRef<X>& p)
{
    o << (void*)p.get();
    return o;
}

template<class X>
commore::OBStream& operator << (commore::OBStream& o, const commore::IAutoRef<X>& p)
{
    o << (void*)p.get();
    return o;
}
#endif

#endif