weak_object_ptr.h

Go to the documentation of this file.

#pragma once
 
#include "object_ptr_intf.h"
 
namespace adtf
{
namespace ucom
{
namespace ant
{
 
namespace detail
{
template<typename StorageType>
class object_ptr_storage;
}

template<typename T>
class weak_object_ptr
{
    template<typename>
    friend class detail::object_ptr_storage;
    typedef size_t size_type;
 
private:
    template<typename U>
    weak_object_ptr(U* i_pObject, detail::iobject_ptr_ref<size_type>* i_pRefer) noexcept:
        m_pObject(ucom_cast<T*>(i_pObject)), m_pRefer(i_pRefer)
    {
        if (nullptr != m_pRefer)
        {
            m_pRefer->IncreaseWeakCount();
        }
    }
 
public:
    constexpr weak_object_ptr() noexcept: m_pObject(nullptr), m_pRefer(nullptr)
    {
    }
    constexpr weak_object_ptr() noexcept: m_pObject(nullptr), m_pRefer(nullptr) {…}

    ~weak_object_ptr() noexcept
    {
        Reset();
    }
    ~weak_object_ptr() noexcept {…}

    constexpr weak_object_ptr(std::nullptr_t) noexcept: weak_object_ptr()
    {
    }
    constexpr weak_object_ptr(std::nullptr_t) noexcept: weak_object_ptr() {…}

    weak_object_ptr(const weak_object_ptr& i_oOther) noexcept:
        weak_object_ptr(i_oOther.m_pObject, i_oOther.m_pRefer) // Delegate increases weak count
    {
    }
    weak_object_ptr(const weak_object_ptr& i_oOther) noexcept: {…}

    weak_object_ptr& operator=(weak_object_ptr oOther) noexcept
    {
        Swap(oOther);
        return *this;
    }
    weak_object_ptr& operator=(weak_object_ptr oOther) noexcept {…}

    weak_object_ptr(weak_object_ptr&& oOther) noexcept: weak_object_ptr()
    {
        Swap(oOther); // leave oOther in valid but unspecified state
        oOther.Reset();
    }
    weak_object_ptr(weak_object_ptr&& oOther) noexcept: weak_object_ptr() {…}

    template<typename U>
    weak_object_ptr(const iobject_ptr<U>& i_pOther) noexcept:
        weak_object_ptr(i_pOther.Get(), i_pOther.GetObjPtrRef()) // delegate increases weak count
    {
    }
    weak_object_ptr(const iobject_ptr<U>& i_pOther) noexcept: {…}

    template<typename U>
    weak_object_ptr& operator=(const iobject_ptr<U>& i_pOther) noexcept
    {
        // delegate increases weak count
        *this = weak_object_ptr(i_pOther.Get(), i_pOther.GetObjPtrRef());
        return *this;
    }
    weak_object_ptr& operator=(const iobject_ptr<U>& i_pOther) noexcept {…}

    template<typename U>
    tResult Reset(const iobject_ptr<U>& i_oOther) noexcept
    {
        *this = i_oOther;
        return m_pObject || !i_oOther.Get() ? tResult() : tResult(ERR_NO_INTERFACE);
    }
    tResult Reset(const iobject_ptr<U>& i_oOther) noexcept {…}

    tResult Reset(const iobject_ptr<T>& i_oOther) noexcept
    {
        *this = i_oOther;
        return ERR_NOERROR;
    }
    tResult Reset(const iobject_ptr<T>& i_oOther) noexcept {…}

    void Reset() noexcept
    {
        if (nullptr != m_pRefer)
        {
            m_pRefer->DecreaseWeakCount();
            m_pRefer = nullptr;
            m_pObject = nullptr;
        }
    }
    void Reset() noexcept {…}

    void Swap(weak_object_ptr& o_oOther) noexcept
    {
        using std::swap; // ADL for swap()
        swap(o_oOther.m_pObject, m_pObject);
        swap(o_oOther.m_pRefer, m_pRefer);
    }
    void Swap(weak_object_ptr& o_oOther) noexcept {…}

    object_ptr<T> Lock() const noexcept
    {
        return object_ptr<T>(*this);
    }
    object_ptr<T> Lock() const noexcept {…}
 
private:
    T* m_pObject; 
    detail::iobject_ptr_ref<size_type>* m_pRefer; 
};
class weak_object_ptr {…};
 
} // namespace ant

template<class T>
using weak_object_ptr = ant::weak_object_ptr<T>;
 
} // 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::weak_object_ptr<T>& i_oLHS, adtf::ucom::ant::weak_object_ptr<T>& i_oRHS) noexcept
{
    i_oLHS.Swap(i_oRHS);
}
} // namespace std