WeakRef.h

#pragma once
#include <fsdk/Def.h>

namespace fsdk
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS

    template<typename T>
    struct WeakRef : RefBase<T> {

        WeakRef() noexcept {}

        WeakRef(std::nullptr_t) noexcept {}

        explicit WeakRef(T* ptr) noexcept { *this = ptr; }

        WeakRef(const WeakRef& other) noexcept { *this = other; }

        WeakRef(const Ref<T>& other) noexcept { *this = other; }

        ~WeakRef() {
            reset();
        }

        WeakRef& operator = (const Ref<T>& other) noexcept {
            return assign(other.get());
        }

        WeakRef& operator = (const WeakRef& other) noexcept {
            return assign(other.get());
        }

        WeakRef& operator = (T* ptr) noexcept {
            return assign(ptr);
        }

        WeakRef& operator = (std::nullptr_t) noexcept {
            reset();
            return *this;
        }

        WeakRef& assign(T* ptr) noexcept {
            if(this->get() != ptr)
            {
                if(this->get())
                    this->get()->releaseWeak();

                this->set(ptr);

                // if retainWeak returns 0 or less it means refcounted object was deallocated in some other
                // thread, so you cant use it and the only solution is to reset WeakRef
                // tbh it should never return negative numbers, but just to be save check it
                if(this->get() && this->get()->retainWeak() < 1)
                    this->set(nullptr);
            }

            return *this;
        }

        void reset() noexcept {
            assign(nullptr);
        }

        Ref<T> lock() const noexcept {
            return (!this->get() || this->isExpired()) ? Ref<T>() : Ref<T>(this->get());
        }

        template<typename S> WeakRef<S> as() noexcept {
            return WeakRef<S>(static_cast<S*>(this->get()));
        }
    };


    template<typename T>
    inline WeakRef<T> make_weak_ref(T* ptr) noexcept {
        return WeakRef<T>(ptr);
    }


    template<typename S, typename T>
    inline WeakRef<S> make_weak_ref_as(T* ptr) noexcept {
        return WeakRef<S>(static_cast<S*>(ptr));
    }

    /* Documented elsewhere. */
    template<typename T>
    inline Ref<T>&
    Ref<T>::operator = (const WeakRef<T>& other) noexcept {
        *this = other.lock();
        return *this;
    }

#endif /* DOXYGEN_SHOULD_SKIP_THIS */
}