object_ptr_privates.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_OBJECT_PTR_PRIVATES_IMPLEMENTATION_HEADER_
#define _ADTF_UCOM_ANT_OBJECT_PTR_PRIVATES_IMPLEMENTATION_HEADER_
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
//forward declare pointer types
template<typename>
class iobject_ptr;
template<typename>
class object_ptr;
template<typename>
class weak_object_ptr;
template<typename>
class enable_object_ptr_from_this;
template<typename>
class object_ptr_const_conversion;
 
//forward declare pointer casts
template<typename T, typename U>
object_ptr<T> ucom_object_ptr_cast(const iobject_ptr<U>& i_oOther);
 
namespace detail
{
 
template< typename >
class delegate_object_ptr;
 
//intermediate for delegate_object_ptr
template<typename T, typename Enable = void>
class delegate_object_ptr_resetter;
 
//intermediate for delegate_object_ptr
template<typename T>
class delegate_object_ptr_resetter<
    T,
    typename std::enable_if<std::is_class<T>::value && has_interface_info_type<typename std::remove_cv<T>::type>::value && std::is_same<typename std::remove_cv<T>::type, typename T::interface_type>::value>::type
> : 
    public object_ptr_const_conversion<typename iobject_ptr<T>::object_type>
{
    typedef typename iobject_ptr<T>::object_type object_type;  
 
public: //implement Reset function with CRTP
    virtual tResult Reset(const iobject_ptr<object_type>& i_oOther)
    {   //in case of an error, still reset!
        using child_type = delegate_object_ptr<T>;
        const auto pTmp = ucom_cast<T*>(i_oOther.Get());
        if (pTmp)
        {
            static_cast<child_type&>(*this) = child_type(i_oOther.GetObjPtrRef(), pTmp);
        }
        else
        {
            static_cast<child_type&>(*this) = child_type();
        }
 
        //successful if either reset pointer is not nil (ucom_cast succeeded) 
        //or incoming pointer is nil
        const bool bSuccess = static_cast<child_type&>(*this).Get() || !i_oOther.Get();
        if (!bSuccess)
        {
            RETURN_ERROR_DESC(ERR_NO_INTERFACE, "Object does not implement interface '%s'.", get_iid<T>());
        }
 
        RETURN_NOERROR;
    }
};//template<typename T> class delegate_object_ptr_resetter<T, true>
 
template<typename T>
class delegate_object_ptr_resetter<
    T,
    typename std::enable_if<std::is_class<T>::value && has_interface_info_type<typename std::remove_cv<T>::type>::value && !std::is_same<typename std::remove_cv<T>::type, typename T::interface_type>::value>::type
> : 
    public object_ptr_const_conversion<typename iobject_ptr<T>::object_type>
{
    typedef typename iobject_ptr<T>::object_type object_type;  
 
private:
    virtual tResult Reset(const iobject_ptr<object_type>&)
    {   //implement private and empty, as there is no way to reset from IObject without IID defined
        return ERR_NOT_IMPL;
    }
};//template<typename T> class delegate_object_ptr_resetter<T, true>
 
template<typename T>
class delegate_object_ptr_resetter<
    T,
    typename std::enable_if<!std::is_class<T>::value || !has_interface_info_type<typename std::remove_cv<T>::type>::value>::type
> :
    public object_ptr_const_conversion<typename iobject_ptr<T>::object_type>
{
    typedef typename iobject_ptr<T>::object_type object_type; 
 
private:
    virtual tResult Reset(const iobject_ptr<object_type>&)
    { //implement private and empty, as there is no way to reset from IObject without IID defined
        return ERR_NOT_IMPL;
    }
}; //template<typename T> class delegate_object_ptr_resetter<T, true>
 
template<typename TSize>
class DOEXPORT iobject_ptr_ref
{
    template<typename> friend class adtf::ucom::ant::weak_object_ptr;
    template<typename> friend class delegate_object_ptr;
 
protected: //types
    typedef TSize size_type;
 
protected: //construction/destruction
    ~iobject_ptr_ref() = default;
 
private:
    virtual void IncreaseUseCount() = 0;
    virtual void DecreaseUseCount() = 0;
 
    virtual void IncreaseWeakCount() = 0;
    virtual void DecreaseWeakCount() = 0;
 
    virtual bool IncreaseUseCountNonZero() = 0;
};//class iobject_ptr_base
 
//base class for the shared reference counter
class object_reference_counter : public iobject_ptr_ref<size_t>
{
public: //types
    typedef iobject_ptr_ref<size_t>::size_type   size_type;
 
public:
    template<typename U>
    explicit object_reference_counter(U* pObjImpl) :
        m_szUseCount(),
        m_szWeakCount(1),
        m_pObjImpl(ucom_cast<const IObject*>(pObjImpl))
    {
    }
 
    virtual ~object_reference_counter()
    {
    }
 
    virtual void IncreaseUseCount()
    {
        m_szUseCount++;
    }
 
    virtual void DecreaseUseCount()
    {
        //if the use count is zero, delete the shared resource
        if (0 == --m_szUseCount)
        {
            Destroy();
            DecreaseWeakCount();
        }
    }
 
    virtual void IncreaseWeakCount()
    {
        m_szWeakCount++;
    }
 
    virtual void DecreaseWeakCount()
    {
        //if the weak count is zero, delete the resource manager
        if (0 == --m_szWeakCount)
        {
            delete this;
        }
    }
 
    virtual bool IncreaseUseCountNonZero()
    {
        size_type szExpected = m_szUseCount;
        //Loop as long as either the use count got increased by one or the use count is 0
        //This step is necessary to ensure the use count won't be zero between two non atomic 
        //operations
        //Mind that szExpected is set to the current value by the compare and exchange method call.
        while (0 != szExpected &&
               !m_szUseCount.compare_exchange_weak(szExpected, szExpected + 1));
 
        return 0 != szExpected;
    }
 
private:
    void Destroy() const
    {
        m_pObjImpl->Destroy();
    }
 
private:    //types
    std::atomic<size_type> m_szUseCount;    
    std::atomic<size_type> m_szWeakCount;   
    const IObject* const   m_pObjImpl;      
};//class object_reference_counter
 
template<typename T>
class delegate_object_ptr : public delegate_object_ptr_resetter<T>
{
    typedef typename iobject_ptr<T>::object_type    object_type;
 
    template< typename >        friend class adtf::ucom::ant::object_ptr;
    template< typename, typename > friend class delegate_object_ptr_resetter;
 
    template<typename Implementation, typename ...Args> friend
        typename std::enable_if
                 <
                    std::is_base_of
                    <
                        enable_object_ptr_from_this<typename std::remove_cv<Implementation>::type>,
                        typename std::remove_cv<Implementation>::type
                    >::value,
                    object_ptr<Implementation>
                 >::type
    make_object_ptr(Args&&... args);
 
private:    //data section
    typedef object_reference_counter::size_type size_type;
    
    iobject_ptr_ref<size_type>* m_pRefer;        
    T*                          m_pSharedObject; 
 
private:    //member section
    delegate_object_ptr() :
        m_pRefer(nullptr),
        m_pSharedObject(nullptr)
    {
    }
 
    delegate_object_ptr(iobject_ptr_ref<size_type>* pRefer, T* pObject)
        : m_pRefer(pRefer), m_pSharedObject(pObject)
    {   
        RefObject();
    }
 
    delegate_object_ptr(const delegate_object_ptr& oOther)
        : m_pRefer(oOther.m_pRefer),
          m_pSharedObject(oOther.m_pSharedObject)
    {
        RefObject();
    }
 
    delegate_object_ptr(delegate_object_ptr&& oOther)
    {
        Swap(oOther);
    }
 
    template<typename U>
    delegate_object_ptr(const weak_object_ptr<U>& i_pWeak) : delegate_object_ptr()
    {   //let's try to implement this thread safe...
        if (nullptr != i_pWeak.m_pRefer && i_pWeak.m_pRefer->IncreaseUseCountNonZero())
        {
            m_pRefer = i_pWeak.m_pRefer;
            m_pSharedObject = i_pWeak.m_pObject;
        }
    }
 
    delegate_object_ptr& operator= (delegate_object_ptr i_oOther)
    {
        Swap(i_oOther);
        return *this;
    }
 
    ~delegate_object_ptr()
    {
        UnrefObject();
    }
 
    void RefObject()
    {
        if (nullptr != m_pRefer)
        {
            m_pRefer->IncreaseUseCount();
        }
    }
 
    void UnrefObject()
    {
        if (nullptr != m_pRefer)
        {
            m_pRefer->DecreaseUseCount();
            m_pSharedObject = nullptr;
            m_pRefer = nullptr;
        }
    }
 
    void Swap(delegate_object_ptr& o_oOther)
    {
        using std::swap;
        swap(m_pRefer, o_oOther.m_pRefer);
        swap(m_pSharedObject, o_oOther.m_pSharedObject);
    }
 
public: //implement iobject_ptr
    virtual object_type* Get() const
    {
        return ucom_cast<object_type*>(m_pSharedObject);
    }
 
    virtual object_type* operator->() const
    {
        return ucom_cast<object_type*>(m_pSharedObject);
    }
 
private: //implement iobject_ptr privates
    virtual iobject_ptr_ref<size_type>* GetObjPtrRef() const
    {
        return m_pRefer;
    }
};//end delegator
 
}//ns detail
}//ns ant
}//ns ucom
}//ns adtf
 
//specializing the swap function to enable best match for compiler
namespace std
{
    template<typename T>
    inline void swap(adtf::ucom::ant::detail::delegate_object_ptr<T>& i_oLHS,
                      adtf::ucom::ant::detail::delegate_object_ptr<T>& i_oRHS)
    {
        i_oLHS.Swap(i_oRHS);
    }
}//ns std
 
#endif //_ADTF_UCOM_ANT_OBJECT_PTR_PRIVATES_IMPLEMENTATION_HEADER_