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