object_ptr.h

Go to the documentation of this file.

 
#ifndef _ADTF_UCOM_ANT_OBJECT_PTR_IMPLEMENTATION_HEADER_
#define _ADTF_UCOM_ANT_OBJECT_PTR_IMPLEMENTATION_HEADER_
 
#ifndef _WIN32
// see https://gitlab.com/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/-/issues/2802
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
#endif
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template<typename T>
class object_ptr_const_conversion : public iobject_ptr<T>
{
protected:
    object_ptr_const_conversion() = default;
    ~object_ptr_const_conversion() = default;
public:
 
#ifndef _MSC_VER
    // see ACORE-9344, workaround for gcc de-virtualization behaviour
    __attribute__((noinline))
#endif
    operator const iobject_ptr<const T>& () const override
    {
        return *reinterpret_cast<const object_ptr_const_conversion<const T>*>(this);
    }
};//template<typename T> class object_ptr_const_conversion
 
template<typename T>
class object_ptr_const_conversion<const T> : public iobject_ptr<const T>
{
protected:
    object_ptr_const_conversion() = default;
    ~object_ptr_const_conversion() = default;
};//template<typename T> class object_ptr_const_conversion<const T>
 
template<typename T,
         bool = std::is_class<T>::value &&
                 detail::has_interface_info_type<typename std::remove_cv<T>::type>::value,
         typename = object_ptr<T>
         >
class object_ptr_base;
 
template<typename T, typename TChild>
class object_ptr_base<T, false, TChild> : public object_ptr_const_conversion<T>
{
    typedef typename iobject_ptr<T>::object_type object_type;  
 
public:
    operator const iobject_ptr<object_type>& () const
    {   //use CRTP to access the private area of the object_ptr (which is the child of this)
        return static_cast<const TChild* const>(this)->m_oDelegateObject;
    }
};//template<typename T, typename TChild> class object_ptr_base<T, false, TChild>
 
template<typename T, typename TChild>
class object_ptr_base<T, true, TChild> : public object_ptr_const_conversion<T>
 
{
    typedef typename iobject_ptr<T>::object_type object_type;  
 
public: //implement implicit cast with CRTP
    operator iobject_ptr<object_type>& ()
    {   //use CRTP to access the private area of the object_ptr (which is the child of this)
        return static_cast<TChild* const>(this)->m_oDelegateObject;
    }
 
    operator const iobject_ptr<object_type>& () const
    {   //use CRTP to access the private area of the object_ptr (which is the child of this)
        return static_cast<const TChild* const>(this)->m_oDelegateObject;
    }
 
protected:
    constexpr object_ptr_base()
    {
        static_assert(!std::is_same<TChild, object_ptr<object_type>>::value,
                      "object_ptr<IObject> already implicitly convertible to iobject_ptr<IObject>");
    }
};//template<typename T, typename TChild> class object_ptr_base<T, true, TChild>
 
template<> class object_ptr_base<IObject> : public object_ptr_const_conversion<IObject> {};
 
template<> class object_ptr_base<const IObject> : public iobject_ptr<const IObject> {};
 
template<typename T>
class object_ptr : public object_ptr_base<T>
{
    template<typename> friend class detail::delegate_object_ptr;
 
    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);
 
    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);
 
    friend class object_ptr_base<T, true, object_ptr<T>>;
    friend class object_ptr_base<T, false, object_ptr<T>>;
    friend class weak_object_ptr<T>;
 
private:    //member section
    template<typename U>
    object_ptr(U* pSharedObject) :
        m_oDelegateObject(nullptr != pSharedObject
                          ? new (std::nothrow) detail::object_reference_counter(pSharedObject)
                          : nullptr,
                          ucom_cast<T*>(pSharedObject))
    {
    }
 
    typedef detail::object_reference_counter::size_type size_type;
 
    virtual detail::iobject_ptr_ref<size_type>* GetObjPtrRef() const
    {
        return m_oDelegateObject.m_pRefer;
    }
 
private:    //data section
    typedef detail::delegate_object_ptr<T>  storage_type;
    storage_type m_oDelegateObject;
public:
    object_ptr() : m_oDelegateObject()
    {
    }
 
    virtual ~object_ptr() = default;
 
    object_ptr(std::nullptr_t) : object_ptr()
    {
    }
 
    object_ptr(const object_ptr& i_oOther) :
        object_ptr(static_cast<const iobject_ptr<T>&>(i_oOther))
    {
    }
 
    object_ptr(const iobject_ptr<T>& i_oOther) :
        m_oDelegateObject(i_oOther.GetObjPtrRef(), i_oOther.Get())
    {
    }
 
    template<typename U>
    object_ptr(const iobject_ptr<U>& i_oOther) :
        object_ptr(ucom_object_ptr_cast<T, U>(i_oOther))
    {
    }
 
    template<typename U>
    object_ptr(const iobject_ptr<U>& i_oOther, T* pSharedObject)
        : m_oDelegateObject(i_oOther.GetObjPtrRef(), pSharedObject)
    {
    }
 
    object_ptr(object_ptr&& i_oOther) : object_ptr()
    {
        Swap(i_oOther);  //leave move-from object in valid but unspecified state
    }
 
    template<typename U>
    object_ptr(const weak_object_ptr<U>& i_pWeak) :
        m_oDelegateObject(i_pWeak)
    {
    }
 
    object_ptr& operator=(object_ptr i_oOther)
    {
        Swap(i_oOther);
        return *this;
    }
 
    template<typename U>
    object_ptr& operator=(const object_ptr<U>& i_oOther)
    {
        *this = ucom_object_ptr_cast<T, U>(i_oOther);
        return *this;
    }
 
    T& operator*() const
    {
        return *Get();
    }
 
    explicit operator bool() const
    {
        return (Get() != nullptr);
    }
 
    void Reset()
    {
        *this = object_ptr();
    }
 
    void Swap(object_ptr& o_oOther)
    {
        m_oDelegateObject.Swap(o_oOther.m_oDelegateObject);
    }
 
public: //implement iobject_ptr
    virtual T* Get() const
    {
        return m_oDelegateObject.m_pSharedObject;
    }
 
    virtual T* operator->() const
    {
        return Get();
    }
 
    virtual tResult Reset(const iobject_ptr<T>& i_oOther)
    {
        *this = i_oOther;
        return ERR_NOERROR;
    }
};//class object_ptr<>
 
}//ns ant
 
template<class T>
using object_ptr = ant::object_ptr<T>;
 
}//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::object_ptr<T>& i_oLHS,
                      adtf::ucom::ant::object_ptr<T>& i_oRHS)
    {
        i_oLHS.Swap(i_oRHS);
    }
}//ns std
 
#ifndef _WIN32
#pragma GCC diagnostic pop
#endif
 
#endif //_ADTF_UCOM_ANT_OBJECT_PTR_IMPLEMENTATION_HEADER_