weak_reference.h

 
#pragma once
 
#include "system/object.h"
#include "system/smart_ptr.h"
#include "system/weak_ptr.h"
 
namespace System
{
    template <typename... Args>
    class ASPOSECPP_SHARED_CLASS WeakReference;
 
    template <typename T>
    class ASPOSECPP_SHARED_CLASS WeakReference<T> : public System::Object
    {
 
        RTTI_INFO(System::WeakReference<T>, ::System::BaseTypesInfo<System::Object>)
    public:
        WeakReference()
        {
        }
 
        WeakReference(std::nullptr_t)
        {
        }
 
        WeakReference(const SmartPtr<T>& data)
        {
            wptr = data;
        }
 
        WeakReference(const SmartPtr<T>& data, bool trackResurrection)
        {
            ASPOSE_UNUSED(trackResurrection);
            wptr = data;
        }
 
        bool TryGetTarget(const SmartPtr<T>& data) const
        {
            data = wptr;
            return true;
        }
 
        void SetTarget(const SmartPtr<T>& data)
        {
            wptr = data;
        }
 
        void reset()
        {
            wptr.reset();
        }
 
        bool operator==(std::nullptr_t) const
        {
            return wptr == nullptr;
        }
 
        bool operator!=(std::nullptr_t) const
        {
            return !(*this == nullptr);
        }
 
        bool operator==(const WeakReference<T>& other) const
        {
            return wptr == other.wptr;
        }
 
        bool operator!=(const WeakReference<T>& other) const
        {
            return wptr != other.wptr;
        }
 
    protected:
        WeakPtr<T> wptr;
    };
 
    template <>
    class ASPOSECPP_SHARED_CLASS WeakReference<> : public WeakReference<System::Object>
    {
 
        RTTI_INFO(System::WeakReference<>, ::System::BaseTypesInfo<System::Object>);
    public:
        WeakReference() : WeakReference<Object>()
        {
        }
 
        WeakReference(std::nullptr_t) : WeakReference<Object>(nullptr)
        {
        }
 
        WeakReference(const SmartPtr<Object>& data) : WeakReference<Object>(data)
        {
        }
 
        WeakReference(const SmartPtr<Object>& data, bool trackResurrection) : WeakReference<Object>(data, trackResurrection)
        {
        }
 
        const WeakPtr<Object>& get_Target() const
        {
            return wptr;
        }
 
        void set_Target(const SmartPtr<Object>& data)
        {
            wptr = data;
        }
 
        bool get_IsAlive() const
        {
            return !wptr.expired();
        }
    };
}