Ref.h

#pragma once

#include "RefBase.h"

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;
    }
}