object_ptr.h

Go to the documentation of this file.

#pragma once
 
#include "object_ptr_intf.h"
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
template<typename T>
class weak_object_ptr;
 
namespace detail
{
template<typename StorageType>
class object_ptr_storage
{
public:
    constexpr object_ptr_storage() noexcept: m_pObject(nullptr), m_pRefer(nullptr)
    {
    }
 
    constexpr object_ptr_storage(::std::nullptr_t) noexcept: object_ptr_storage()
    {
    }
 
    object_ptr_storage(iobject_ptr_ref<size_t>* pControlBlock,
                       StorageType* pSharedObject,
                       bool bFromWeak = false) noexcept:
        m_pObject(pSharedObject), m_pRefer(pSharedObject ? pControlBlock : nullptr)
    {
        if (m_pRefer)
        {
            if (bFromWeak)
            {
                if (!m_pRefer->IncreaseUseCountNonZero())
                {
                    m_pObject = nullptr;
                    m_pRefer = nullptr;
                }
            }
            else
            {
                m_pRefer->IncreaseUseCount();
            }
        }
    }
 
    object_ptr_storage(const object_ptr_storage& oOther) noexcept:
        object_ptr_storage(oOther.GetObjPtrRef(), oOther.GetStorageObject())
    {
    }
 
    template<typename U,
             typename ConstCompatible = ::std::enable_if_t<::std::is_const_v<StorageType> || !::std::is_const_v<U>>>
    object_ptr_storage(const iobject_ptr<U>& oOther) noexcept:
        object_ptr_storage(oOther.GetObjPtrRef(), ucom_cast<StorageType*>(oOther.Get()))
    {
    }
 
    template<typename U,
             typename ConstCompatible = ::std::enable_if_t<std::is_const_v<StorageType> || !::std::is_const_v<U>>>
    object_ptr_storage(const weak_object_ptr<U>& oWeak) noexcept:
        object_ptr_storage(oWeak.m_pRefer, oWeak.m_pObject, true)
    {
    }
 
    object_ptr_storage(const iobject_ptr<StorageType>& oOther) noexcept:
        object_ptr_storage(oOther.GetObjPtrRef(), oOther.Get())
    {
    }

    template<typename U>
    object_ptr_storage(const iobject_ptr<U>& i_oOther, StorageType* pSharedObject) noexcept:
        object_ptr_storage(i_oOther.GetObjPtrRef(), pSharedObject)
    {
    }
 
    ~object_ptr_storage()
    {
        Reset();
    }
 
    constexpr detail::iobject_ptr_ref<size_t>* GetObjPtrRef() const noexcept
    {
        return m_pRefer;
    }
 
    constexpr StorageType* GetStorageObject() const noexcept
    {
        return m_pObject;
    }
 
    object_ptr_storage& operator=(const object_ptr_storage& oOther)
    {
        object_ptr_storage oHelper(oOther);
        Swap(oHelper);
        return *this;
    }
 
    object_ptr_storage& operator=(object_ptr_storage&& oOther)
    {
        Swap(oOther);
        // Not strictly neccessary by operator definition, but tests require this.
        // Has unintended side effect of making the move assignment throwing.
        oOther.Reset();
        return *this;
    }
 
    void Reset()
    {
        if (m_pRefer)
        {
            auto pOrphanedBlock = m_pRefer;
            m_pRefer = nullptr;
            m_pObject = nullptr;
            // If the destructor of iobject_ptr_ref is throwing, then Reset() is throwing too.
            pOrphanedBlock->DecreaseUseCount();
        }
    }
 
    void Swap(object_ptr_storage& oOther) noexcept
    {
        using ::std::swap;
        swap(m_pObject, oOther.m_pObject);
        swap(m_pRefer, oOther.m_pRefer);
    }
 
private:
    StorageType* m_pObject; 
    detail::iobject_ptr_ref<size_t>* m_pRefer; 
};
 
template<typename StorageType>
class object_ptr_const_iobject_delegate;
template<typename StorageType>
class object_ptr_iobject_delegate;
template<typename T, typename StorageType>
class object_ptr_const_delegate;
template<typename T, typename StorageType>
class object_ptr_delegate;
 
template<typename T, typename StorageType>
using object_ptr_base =
    typename ::std::conditional_t<::std::is_same_v<std::remove_const_t<T>, IObject>,
                                  ::std::conditional_t<::std::is_const_v<T>,
                                                       object_ptr_const_iobject_delegate<StorageType>,
                                                       object_ptr_iobject_delegate<StorageType>>,
                                  ::std::conditional_t<::std::is_const_v<T>,
                                                       object_ptr_const_delegate<T, StorageType>,
                                                       object_ptr_delegate<T, StorageType>>>;
 
template<typename T, typename StorageType>
class object_ptr_delegate_base : public iobject_ptr<T>
{
    static_assert(!::std::is_volatile_v<T> && !::std::is_reference_v<T>);
    static_assert(!::std::is_volatile_v<StorageType> && !::std::is_reference_v<StorageType>);
    static_assert(::std::is_const_v<T> || !::std::is_const_v<StorageType>,
                  "Can't enable non-const interface for a const storage type");
 
public:
    template<typename... Args>
    object_ptr_delegate_base(Args&&... args) noexcept: m_oDelegate(::std::forward<Args>(args)...)
    {
    }
 
    object_ptr_delegate_base(const object_ptr_delegate_base& oOther) noexcept:
        object_ptr_delegate_base(oOther, oOther.GetStorageObject())
    {
    }
 
    object_ptr_delegate_base(object_ptr_delegate_base&& oOther) noexcept: object_ptr_delegate_base()
    {
        Swap(oOther);
    }
 
    ~object_ptr_delegate_base() = default;
 
    constexpr detail::iobject_ptr_ref<size_t>* GetObjPtrRef() const noexcept final override
    {
        return m_oDelegate.GetObjPtrRef();
    }
 
    constexpr StorageType* GetStorageObject() const noexcept
    {
        return m_oDelegate.GetStorageObject();
    }
 
    T* Get() const final override
    {
        if constexpr (::std::is_same_v<T, StorageType>)
        {
            return GetStorageObject();
        }
        else
        {
            return ucom_cast<T*>(GetStorageObject());
        }
    }
 
    T* operator->() const noexcept final override
    {
        return Get();
    }
 
    T& operator*() const noexcept
    {
        return *Get();
    }
 
    void Swap(object_ptr_delegate_base& oOther) noexcept
    {
        m_oDelegate.Swap(oOther.m_oDelegate);
    }
 
    void Reset()
    {
        m_oDelegate.Reset();
    }
 
    tResult Reset(const iobject_ptr<T>& oOther) noexcept final override
    {
        RETURN_IF_THROWS(Reset());
 
        if (!oOther.Get())
        {
            RETURN_NOERROR;
        }
        else if constexpr (::std::is_same_v<T, StorageType>)
        {
            object_ptr_base<T, StorageType> oHelper(oOther);
            Swap(oHelper);
            RETURN_NOERROR;
        }
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 6326) // Potential comparison of a constant with another constant
#endif
        else if constexpr (::std::is_same_v<std::remove_const_t<T>, IObject> &&
                           ::std::is_const_v<StorageType> == ::std::is_const_v<T> &&
                           has_interface_info_type<::std::remove_const_t<StorageType>>::value)
#ifdef _MSC_VER
#pragma warning(pop)
#endif
        {
            const auto pObject = ucom_cast<StorageType*>(oOther.Get());
            if (!pObject)
            {
                RETURN_ERROR_DESC(ERR_NO_INTERFACE, "Object does not implement interface '%s'.",
                                  get_iid<StorageType>());
            }
 
            object_ptr_base<T, StorageType> oHelper(oOther, pObject);
            Swap(oHelper);
            RETURN_NOERROR;
        }
        else
        {
            RETURN_ERROR(ERR_NO_INTERFACE);
        }
    }
 
    object_ptr_delegate_base& operator=(const object_ptr_delegate_base& oOther)
    {
        m_oDelegate = oOther.m_oDelegate;
        return *this;
    }
 
    object_ptr_delegate_base& operator=(object_ptr_delegate_base&& oOther)
    {
        m_oDelegate = ::std::move(oOther.m_oDelegate);
        return *this;
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return (GetStorageObject() != nullptr);
    }
 
protected:
    ::std::conditional_t<::std::is_same_v<std::remove_const_t<T>, IObject>,
                         std::conditional_t<!::std::is_const_v<T> && !::std::is_const_v<StorageType>,
                                            object_ptr_const_iobject_delegate<StorageType>,
                                            object_ptr_storage<StorageType>>,
                         std::conditional_t<::std::is_const_v<T> || ::std::is_const_v<StorageType>,
                                            ::std::conditional_t<::std::is_const_v<StorageType>,
                                                                 object_ptr_const_iobject_delegate<StorageType>,
                                                                 object_ptr_iobject_delegate<StorageType>>,
                                            object_ptr_const_delegate<const T, StorageType>>>
        m_oDelegate;
};
 
template<typename StorageType>
class object_ptr_const_iobject_delegate : public object_ptr_delegate_base<const IObject, StorageType>
{
public:
    using object_ptr_delegate_base<const IObject, StorageType>::object_ptr_delegate_base;
};
 
template<typename StorageType>
class object_ptr_iobject_delegate : public object_ptr_delegate_base<IObject, StorageType>
{
    using base = object_ptr_delegate_base<IObject, StorageType>;
public:
    using base::base;
 
    constexpr operator const iobject_ptr<const IObject>&() const noexcept final override
    {
        return base::m_oDelegate;
    }
};
 
template<typename T, typename StorageType>
class object_ptr_const_delegate : public object_ptr_delegate_base<T, StorageType>
{
    static_assert(::std::is_const_v<T> && !::std::is_same_v<T, const IObject>);
 
    using base = object_ptr_delegate_base<T, StorageType>;
public:
    using base::base;
 
    constexpr operator const iobject_ptr<const IObject>&() const noexcept
    {
        return base::m_oDelegate;
    }
 
    template<typename U, typename = ::std::enable_if_t<::std::is_same_v<U, IObject> && !::std::is_const_v<StorageType>>>
    constexpr operator const iobject_ptr<U>&() const noexcept
    {
        return base::m_oDelegate;
    }
 
    template<typename U,
             typename = std::enable_if_t<(::std::is_same_v<U, const IObject> && ::std::is_const_v<StorageType>) ||
                                         (::std::is_same_v<U, IObject> && !::std::is_const_v<StorageType>)>>
    constexpr operator iobject_ptr<U>&() noexcept
    {
        return base::m_oDelegate;
    }
};
 
template<typename T, typename StorageType>
class object_ptr_delegate : public object_ptr_delegate_base<T, StorageType>
{
    static_assert(!::std::is_const_v<T> && !::std::is_same_v<T, IObject>);
    using base = object_ptr_delegate_base<T, StorageType>;
public:
    using base::base;
 
    constexpr operator const iobject_ptr<const T>&() const noexcept final override
    {
        return base::m_oDelegate;
    }
 
    constexpr operator const iobject_ptr<const IObject>&() const noexcept
    {
        return base::m_oDelegate;
    }
 
    constexpr operator const iobject_ptr<IObject>&() const noexcept
    {
        return base::m_oDelegate;
    }
 
    constexpr operator iobject_ptr<IObject>&() noexcept
    {
        return base::m_oDelegate;
    }
};
 
} // namespace detail
 
template<typename T>
class object_ptr : public detail::object_ptr_base<T, T>
{
    using base = detail::object_ptr_base<T, T>;
 
public:
    using base::base;
};
 
} // namespace ant

using ant::object_ptr;
 
} // namespace ucom
} // namespace 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) noexcept
{
    i_oLHS.Swap(i_oRHS);
}
} // namespace std