Ref.h

#pragma once

#include <cassert>
#include <type_traits>

#include <fsdk/Types/RefBase.h>
#include <fsdk/Def.h>

namespace fsdk
{
#ifndef DOXYGEN_SHOULD_SKIP_THIS

    /* Forward declarations. */
    template<typename T> struct WeakRef;

#endif /* DOXYGEN_SHOULD_SKIP_THIS */

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

        Ref() noexcept = default;

        Ref(std::nullptr_t) noexcept {}

        FSDK_DEPRECATED("construction from raw pointer is deprecated, use make_ref function instead")
        explicit Ref(T* ptr) noexcept { *this = ptr; }

        Ref(const Ref& other) : RefBase<T>() { *this = other; }

        template<class D, typename = typename std::enable_if<std::is_convertible<D*, T*>::value>::type>
        explicit Ref(const Ref<D>& other) : RefBase<T>() { *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 {
            assign(other.get());
            return *this;
        }

        template<class D, typename = typename std::enable_if<std::is_convertible<D*, T*>::value>::type>
        Ref& operator = (const Ref<D>& other) noexcept {
            assign(other.get());
            return *this;
        }

        FSDK_DEPRECATED("Assignment from raw pointer is deprecated, use make_ref function instead")
        Ref& operator = (T* ptr) noexcept {
            assign(ptr);
            return *this;
        }

        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(this->get())
                    this->get()->retain();
            }

            return *this;
        }

        Ref& acquire(T* ptr) noexcept {
            if(this->get() != ptr)
            {
                if(this->get())
                    this->get()->release();

                this->set(ptr);
            }

            return *this;
        }

        Ref& make_ref(T* ptr) noexcept {
            return assign(ptr);
        }

        T* reset() noexcept {
            T* ptr = this->get();
            assign(nullptr);
            return ptr;
        }

        template<typename S> Ref<S> as() const noexcept {
            Ref<S> ref;
            ref.make_ref(static_cast<S*>(this->get()));
            return ref;
        }
    };


    template<typename T>
    inline Ref<T> make_ref(T* ptr) noexcept {
        Ref<T> ref;
        ref.make_ref(ptr);
        return ref;
    }


    template<typename S, typename T>
    inline Ref<S> make_ref_as(T* ptr) noexcept {
        Ref<T> ref;
        ref.make_ref(ptr);
        return ref.template as<S>();
    }


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