SmartPtr.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/Container/Atomic.hpp"
 
#include <atomic>
#include <memory>
#include <type_traits>
#ifndef NDEBUG
#include <cstring>
#endif
 
namespace CeresEngine {
 
    template<typename T, typename Deleter = std::default_delete<T>> using UPtr = std::unique_ptr<T, Deleter>;
 
    template<typename T> using SPtr = std::shared_ptr<T>;
 
    template<typename T> using WPtr = std::weak_ptr<T>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, typename... Args> [[nodiscard]] inline constexpr T* ce_new(Args&&... args) { // NOLINT
        return new T(std::forward<Args>(args)...);
    }
 
    template<typename T, typename... Args> [[nodiscard]] inline constexpr UPtr<T> ce_unique_new(Args&&... args) { // NOLINT
        return std::make_unique<T>(std::forward<Args>(args)...);
    }
 
    template<typename T, typename RawAllocator, typename... Args>
    [[nodiscard]] inline constexpr UPtr<T, AllocatorDeleter<T, RawAllocator>> ce_unique_alloc(RawAllocator& allocator, Args&&... args) { // NOLINT
        using PtrGuard = UPtr<T, AllocatorDeallocator<T, RawAllocator>>;
 
        // RawPtr deallocates memory in case of constructor exception
        void* const memory = allocator.allocate_node(sizeof(T), alignof(T));
        PtrGuard result(static_cast<T*>(memory), {allocator});
 
        // Call constructor
        ::new(memory) T(std::forward<Args>(args)...);
 
        // Pass ownership to return value using a deleter that calls destructor
        return {result.release(), {allocator}};
    }
 
    template<typename T, typename... Args> [[nodiscard]] inline constexpr SPtr<T> ce_shared_new(Args&&... args) { // NOLINT
        return std::make_shared<T>(std::forward<Args>(args)...);
    }
 
    template<typename T, typename Allocator, typename... Args>
    [[nodiscard]] inline constexpr SPtr<T> ce_shared_alloc(Allocator& allocator,
        Args&&... args) { // NOLINT
        return std::allocate_shared<T>(make_std_allocator(make_allocator_reference(allocator)), std::forward<Args>(args)...);
    }
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    template<bool ThreadSafe> class RefCounter;
 
    template<typename T, typename Counter = RefCounter<true>, typename Deleter = std::default_delete<T>> class RefCounted;
 
    template<typename T, bool = true> struct CountedPtrTrait;
 
    static const constexpr struct AdoptPtrT {
    } adoptPtr;
 
    // and `release` pair of methods.
    template<typename T>
    concept IntrusiveReferenceCountable = requires(T* ptr) {
                                              ptr->retain();
                                              ptr->release();
                                          };
 
    template<typename T>
    concept ReferenceCountable = requires(T* ptr) {
                                     CountedPtrTrait<T>::retain(ptr);
                                     CountedPtrTrait<T>::release(ptr);
                                 };
 
    template<typename T> class CountedPtr final {
        template<typename TT> friend class CountedPtr;
 
        using Trait = CountedPtrTrait<T>;
 
    public:
        using ElementType = T;
 
        using Pointer = T*;
 
        using Reference = T&;
 
    private:
        Pointer ptr = nullptr;
 
    public:
        CountedPtr() noexcept = default;
 
        CountedPtr(const Pointer ptr) noexcept { set(ptr); }
 
        CountedPtr(std::nullptr_t) noexcept { set(nullptr); }
 
        CountedPtr(AdoptPtrT, const Pointer aPtr) noexcept : ptr(aPtr) {}
 
        CountedPtr(const CountedPtr& other) noexcept : CountedPtr(other.ptr) {}
 
        template<typename U> CountedPtr(const CountedPtr<U>& other) noexcept : CountedPtr(other.ptr) {}
 
        CountedPtr& operator=(const CountedPtr& other) noexcept { // NOLINT(cert-oop54-cpp)
            set(other.ptr);
            return *this;
        }
 
        template<typename U> CountedPtr& operator=(const CountedPtr<U>& other) noexcept {
            set(other.ptr);
            return *this;
        }
 
        CountedPtr(CountedPtr&& other) noexcept : ptr(std::exchange(other.ptr, nullptr)) { }
 
        template<typename U> CountedPtr(CountedPtr<U>&& other) noexcept : ptr(std::exchange(other.ptr, nullptr)) { // NOLINT
        }
 
        CountedPtr& operator=(CountedPtr&& other) noexcept {
            if(other.ptr == ptr) {
                return *this;
            }
 
            reset();
            ptr = std::exchange(other.ptr, nullptr);
            return *this;
        }
 
        template<typename U> CountedPtr& operator=(CountedPtr<U>&& other) noexcept {
            if(other.ptr == ptr) {
                return *this;
            }
 
            reset();
            ptr = std::exchange(other.ptr, nullptr);
 
            return *this;
        }
 
        template<typename U> CountedPtr& operator=(U* aPtr) noexcept {
            if(aPtr == ptr) {
                return *this;
            }
 
            set(aPtr);
            return *this;
        }
 
        ~CountedPtr() noexcept { reset(); }
 
    public:
        [[nodiscard]] Pointer get() const noexcept { return ptr; }
 
        [[nodiscard]] Pointer operator->() const noexcept { return ptr; }
 
        [[nodiscard]] Reference operator*() const noexcept { return *ptr; }
 
        [[nodiscard]] explicit operator bool() const noexcept { return ptr != nullptr; }
 
        void reset() noexcept { set(nullptr); }
 
        [[nodiscard]] Pointer release() noexcept {
            // NOTE: no ref count decrement
            return std::exchange(ptr, nullptr);
        }
 
    public:
        static CountedPtr<T> adopt(T* const ptr) { return {adoptPtr, ptr}; }
 
    private:
        void set(Pointer newPtr) noexcept {
            if(newPtr == ptr) {
                return;
            }
 
            if(ptr) {
                Trait::release(ptr);
            }
 
            ptr = newPtr;
            if(ptr) {
                Trait::retain(ptr);
            }
        }
 
    public:
        using Counted = RefCounted<T>;
 
    public:
        template<typename U1, typename U2> friend inline bool operator==(const CountedPtr<U1>& a, const CountedPtr<U2>& b) noexcept;
 
        template<typename U1, typename U2> friend inline bool operator!=(const CountedPtr<U1>& a, const CountedPtr<U2>& b) noexcept;
 
        template<typename U1, typename U2> friend inline bool operator==(const CountedPtr<U1>& a, const U2* b) noexcept;
 
        template<typename U1, typename U2> friend inline bool operator!=(const CountedPtr<U1>& a, const U2* b) noexcept;
 
        template<typename U1, typename U2> friend inline bool operator==(const U1* a, const CountedPtr<U2>& b) noexcept;
 
        template<typename U1, typename U2> friend inline bool operator!=(const U1* a, const CountedPtr<U2>& b) noexcept;
 
        template<typename U> friend inline bool operator==(const CountedPtr<U>& a, std::nullptr_t) noexcept;
 
        template<typename U> friend inline bool operator!=(const CountedPtr<U>& a, std::nullptr_t) noexcept;
    };
 
    // additional deduction guide
    template<typename Pointer> CountedPtr(Pointer) -> CountedPtr<Pointer>;
 
    template<typename T> using RC = CountedPtr<T>;
 
    template<IntrusiveReferenceCountable T> struct CountedPtrTrait<T> {
        static void retain(T* ptr) noexcept { ptr->retain(); }
 
        static void release(T* ptr) noexcept { ptr->release(); }
    };
 
#define CE_RCPTR_TRAIT_DECL(ClassName)                          \
    template<> struct CeresEngine::CountedPtrTrait<ClassName> { \
        static void retain(ClassName* ptr) noexcept;            \
        static void release(ClassName* ptr) noexcept;           \
    };
 
#define CE_RCPTR_TRAIT_DEF(ClassName)                                                                  \
    void ::CeresEngine::CountedPtrTrait<ClassName>::retain(ClassName* ptr) noexcept { ptr->retain(); } \
    void ::CeresEngine::CountedPtrTrait<ClassName>::release(ClassName* ptr) noexcept { ptr->release(); }
 
    // ---------------------------------------------------------------------------------------------
 
    template<ReferenceCountable T> RC<T> ce_counted_adopt(T* const ptr) { // NOLINT
        return RC<T>::adopt(ptr);
    }
 
    template<ReferenceCountable T, typename... Args> RC<T> ce_counted_new(Args&&... args) { // NOLINT
        return new T(std::forward<Args>(args)...);
    }
 
    // ---------------------------------------------------------------------------------------------
 
    template<bool ThreadSafe = true> class RefCounter;
 
    template<> class RefCounter<true> final {
        Atomic<UInt64> mCounter = 0;
 
    public:
        RefCounter() = default;
        explicit RefCounter(const UInt64 initialCount) : mCounter(initialCount) {}
 
    public:
        void increment() noexcept;
 
        [[nodiscard]] bool decrement() noexcept;
    };
 
    template<> class RefCounter<false> final {
        UInt64 mCounter = 0;
 
    public:
        RefCounter() = default;
        explicit RefCounter(const UInt64 initialCount) : mCounter(initialCount) {}
 
    public:
        void increment() noexcept;
 
        [[nodiscard]] bool decrement() noexcept;
    };
 
    template<typename T, typename Counter, typename Deleter> class RefCounted {
        Counter mRefCounter;
 
        Deleter mDeleter;
 
    public:
        template<typename... Args> explicit RefCounted(Args&&... args) : mDeleter(std::forward<Args>(args)...){};
 
    public:
        void retain() noexcept { mRefCounter.increment(); }
 
        bool release() noexcept {
            if(mRefCounter.decrement()) {
                mDeleter(static_cast<T*>(this));
                return true;
            }
            return false;
        }
    };
 
    template<typename T, typename Counter> class RefCounted<T, Counter, std::default_delete<T>> {
        using Deleter = std::default_delete<T>;
 
        Counter mRefCounter;
 
    public:
        void retain() noexcept { mRefCounter.increment(); }
 
        bool release() noexcept {
            if(mRefCounter.decrement()) {
                Deleter{}(static_cast<T*>(this));
                return true;
            }
            return false;
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename U1, typename U2> inline bool operator==(const CountedPtr<U1>& a, const CountedPtr<U2>& b) noexcept { return a.ptr == b.ptr; }
    template<typename U1, typename U2> inline bool operator!=(const CountedPtr<U1>& a, const CountedPtr<U2>& b) noexcept { return a.ptr != b.ptr; }
    template<typename U1, typename U2> inline bool operator==(const CountedPtr<U1>& a, const U2* b) noexcept { return a.ptr == b; }
    template<typename U1, typename U2> inline bool operator!=(const CountedPtr<U1>& a, const U2* b) noexcept { return a.ptr != b; }
    template<typename U1, typename U2> inline bool operator==(const U1* a, const CountedPtr<U2>& b) noexcept { return a == b.ptr; }
    template<typename U1, typename U2> inline bool operator!=(const U1* a, const CountedPtr<U2>& b) noexcept { return a != b.ptr; }
    template<typename U> inline bool operator==(const CountedPtr<U>& a, std::nullptr_t) noexcept { return a.ptr == nullptr; }
    template<typename U> inline bool operator!=(const CountedPtr<U>& a, std::nullptr_t) noexcept { return a.ptr != nullptr; }
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> class CopyOnWritePtr {
        // static_assert(std::is_copy_constructible_v<T>, "T must be copy constructible.");
 
    private:
        struct Data {
            SPtr<T> data;
 
            SPtr<T> (*copy)(const SPtr<T>& other);
 
            explicit Data() = default;
            explicit Data(const SPtr<T>& data, SPtr<T> (*copy)(const SPtr<T>&)) : data(data), copy(copy) {}
 
            Data(const Data&) = default;
            Data& operator=(const Data&) = default;
 
            Data(Data&&) noexcept = default;
            Data& operator=(Data&&) noexcept = default;
        };
 
        Data mData;
 
    public:
        CopyOnWritePtr() = default;
 
        template<typename U>
        CopyOnWritePtr(U&& value) requires(std::is_constructible_v<T, U>)
        : CopyOnWritePtr(std::in_place_type_t<U>{}, std::forward<U>(value)) {}
 
        CE_EXPLICIT(false) CopyOnWritePtr(std::nullptr_t) noexcept {}
 
        CopyOnWritePtr(const CopyOnWritePtr&) noexcept = default;
 
        CopyOnWritePtr& operator=(const CopyOnWritePtr&) noexcept = default;
 
        CopyOnWritePtr(CopyOnWritePtr&&) noexcept = default;
 
        CopyOnWritePtr& operator=(CopyOnWritePtr&&) noexcept = default;
 
    private:
        template<typename U, typename... Args>
        explicit CopyOnWritePtr(std::in_place_type_t<U>, Args&&... args)
                : mData(ce_shared_new<U>(std::forward<Args>(args)...),
                      [](const SPtr<T>& other) -> SPtr<T> { return ce_shared_new<U>(static_cast<const U&>(*other)); }) {}
 
    public:
        [[nodiscard]] bool valid() const noexcept { return mData.data != nullptr; }
 
        [[nodiscard]] explicit operator bool() const noexcept { return valid(); }
 
        [[nodiscard]] const T* get() const noexcept { return mData.data.get(); }
 
        [[nodiscard]] const T& operator*() const noexcept { return *get(); }
 
        [[nodiscard]] const T* operator->() const noexcept { return get(); }
 
        void reset() { mData.data.reset(); }
 
    public: // Write
        template<typename Func> decltype(auto) mutate(Func&& func) {
            makeCopyIfNeeded();
 
            // At this point, we MUST be the only instance of the CoW pointer.
            //
            CE_ASSERT(mData.data.use_count() == 1);
            return func(*mData.data);
        }
 
    private:
        inline void makeCopyIfNeeded() {
            if(mData.data.use_count() == 1) {
                return;
            }
            mData.data = mData.copy(mData.data);
        }
 
    public:
        friend bool operator==(const CopyOnWritePtr& lhs, const CopyOnWritePtr& rhs) noexcept { return lhs.mData.data == rhs.mData.data; }
 
        friend bool operator!=(const CopyOnWritePtr& lhs, const CopyOnWritePtr& rhs) noexcept { return lhs.mData.data != rhs.mData.data; }
 
        friend bool operator==(const CopyOnWritePtr& lhs, std::nullptr_t) noexcept { return lhs.mData.data == nullptr; }
 
        friend bool operator!=(const CopyOnWritePtr& lhs, std::nullptr_t) noexcept { return lhs.mData.data != nullptr; }
 
        friend bool operator==(std::nullptr_t, const CopyOnWritePtr& rhs) noexcept { return nullptr == rhs.mData.data; }
 
        friend bool operator!=(std::nullptr_t, const CopyOnWritePtr& rhs) noexcept { return nullptr != rhs.mData.data; }
 
        template<typename T1, typename U, typename... Args> friend CopyOnWritePtr<T1> ce_cow_new(Args&&... args);
    };
 
    template<typename T> using CoW = CopyOnWritePtr<T>;
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T, typename U = T, typename... Args> [[nodiscard]] CopyOnWritePtr<T> ce_cow_new(Args&&... args) { // NOLINT
        return CopyOnWritePtr<T>(std::in_place_type_t<U>{}, std::forward<Args>(args)...);
    }
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
#define CE_VPTR_TMPL(T) typename T, size_t T##SmallSize
#define CE_VPTR_TYPE(T) ValuePtr<T, T##SmallSize>
 
    template<typename T, size_t SmallSize = sizeof(int*) * 4> class ValuePtr final {
    private:
        struct VTable;
 
        const VTable* vtable = nullptr;
 
        alignas(T) mutable UInt8 raw[SmallSize];
 
    public:
        template<typename U> static constexpr inline bool isSmall = sizeof(U) <= SmallSize;
 
    private:
        struct VTable {
            T* (*get)(void*);
            void (*copy)(void*, const void*);
            void (*move)(void*, void*);
            void (*destroy)(void*);
 
            template<typename TT> static const VTable* create() {
                if constexpr(sizeof(TT) <= SmallSize) {
                    static const VTable vtable{
                        .get = [](void* ptr) -> T* { return reinterpret_cast<TT*>(ptr); },
                        .copy = []() -> decltype(VTable::copy) {
                            if constexpr(std::is_copy_constructible_v<TT>) {
                                return [](void* destination, const void* source) {
                                    new(destination) TT(*reinterpret_cast<const TT*>(source));
                                };
                            }
                            return nullptr;
                        }(),
                        .move = []() -> decltype(VTable::move) {
                            if constexpr(std::is_move_constructible_v<TT>) {
                                return [](void* destination, void* source) {
                                    new(destination) TT(std::move(*reinterpret_cast<TT*>(source)));
                                };
                            }
                            return nullptr;
                        }(),
                        .destroy = [](void* ptr) { reinterpret_cast<TT*>(ptr)->~TT(); },
                    };
                    return &vtable;
                } else {
                    static const VTable vtable{
                        .get = [](void* ptr) -> T* { return *reinterpret_cast<TT**>(ptr); },
                        .copy = []() -> decltype(VTable::copy) {
                            if constexpr(std::is_copy_constructible_v<TT>) {
                                return [](void* destination, const void* source) {
                                    *reinterpret_cast<TT**>(destination) = new TT(**reinterpret_cast<const TT* const*>(source));
                                };
                            }
                            return nullptr;
                        }(),
                        .move =
                            [](void* destination, void* source) { //
                                *reinterpret_cast<TT**>(destination) = std::exchange(*reinterpret_cast<TT**>(source), nullptr);
                            },
                        .destroy = [](void* ptr) { delete *reinterpret_cast<TT**>(ptr); },
                    };
                    return &vtable;
                }
            }
        };
 
    public:
        [[nodiscard]] bool isCopyable() const noexcept { return vtable == nullptr || vtable->copy != nullptr; }
 
        ValuePtr(const ValuePtr& other) : vtable(other.vtable) {
            CE_ASSERT(other.isCopyable());
 
            if(vtable == nullptr) {
                return;
            }
 
            CE_ASSERT(vtable->copy != nullptr);
            vtable->copy(raw, other.raw);
        }
 
        ValuePtr& operator=(const ValuePtr& other) { // NOLINT(bugprone-unhandled-self-assignment,cert-oop54-cpp)
            CE_ASSERT(other.isCopyable());
 
            // If both objects are pointing to the same object, no need to do
            // anything. Just return.
            //
            if(other.get() == get()) {
                return *this;
            }
 
            reset();
            vtable = other.vtable;
            if(vtable != nullptr) {
                CE_ASSERT(vtable->copy != nullptr);
                vtable->copy(raw, other.raw);
            }
 
            return *this;
        }
 
        [[nodiscard]] bool isMovable() const noexcept { return vtable == nullptr || vtable->move != nullptr; }
 
        ValuePtr(ValuePtr&& other) noexcept : vtable(other.vtable) {
            CE_ASSERT(other.isMovable());
 
            if(vtable == nullptr) {
                return;
            }
 
            CE_ASSERT(vtable->move != nullptr);
            vtable->move(raw, other.raw);
        }
 
        ValuePtr& operator=(ValuePtr&& other) { // NOLINT
            CE_ASSERT(other.isMovable());
 
            // If both objects are pointing to the same object, no need to do
            // anything. Just return.
            //
            if(other.get() == get()) {
                return *this;
            }
 
            reset();
 
            vtable = other.vtable;
            if(vtable != nullptr) {
                CE_ASSERT(vtable->move != nullptr);
                vtable->move(raw, other.raw);
            }
 
            return *this;
        }
 
        ValuePtr(std::nullptr_t) noexcept : vtable(nullptr) {} // NOLINT
 
        ValuePtr& operator=(std::nullptr_t) noexcept {
            reset();
            return *this;
        }
 
        ~ValuePtr() noexcept { reset(); }
 
    private:
        template<typename TT> struct ConstructTag {};
 
        template<typename TT, typename... Args, typename = std::enable_if_t<std::is_convertible_v<TT*, T*> && std::is_constructible_v<TT, Args...>>>
        explicit ValuePtr(ConstructTag<TT>, Args&&... args) {
            emplace<TT>(std::forward<Args>(args)...);
        }
 
    public:
        template<bool B = std::is_default_constructible_v<T>&& std::is_copy_constructible_v<T>, typename = std::enable_if_t<B>>
        ValuePtr() noexcept : ValuePtr(ConstructTag<T>{}) {}
 
        template<typename... Args, typename = std::enable_if_t<std::is_constructible_v<T, Args...>>>
        explicit ValuePtr(Args&&... args) : ValuePtr(ConstructTag<T>{}, std::forward<Args>(args)...) {}
 
        template<typename TT> requires(std::is_convertible_v<TT*, T*>)
        ValuePtr(TT object) // NOLINT
                : ValuePtr(ConstructTag<TT>{}, std::forward<TT>(object)) {}
 
        template<typename TT, typename... Args, typename = std::enable_if_t<std::is_constructible_v<TT, Args...>>> TT& emplace(Args&&... args) {
            reset();
 
            vtable = VTable::template create<TT>();
            CE_ASSERT(vtable != nullptr);
 
            if constexpr(sizeof(TT) <= SmallSize) {
                new(raw) TT(std::forward<Args>(args)...);
            } else {
                *reinterpret_cast<TT**>(raw) = new TT(std::forward<Args>(args)...);
            }
 
            return static_cast<TT&>(*get());
        }
 
    public: // Public interface
        [[nodiscard]] bool valid() const { return vtable != nullptr; }
 
        [[nodiscard]] bool empty() const { return vtable == nullptr; }
 
        [[nodiscard]] T* get() const { return vtable == nullptr ? nullptr : vtable->get(raw); }
 
        void reset() {
            if(vtable == nullptr) {
                return;
            }
 
            CE_ASSERT(vtable->destroy != nullptr);
            vtable->destroy(raw);
            vtable = nullptr;
#ifndef NDEBUG
            std::memset(raw, 0x00, sizeof(raw));
#endif
        }
 
        explicit operator bool() const { return vtable != nullptr; }
 
        T* operator->() const { return get(); }
 
        T& operator*() const { return *get(); }
 
    public:
        template<typename... Args> static ValuePtr<T, SmallSize> create(Args&&... args) { return ValuePtr<T, SmallSize>(std::forward<Args>(args)...); }
 
        template<typename U, typename... Args> static ValuePtr<T, SmallSize> create(Args&&... args) {
            return ValuePtr<T, SmallSize>(ConstructTag<U>{}, std::forward<Args>(args)...);
        }
    };
 
    template<CE_VPTR_TMPL(T), CE_VPTR_TMPL(U)> bool operator==(const CE_VPTR_TYPE(T) & lhs, const CE_VPTR_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) == *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), typename U> bool operator==(const CE_VPTR_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) == rhs;
    }
 
    template<typename U, CE_VPTR_TMPL(T)> bool operator==(const U& lhs, const CE_VPTR_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs == *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), CE_VPTR_TMPL(U)> bool operator!=(const CE_VPTR_TYPE(T) & lhs, const CE_VPTR_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return true;
        }
        if(rhs.get() == nullptr) {
            return true;
        }
        return *(lhs.get()) != *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), typename U> bool operator!=(const CE_VPTR_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return true;
        }
        return *(lhs.get()) != rhs;
    }
 
    template<typename U, CE_VPTR_TMPL(T)> bool operator!=(const U& lhs, const CE_VPTR_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return true;
        }
        return lhs != *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), CE_VPTR_TMPL(U)> bool operator>(const CE_VPTR_TYPE(T) & lhs, const CE_VPTR_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) > *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), typename U> bool operator>(const CE_VPTR_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) > rhs;
    }
 
    template<typename U, CE_VPTR_TMPL(T)> bool operator>(const U& lhs, const CE_VPTR_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs > *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), CE_VPTR_TMPL(U)> bool operator>=(const CE_VPTR_TYPE(T) & lhs, const CE_VPTR_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) >= *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), typename U> bool operator>=(const CE_VPTR_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) >= rhs;
    }
 
    template<typename U, CE_VPTR_TMPL(T)> bool operator>=(const U& lhs, const CE_VPTR_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs >= *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), CE_VPTR_TMPL(U)> bool operator<(const CE_VPTR_TYPE(T) & lhs, const CE_VPTR_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) < *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), typename U> bool operator<(const CE_VPTR_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) < rhs;
    }
 
    template<typename U, CE_VPTR_TMPL(T)> bool operator<(const U& lhs, const CE_VPTR_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs < *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), CE_VPTR_TMPL(U)> bool operator<=(const CE_VPTR_TYPE(T) & lhs, const CE_VPTR_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) <= *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T), typename U> bool operator<=(const CE_VPTR_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) <= rhs;
    }
 
    template<typename U, CE_VPTR_TMPL(T)> bool operator<=(const U& lhs, const CE_VPTR_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs <= *(rhs.get());
    }
 
    template<CE_VPTR_TMPL(T)> bool operator==(const CE_VPTR_TYPE(T) & lhs, std::nullptr_t) noexcept { return lhs.get() == nullptr; }
 
    template<CE_VPTR_TMPL(T)> bool operator!=(const CE_VPTR_TYPE(T) & lhs, std::nullptr_t) noexcept { return lhs.get() != nullptr; }
 
#undef CE_VPTR_TMPL
#undef CE_VPTR_TYPE
 
    template<typename T, size_t SmallSize = sizeof(int*) * 3> using VPtr = ValuePtr<T, SmallSize>;
 
} // namespace CeresEngine
 
template<typename T> struct std::hash<CeresEngine::CountedPtr<T>> {
    using Type = CeresEngine::CountedPtr<T>;
    inline size_t operator()(const Type& obj) const noexcept { return std::hash<T*>{}(obj.get()); }
};