Box.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 "Forward.hpp"
 
#include "MetaError.hpp"
#include "Type.hpp"
#include "IReflectable.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Logging.hpp"
#include "CeresEngine/Foundation/ScopeExit.hpp"
#include "CeresEngine/Foundation/Container/SmallVector.hpp"
 
#include <cassert>
 
namespace CeresEngine {
 
    class TypeInfo;
    class Type;
 
    class MetaArgument;
 
    namespace internal {
        template<typename T>
        using is_class_ptr = std::conditional_t<std::is_pointer_v<std::remove_reference_t<T>> && std::is_class_v<std::remove_pointer_t<std::remove_reference_t<T>>>,
            std::true_type, std::false_type>;
        template<typename T> using is_class_ptr_t = typename is_class_ptr<T>::type;
        template<typename T> constexpr auto is_class_ptr_v = is_class_ptr_t<T>::value;
    } // namespace internal
 
    class Box {
    private:
        static constexpr const size_t kSmallSize = sizeof(void*) * 2;
 
        union Storage {
            void* ptr;
 
            char buffer[kSmallSize];
 
            explicit Storage() : ptr(nullptr) {}
        };
 
        Storage mStorage;
 
        const TypeInfo* mTypeInfo = nullptr;
 
    public: // Views
        class Array;
 
        class Map;
 
        class Iterable;
 
        class Iterator;
 
        class Pointer;
 
        class WeakPointer;
 
    public:
        Box() noexcept;
 
        Box(const Box& other);
 
        Box& operator=(const Box& other);
 
        Box(Box&& other) noexcept;
 
        Box& operator=(Box&& other) noexcept;
 
        template<typename T> requires(!std::is_same_v<std::decay_t<T>, Box>)
        Box(T&& value);
 
        template<typename T> requires(!std::is_same_v<std::decay_t<T>, Box>)
        Box& operator=(T&& value);
 
        template<typename T>  requires(!std::is_same_v<T, Box>) Box(std::reference_wrapper<T> value);
 
        template<typename T, typename... Args> requires(!std::is_same_v<T, Box>) explicit Box(std::in_place_type_t<T>, Args&&... args);
 
        template<typename T, typename... Args> static Box create(Args&&... args) {
            return Box(std::in_place_type_t<T>{}, std::forward<Args>(args)...);
        }
 
        explicit Box(const void* ptr, const TypeInfo* typeInfo);
 
        ~Box() noexcept;
 
    private:
        friend class Type;
 
    public:
        [[nodiscard]] bool isSmall() const noexcept;
 
        void clear() noexcept;
 
        [[nodiscard]] bool empty() const noexcept;
 
        [[nodiscard]] explicit operator bool() const noexcept { return !empty(); }
 
        friend bool operator==(const Box& lhs, const Box& rhs);
 
        friend bool operator!=(const Box& lhs, const Box& rhs) { return !operator==(lhs, rhs); }
 
#if !CE_COMPILER_MSVC && 0
        template<typename T> requires(!std::is_same_v<T, Box>)
        [[nodiscard]] friend bool operator==(const Box& lhs, const T& rhs) {
            return lhs == Box(std::cref(rhs));
        }
 
        template<typename T> requires(!std::is_same_v<T, Box>)
        [[nodiscard]] friend bool operator!=(const Box* lhs, const T& rhs) {
            return !(lhs == rhs);
        }
#endif
 
        template<typename T> [[nodiscard]] bool eq(const T& value) const;
 
        template<typename T> [[nodiscard]] bool neq(const T& value) const { return !eq(value); }
 
    public: // Type information
        [[nodiscard]] TypeID getTypeID() const noexcept { return getInternalTypeID(); }
 
        [[nodiscard]] Type getType() const noexcept;
 
        [[nodiscard]] Type getClassType() const noexcept;
 
        [[nodiscard]] const Class* getClass() const noexcept;
        [[nodiscard]] const Enum* getMetaEnum() const noexcept;
 
        template<typename T> [[nodiscard]] bool is() const {
            return is(CeresEngine::getType<T>());
        }
 
        [[nodiscard]] bool is(const Type& type) const;
 
    public:
        [[nodiscard]] Box copy() const;
 
    public:
        [[nodiscard]] Box ref() const&;
 
        [[nodiscard]] Box cref() const&;
 
        [[nodiscard]] Box rref() &&;
 
        [[nodiscard]] Box ref() && { return std::move(*this).rref(); }
 
        template<typename T> [[nodiscard]] T& ref() const& {
            using U = std::remove_reference_t<T>;
 
            const TypeID fromID = getInternalTypeID(std::is_const_v<T> ? TypeAttribute::LREF_CONST : TypeAttribute::LREF);
            const TypeID toID = CeresEngine::getTypeID<std::add_lvalue_reference_t<U>>();
 
            U* const result = TypeCastOperation<U>::invoke(*this, fromID, toID);
            return *result;
        }
 
        template<> [[nodiscard]] Box& ref<Box>() const& {
            return const_cast<Box&>(*this);
        }
 
        template<typename T> [[nodiscard]] T&& ref() && { return std::move(*this).rref<T>(); }
 
        template<> [[nodiscard]] Box&& ref<Box>() && {
            return std::move(*this);
        }
 
        template<typename T> [[nodiscard]] const T& cref() const { return ref<std::add_const_t<std::remove_reference_t<T>>>(); }
 
        template<> [[nodiscard]] const Box& cref<Box>() const {
            return *this;
        }
 
        template<typename T> [[nodiscard]] T&& rref() && {
            using U = std::remove_reference_t<T>;
 
            const TypeID fromID = getInternalTypeID(TypeAttribute::RREF);
            const TypeID toID = CeresEngine::getTypeID<std::add_rvalue_reference_t<U>>();
 
            auto* result = TypeCastOperation<U>::invoke(*this, fromID, toID);
            return std::move(*result);
        }
 
        template<> [[nodiscard]] Box&& rref<Box>() && {
            return std::move(*this);
        }
 
        [[nodiscard]] void* data() noexcept { return const_cast<void*>(std::as_const(*this).data()); }
 
        [[nodiscard]] const void* data() const noexcept;
 
        template<typename T> [[nodiscard]] T* data() const {
            using U = std::remove_reference_t<T>;
 
            const TypeID fromID = getInternalTypeID(std::is_const_v<T> ? TypeAttribute::LREF_CONST : TypeAttribute::LREF);
            const TypeID toID = CeresEngine::getTypeID<std::add_lvalue_reference_t<U>>();
            try {
                return TypeCastOperation<U>::invoke(*this, fromID, toID);
            } catch(...) {
                return nullptr;
            }
        }
 
        //        /// Checks if the value held by the variant is convertible to `T`.
        //        /// \tparam T The check conversion.
        //        template<typename T> [[nodiscard]] bool canConvert() {
        //            static_assert(!std::is_reference_v<T>, "Type cannot be reference");
        //
        //            if(is<T>()) {
        //                return true;
        //            }
        //
        //            const TypeID fromID = getInternalTypeID(TypeAttribute::LREF);
        //            const TypeID toID = getTypeID<T>();
        //            if(Type::hasConverter(fromID, toID)) {
        //                return true;
        //            }
        //
        //            return false;
        //        }
 
        template<typename T> [[nodiscard]] bool canConvert() const {
            static_assert(!std::is_reference_v<T>, "Type cannot be reference");
 
            if(mTypeInfo == nullptr) {
                return false;
            }
 
            if(is<T>()) {
                return true;
            }
 
            const TypeID toID = CeresEngine::getTypeID<T>();
            return canConvert(toID);
        }
 
        [[nodiscard]] bool canConvert(const TypeID& target) const { return canConvert(Type(target)); }
 
        [[nodiscard]] bool canConvert(const Type& target) const {
            if(target.mTypeInfo == nullptr) {
                return false;
            }
            return canConvert(*target.mTypeInfo);
        }
 
        [[nodiscard]] bool canConvert(const TypeInfo& target) const;
 
        template<typename T> [[nodiscard]] T to() const& {
            static_assert(!std::is_reference_v<T>, "Type cannot be reference");
 
            std::aligned_storage_t<sizeof(T), alignof(T)> buffer;
 
            const TypeID typeID = getInternalTypeID(TypeAttribute::LREF_CONST);
            TypeConversionOperation<T>::invoke(*this, typeID, &buffer);
            CE_SCOPE_EXIT { reinterpret_cast<T*>(&buffer)->~T(); };
            return std::move(*reinterpret_cast<T*>(&buffer));
        }
 
        template<> [[nodiscard]] Box to<Box>() const& {
            return *this;
        }
 
        [[nodiscard]] Box to(const TypeID& target) const { return to(Type(target)); }
 
        [[nodiscard]] Box to(const Type& target) const {
            if(target.mTypeInfo == nullptr) {
                return nullptr;
            }
            return to(*target.mTypeInfo);
        }
 
        [[nodiscard]] Box to(const TypeInfo& target) const;
 
        template<typename T> void convert() { *this = to<T>(); }
 
        template<typename T> [[nodiscard]] bool tryConvert() {
            try {
                *this = to<T>();
                return true;
            } catch(...) {
                return false;
            }
        }
 
    private:
        void* cast();
 
    public: // Views
        [[nodiscard]] Iterable asIterable() const&;
        [[nodiscard]] Iterable asIterable() &&;
 
        [[nodiscard]] Iterator asIterator() const&;
        [[nodiscard]] Iterator asIterator() &&;
 
        [[nodiscard]] Array asArray() const&;
        [[nodiscard]] Array asArray() &&;
 
        [[nodiscard]] Map asMap() const&;
        [[nodiscard]] Map asMap() &&;
 
        [[nodiscard]] Pointer asPointer() const&;
        [[nodiscard]] Pointer asPointer() &&;
 
    private:
        [[nodiscard]] void* storage() noexcept { return const_cast<void*>(std::as_const(*this).storage()); }
 
        [[nodiscard]] const void* storage() const noexcept { return isSmall() ? mStorage.buffer : mStorage.ptr; }
 
        friend struct std::hash<CeresEngine::Box>;
        friend void swap(Box&, Box&) noexcept;
        friend class MetaArgument;
 
        void* allocate(const TypeInfo* typeInfo);
        void destroy();
 
        void swap(Box& other) noexcept;
 
        [[nodiscard]] TypeID getInternalTypeID(TypeAttribute attr = TypeAttribute::NONE) const noexcept;
 
        [[nodiscard]] ClassInfo getClassInfo() const noexcept;
 
        template<typename T> struct TypeCheckOperation;
 
        template<typename T> struct TypeCastOperation;
 
        template<typename T> struct TypeConversionOperation;
    };
 
    inline void swap(Box& lhs, Box& rhs) noexcept { lhs.swap(rhs); }
 
    // template<typename T> struct Box::TypeCheckOperation {
    // public:
    //     /// Performs the variant type check operaton.
    //     /// \param self     The variant to perform a type check against.
    //     /// \param typeID   The type to check.
    //     static bool invoke(const Box& self, const TypeID typeID) {
    //         using Decay = full_decay<T>;
    //         using C = std::remove_pointer_t<Decay>;
    //
    //         if(self.empty()) {
    //             return false;
    //         }
    //
    //         const Type from = Type{typeID};
    //         const Type to = Type{CeresEngine::getTypeID<T>()};
    //
    //         if(Type::compatible(from, to) && from.getDecayTypeID() == to.getDecayTypeID()) {
    //             return true;
    //         }
    //
    //         if constexpr(std::is_class_v<Decay> || internal::is_class_ptr_v<Decay>) {
    //             const Class* const fromClass = self.getClassType().getClass();
    //             const Class* const toClass = Class::find(CeresEngine::getTypeID<C>());
    //             if(fromClass == nullptr || toClass == nullptr) {
    //                 return false;
    //             }
    //
    //             return fromClass->inheritedFrom(toClass);
    //         }
    //
    //         return false;
    //     }
    // };
 
    namespace impl {
        [[nodiscard]] const void* castInternal(const Box& self, const Type& type);
    }
 
    template<typename T> struct Box::TypeCastOperation {
    private:
        using Decay = full_decay<T>;
        using C = std::remove_pointer_t<Decay>;
        using tag_t = std::conditional_t<std::is_class_v<Decay>, std::integral_constant<int, 1>,
            std::conditional_t<internal::is_class_ptr_v<Decay>, std::integral_constant<int, 2>, std::integral_constant<int, 0>>>;
 
    public:
        [[nodiscard]] static T* invoke(const Box& self, const TypeID fromID, const TypeID toID) {
            using namespace std::literals;
 
            if(self.empty()) {
                throw BadMetaValueCast("Box is empty");
            }
 
            const Decay* result = nullptr;
 
            const Type from = Type{fromID};
            const Type to = Type{toID};
            if(Type::compatible(from, to)) {
                if(from.getDecayTypeID() == to.getDecayTypeID()) {
                    result = static_cast<const Decay*>(self.data());
                } else if(const void* const ptr = cast(self, from, tag_t{})) {
                    result = static_cast<const Decay*>(ptr);
                }
            }
 
            if(!result) {
                result = static_cast<const Decay*>(self.data());
                info("{0} -> {1}", from.getTypeName(), to.getTypeName());
                throw BadMetaValueCast("Incompatible types: {} -> {}", from.getTypeName(), to.getTypeName());
            }
 
            if constexpr(std::is_array_v<T>) {
                return reinterpret_cast<T*>(*result);
            } else {
                return const_cast<T*>(result);
            }
        }
 
    private:
        // nope
        [[nodiscard]] static const void* cast(const Box&, Type, std::integral_constant<int, 0>) { return nullptr; }
 
        // class
        [[nodiscard]] static const void* cast(const Box& self, const Type from, std::integral_constant<int, 1>) {
            return from.isClass() ? impl::castInternal(self, CeresEngine::getType<T>()) : nullptr;
        }
 
        // class ptr
        [[nodiscard]] static const void* cast(const Box& self, const Type from, std::integral_constant<int, 2>) {
            if(!from.isClassPtr()) {
                return nullptr;
            }
 
            const void* const ptr = impl::castInternal(self, CeresEngine::getType<T>());
            if(ptr == nullptr) {
                return nullptr;
            }
 
            if(ptr != self.mStorage.ptr) {
                throw BadMetaValueCast("Reference to sub-object pointers isn't supported");
            }
 
            return &self.mStorage.ptr;
        }
    };
 
    template<typename T> struct Box::TypeConversionOperation {
        static_assert(!std::is_array_v<T>, "Array types aren't supported");
 
        static void invoke(const Box& self, const TypeID typeID, void* const buffer) {
            CE_ASSERT(buffer != nullptr);
            if(self.empty()) {
                throw BadMetaValueConvert("Box is empty");
            }
 
            const Type from(typeID);
            const Type to(CeresEngine::getTypeID<T>());
            if(Type::compatible(from, to)) {
                if(from.getDecayTypeID() == to.getDecayTypeID()) {
                    to.copyConstruct(self.data(), buffer);
                    return;
                } else if(cast(self, from, to, buffer, tag_t{})) {
                    return;
                }
            }
 
            if(Type::convert(self.data(), from, buffer, to)) {
                return;
            }
 
            throw BadMetaValueConvert("Incompatible types: {0} -> {1}", from.getTypeName(), to.getTypeName());
        }
 
    private:
        using Decay = full_decay<T>;
        using C = std::remove_pointer_t<Decay>;
        using tag_t = std::conditional_t<std::is_class_v<Decay>, std::integral_constant<int, 1>,
            std::conditional_t<internal::is_class_ptr_v<Decay>, std::integral_constant<int, 2>, std::integral_constant<int, 0>>>;
 
        // nope
        [[nodiscard]] static bool cast(const Box&, Type, Type, void*, std::integral_constant<int, 0>) { return false; }
 
        // class
        [[nodiscard]] static bool cast(const Box& self, const Type from, const Type to, void* buffer, std::integral_constant<int, 1>) {
            if(from.isClass()) {
                if(const auto ptr = impl::castInternal(self, CeresEngine::getType<T>())) {
                    to.copyConstruct(ptr, buffer);
                    return true;
                }
            }
            return false;
        }
 
        // class ptr
        [[nodiscard]] static bool cast(const Box& self, const Type from, const Type to, void* buffer, std::integral_constant<int, 2>) {
            if(from.isClassPtr()) {
                if(const auto ptr = impl::castInternal(self, CeresEngine::getType<T>())) {
                    to.copyConstruct(&ptr, buffer);
                    return true;
                }
            }
            return false;
        }
    };
 
    template<typename T> requires(!std::is_same_v<std::decay_t<T>, Box>)
    Box::Box(T&& value) {
        using Type = std::remove_reference_t<T>;
        const TypeInfo& typeInfo = GetTypeInfo<Type>::get();
        new(allocate(&typeInfo)) Type(std::forward<T>(value));
    }
 
    template<typename T> requires(!std::is_same_v<std::decay_t<T>, Box>)
    Box& Box::operator=(T&& value) {
        using Type = std::remove_reference_t<T>;
        const TypeInfo& typeInfo = GetTypeInfo<Type>::get();
        new(allocate(&typeInfo)) Type(std::forward<T>(value));
        return *this;
    }
 
    template<typename T>  requires(!std::is_same_v<T, Box>) Box::Box(std::reference_wrapper<T> value) {
        // NOTE: Reference types are cosntructed by storing a raw-pointer to the
        //  type. This is embedded in the semantics of the TypeInfo for
        //  reference types.
        const TypeInfo& typeInfo = GetTypeInfo<T&>::get();
        new(allocate(&typeInfo)) T*(&value.get());
    }
 
    template<typename T, typename... Args> requires(!std::is_same_v<T, Box>) Box::Box(std::in_place_type_t<T>, Args&&... args) {
        using Type = std::remove_reference_t<T>;
        const TypeInfo& typeInfo = GetTypeInfo<Type>::get();
        new(allocate(&typeInfo)) T(std::forward<Args>(args)...);
    }
 
    template<typename T> bool Box::eq(const T& value) const {
        if(*this == Box{std::cref(value)})
            return true;
 
        const auto mt_self = Type{getInternalTypeID(TypeAttribute::NONE)};
        const auto mt_value = Type{CeresEngine::getTypeID<T>()};
 
        if(Type::hasConverter(mt_self, mt_value)) {
            std::aligned_storage_t<sizeof(T), alignof(T)> buffer;
            if(Type::convert(data(), mt_self, &buffer, mt_value)) {
                CE_SCOPE_EXIT { reinterpret_cast<T*>(&buffer)->~T(); };
                return value == *reinterpret_cast<const T*>(&buffer);
            }
        }
 
        if(Type::hasConverter(mt_value, mt_self)) {
            auto* buffer = mt_self.allocate();
            CE_SCOPE_EXIT { mt_self.deallocate(buffer); };
 
            // Array is passed as **data
            auto tmp = std::addressof(value);
            const void* address = tmp;
            if(mt_value.isArray())
                address = std::addressof(tmp);
 
            if(Type::convert(address, mt_value, buffer, mt_self)) {
                CE_SCOPE_EXIT { mt_self.destroy(buffer); };
                auto ptr = data();
                if(mt_self.isArray())
                    ptr = *reinterpret_cast<const void* const*>(ptr);
                return mt_self.compareEquality(ptr, buffer);
            }
        }
 
        return false;
    }
 
    template<typename T> Box box(T& value) { return Box(std::ref(value)); }
 
    template<typename T> Box box(const T& value) { return Box(std::cref(value)); }
 
    template<typename T> Box box(T&& value) { return Box(std::forward<T>(value)); }
 
    // ---------------------------------------------------------------------------------------------
 
    class Box::Pointer : public Box {
        using super = Box;
 
    public:
        using super::Box;
 
        CE_EXPLICIT(false) Pointer(const Box& other) : super(other) {}
        CE_EXPLICIT(false) Pointer(Box&& other) noexcept : super(std::move(other)) {}
 
        Pointer(const Pointer&) = default;
        Pointer& operator=(const Pointer&) = default;
        Pointer(Pointer&&) noexcept = default;
        Pointer& operator=(Pointer&&) noexcept = default;
 
        static bool is(const Box& value) noexcept;
 
    public:
        [[nodiscard]] Box get() const;
 
        [[nodiscard]] Box operator*() const;
 
        [[nodiscard]] Box operator->() const;
    };
 
    // ---------------------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------------------
 
    [[nodiscard]] Box dereference(Box&& value);
    [[nodiscard]] Box dereference(const Box& value);
 
    template<typename T> [[nodiscard]] Box dereference(Box&& value) { return dereference(std::forward<Box>(value)).ref<T>(); }
 
    template<typename T> [[nodiscard]] Box dereference(const Box& value) { return dereference(value).ref<T>(); }
 
    template<> struct GetTypeInfo<Box> {
        static const TypeInfo& get();
    };
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::Box> {
    using BoxType = CeresEngine::Box;
    [[nodiscard]] std::size_t operator()(const BoxType& value) const noexcept;
};