Ref.h

#pragma once
 
namespace fsdk
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
    /* Forward decalrations. */
    template<typename T> struct WeakRef;
 
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
    template<typename T>
    struct Ref : RefBase<T> {
 
        Ref() noexcept {}
 
        Ref(std::nullptr_t) noexcept {}
 
        explicit Ref(T* ptr) noexcept { *this = ptr; }
 
        Ref(const Ref& other) noexcept { *this = other; }
 
    #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
        Ref(const WeakRef<T>& other) noexcept { *this = other; }
 
    #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
        ~Ref() noexcept {
            reset();
        }
 
        T* operator -> () const noexcept {
            assert(!this->isNull());
            return this->get();
        }
 
        T** getInitReference() noexcept {
            if(this->get())
                this->get()->release();
 
            this->set(nullptr);
 
            return &this->m_ptr;
        }
 
        bool operator == (const Ref& other) const noexcept {
            return this->get() == other.get();
        }
 
        bool operator != (const Ref& other) const noexcept {
            return !(*this == other);
        }
 
    #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
        Ref& operator = (const WeakRef<T>& other) noexcept;
 
    #endif /* DOXYGEN_SHOULD_SKIP_THIS */
 
        Ref& operator = (const Ref& other) noexcept {
            return assign(other.get());
        }
 
        Ref& operator = (T* ptr) noexcept {
            return assign(ptr);
        }
 
        Ref& operator = (std::nullptr_t) noexcept {
            reset();
            return *this;
        }
 
        Ref& assign(T* ptr) noexcept {
            if(this->get() != ptr)
            {
                if(this->get())
                    this->get()->release();
 
                this->set(ptr);
 
                // if retain returns 0 or less it means refcounted object was destroyed in some other
                // thread, so you cant use it and the only solution is to reset Ref
                // tbh it should never return negative numbers, but just to be save check it
                if(this->get() && this->get()->retain() < 1)
                    this->set(nullptr);
            }
 
            return *this;
        }
 
        Ref& acquire(T* ptr) noexcept {
            if(this->get() != ptr)
            {
                if(this->get())
                    this->get()->release();
 
                this->set(ptr);
            }
 
            return *this;
        }
 
        //void reset() noexcept {
        T* reset() noexcept {
            T* ptr = this->get();
            assign(nullptr);
            return ptr;
        }
 
        template<typename S> Ref<S> as() const noexcept {
            return Ref<S>(static_cast<S*>(this->get()));
        }
    };
 
 
    template<typename T>
    inline Ref<T> make_ref(T* ptr) noexcept {
        return Ref<T>(ptr);
    }
 
 
    template<typename S, typename T>
    inline Ref<S> make_ref_as(T* ptr) noexcept {
        return Ref<S>(static_cast<S*>(ptr));
    }
 
 
    template<typename T>
    inline Ref<T> acquire(T* ptr) noexcept {
        Ref<T> ref;
        ref.acquire(ptr);
        return ref;
    }
 
 
    template<typename S, typename T>
    inline Ref<S> acquire_as(T* ptr) noexcept {
        Ref<S> ref;
        ref.acquire(static_cast<S*>(ptr));
        return ref;
    }
}