dynamic_weak_ptr.h

 
#ifndef _aspose_system_dynamic_weak_ptr_h_
#define _aspose_system_dynamic_weak_ptr_h_
 
#include "system/smart_ptr.h"
#include "detail.h"
 
namespace System
{
 
namespace Details
{
    template <unsigned int ...leafs> struct WeakLeafMaker;
 
    template <unsigned int leaf, unsigned int ...leafs>
    struct WeakLeafMaker<leaf, leafs...>
    {
        static constexpr bool HasLeafs = true;
        static void Apply(System::Object *ptr);
    };
 
    template <>
    struct WeakLeafMaker<>
    {
        static constexpr bool HasLeafs = false;
        static void Apply(System::Object*)
        {}
    };
} //Details
template <typename T, SmartPtrMode trunkMode, unsigned int ...weakLeafs>
class DynamicWeakPtr : public SmartPtr<T>
{
public:
    typedef SmartPtr<T> SmartPtr_;
    typedef DynamicWeakPtr<T, trunkMode, weakLeafs...> DynamicWeakPtr_;
    using typename SmartPtr_::Pointee_;
    DynamicWeakPtr(std::nullptr_t = nullptr)
        : SmartPtr_(nullptr, trunkMode)
    {}
    DynamicWeakPtr(Pointee_ *object)
        : SmartPtr_(object, trunkMode)
    {
        Apply();
    }
    DynamicWeakPtr(const SmartPtr_ &ptr)
        : SmartPtr_(ptr, trunkMode)
    {
        Apply();
    }
    template<class Q>
    DynamicWeakPtr(const SmartPtr<Q>& x)
        : SmartPtr_(x, trunkMode)
    {
        Apply();
    }
    DynamicWeakPtr(const DynamicWeakPtr_ &ptr)
        : SmartPtr_(ptr, trunkMode)
    {
        Apply();
    }
    DynamicWeakPtr(SmartPtr_&& x)
        : SmartPtr_(x, trunkMode)
    {
        Apply();
    }
    bool operator == (std::nullptr_t) const
    {
        return SmartPtr_::operator == (nullptr);
    }
    DynamicWeakPtr_& operator = (SmartPtr_&& x)
    {
        SmartPtr_::operator = (x);
        Apply();
        return *this;
    }
    DynamicWeakPtr_& operator = (const SmartPtr_ &x)
    {
        SmartPtr_::operator = (x);
        Apply();
        return *this;
    }
    template <typename Q>
    DynamicWeakPtr_& operator = (const SmartPtr<Q> &x)
    {
        SmartPtr_::operator = (x);
        Apply();
        return *this;
    }
    DynamicWeakPtr_& operator = (typename SmartPtr_::Pointee_ *p)
    {
        SmartPtr_::operator = (p);
        Apply();
        return *this;
    }
    DynamicWeakPtr_& operator = (std::nullptr_t)
    {
        return SmartPtr_::operator = (nullptr);
    }
    class Reference
    {
    public:
        Reference(DynamicWeakPtr_ &ptr)
            : m_ptr(&ptr)
        {}
        Reference(Reference &&reference) noexcept
            : m_ptr(reference.m_ptr)
        {
            reference.m_ptr = nullptr;
        }
        ~Reference()
        {
            if (m_ptr)
                m_ptr->Apply();
        }
        operator DynamicWeakPtr_& () const
        {
            return *m_ptr;
        }
 
    private:
        DynamicWeakPtr_ *m_ptr;
    };
 
private:
    void Apply()
    {
        if (!System::Details::WeakLeafMaker<weakLeafs...>::HasLeafs)
            return;
        if (Object *const object = SmartPtr_::GetObjectOrNull())
            System::Details::WeakLeafMaker<weakLeafs...>::Apply(object);
    }
};
template <typename T, SmartPtrMode trunkMode, unsigned int ...weakLeafs>
typename DynamicWeakPtr<T, trunkMode, weakLeafs...>::Reference Ref(DynamicWeakPtr<T, trunkMode, weakLeafs...> &ptr)
{
    return typename DynamicWeakPtr<T, trunkMode, weakLeafs...>::Reference(ptr);
}
template <typename T>
decltype(Ref(std::declval<T&>())) Ref(const std::reference_wrapper<T> &wrapper)
{
    return Ref(wrapper.get());
}
 
} // namespace System
 
#endif // _aspose_system_dynamic_weak_ptr_h_