WeakRef.h

#pragma once
 
#include <fsdk/Types/Ref.h>
#include <fsdk/Types/RefBase.h>
 
namespace fsdk {
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
    template <typename T>
    struct WeakRef : RefBase<T> {
 
        WeakRef() noexcept = default;
 
        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(this->get())
                    this->get()->retainWeak();
            }
 
            return *this;
        }
 
        void reset() noexcept {
            assign(nullptr);
        }
 
        Ref<T> lock() const noexcept {
            return (!this->get() || this->isExpired()) ? Ref<T>() : Ref<T>(*this);
        }
 
        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 {
        if(this->get() != other.get()) {
            if(this->get())
                this->get()->release();
 
            this->set(other.get());
 
            // if retainLocked returns 0 or less it means refcounted object was destroyed in some other thread
            if(this->get() && this->get()->retainLocked() < 1)
                this->set(nullptr);
        }
 
        return *this;
    }
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
} // namespace fsdk