Ref.h

#pragma once

#include <cassert>
#include <type_traits>
#include <utility>

#include <fsdk/Def.h>
#include <fsdk/Types/RefBase.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;
        }

        Ref(Ref&& other) noexcept
            : RefBase<T>() {
            move(std::move(other));
        }

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

        Ref& operator=(Ref&& other) noexcept {
            return move(std::move(other));
        }

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

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

        template <class D, typename = typename std::enable_if<std::is_convertible<D*, T*>::value>::type>
        Ref& move(Ref<D>&& other) noexcept {
            auto* ptr = other.get();
            if(this->get() != ptr) {
                if(this->get())
                    this->get()->release();

                this->set(ptr);

                if(ptr) {
                    other.set(nullptr);
                }
            }

            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;
    }
} // namespace fsdk