object_ptr_utilities.h

Go to the documentation of this file.

#pragma once
 
#include "object_ptr.h"
#include "object_ptr_privates.h"
 
#include <memory>
#include <type_traits>
 
namespace adtf
{
namespace ucom
{
namespace vision
{
template<typename Implementation, bool Fuse, typename Allocator, typename... Args>
inline object_ptr<Implementation> allocate_object_ptr(Allocator&& allocator, Args&&... args);
}
namespace ant
{

template<typename T>
class enable_object_ptr_from_this
{
protected: // construction/destruction
    enable_object_ptr_from_this() = default;
    ~enable_object_ptr_from_this() = default;
    enable_object_ptr_from_this(const enable_object_ptr_from_this&) = default;
    enable_object_ptr_from_this& operator=(const enable_object_ptr_from_this&) = default;
 
public:
    object_ptr<T> object_ptr_from_this()
    {
        return m_pWeak.Lock();
    }

    object_ptr<const T> object_ptr_from_this() const
    {
        return m_pWeak.Lock();
    }
 
private:
    // Only allocate_object_ptr has access to Assign()
    template<typename Implementation, bool Fuse, typename Allocator, typename... Args>
    friend object_ptr<Implementation> vision::allocate_object_ptr(Allocator&& allocator, Args&&... args);

    void Assign(const object_ptr<T>& i_pObject)
    {
        m_pWeak.Reset(i_pObject);
    }
 
private: // private data
    weak_object_ptr<T> m_pWeak; 
}; // template<typename T> class enable_object_ptr_from_this
 
namespace detail
{

template<typename T>
T* deduce_object_ptr_enabler(enable_object_ptr_from_this<T>&) noexcept;
 
template<typename Implementation, typename = void>
struct enables_object_ptr_from_this: ::std::false_type
{
};

template<typename Implementation>
struct enables_object_ptr_from_this<
    Implementation,
    ::std::void_t<decltype(deduce_object_ptr_enabler(::std::declval<Implementation&>()))>>:
    ::std::is_convertible<Implementation*, decltype(deduce_object_ptr_enabler(::std::declval<Implementation&>()))>
{
};

} // namespace detail
 
// #################################################################################################
// ############################### Special free functions ##########################################
// #################################################################################################
template<typename T>
object_ptr<T> ucom_object_ptr_cast(object_ptr<T> oCasted)
{
    return oCasted;
}

template<typename Implementation, typename... Args>
inline object_ptr<Implementation> make_object_ptr(Args&&... args)
{
    return vision::allocate_object_ptr<Implementation, true>(std::allocator<void>(), std::forward<Args>(args)...);
}

template<typename Implementation>
inline object_ptr<std::decay_t<Implementation>> make_object_ptr(Implementation&& object_to_emplace)
{
    return vision::allocate_object_ptr<std::decay_t<Implementation>, true>(std::allocator<void>(),
                                                                           std::forward<Implementation>(object_to_emplace));
}

template<typename T, typename U>
tResult reset_object_ptr(iobject_ptr<const T>& o_oDest, const iobject_ptr<U>& i_oSrc)
{
    // must be checked beforehand to determine error if ucom_object_ptr_cast returns empty
    if (nullptr == i_oSrc.Get())
    { // resetting empty is not an error
        o_oDest.Reset(object_ptr<const T>());
        return ERR_NOERROR;
    }
 
    // if the subsequent call returns empty, the ucom_cast<> failed
    const auto pTmp = ucom_object_ptr_cast<const T>(i_oSrc);
    if (!pTmp)
    { // reset empty and return error
        o_oDest.Reset(object_ptr<const T>());
        return ERR_NO_INTERFACE;
    }
 
    return o_oDest.Reset(pTmp);
}

template<typename T>
tResult reset_object_ptr(iobject_ptr<const T>& o_oDest, const iobject_ptr<T>& i_oSrc)
{
    const object_ptr<const T> pTmp(i_oSrc);
    return o_oDest.Reset(pTmp);
}
 
} // namespace ant
 
namespace penguin
{

template<typename T>
ant::object_ptr<T> ucom_object_ptr_const_cast(const ant::iobject_ptr<const T>& i_oOther)
{
    return ant::object_ptr<T>(i_oOther, const_cast<typename ant::object_ptr<T>::element_type*>(i_oOther.Get()));
}
 
} // namespace penguin
 
namespace vision
{
template<typename Implementation, bool Fuse, typename Allocator, typename... Args>
inline object_ptr<Implementation> allocate_object_ptr(Allocator&& allocator, Args&&... args)
{
    static_assert(!std::is_reference_v<Implementation> && !std::is_volatile_v<Implementation>);
    using implementation_base_type = std::remove_const_t<Implementation>;
    using allocator_base = typename std::allocator_traits<Allocator>::template rebind_alloc<void>;
    using counter_type = detail::fused_object_reference_counter<implementation_base_type, allocator_base, Fuse>;
 
    auto pCounter = counter_type::Create(std::forward<Allocator>(allocator), std::forward<Args>(args)...);
    auto pSharedObject = pCounter->GetSharedObject();
    object_ptr<implementation_base_type> oResult(static_cast<ant::detail::iobject_ptr_ref<size_t>*>(pCounter),
                                                 pSharedObject);
 
    if constexpr (ant::detail::enables_object_ptr_from_this<implementation_base_type>::value)
    {
        // the base may be enabled for one of the base classes of the implementation, so the object_ptr
        // to assign shares the reference count of the result and points to that base
        using enabled_type =
            ::std::remove_pointer_t<decltype(ant::detail::deduce_object_ptr_enabler(*pSharedObject))>;
        enabled_type* pEnabled = pSharedObject;
        ant::enable_object_ptr_from_this<enabled_type>* pEnabler = pSharedObject;
        pEnabler->Assign(object_ptr<enabled_type>(oResult, pEnabled));
    }
 
    return oResult;
}
} // namespace vision

template<class T>
using enable_object_ptr_from_this = ant::enable_object_ptr_from_this<T>;

using ant::ucom_object_ptr_cast;

using ant::make_object_ptr;

using ant::reset_object_ptr;

using penguin::ucom_object_ptr_const_cast;

using vision::allocate_object_ptr;
 
} // namespace ucom
} // namespace adtf