Type.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 "TypeName.hpp"
#include "TypeInfo.hpp"
 
#include "CeresEngine/Concepts.hpp"
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
#include "CeresEngine/Foundation/TypeTraits.hpp"
 
namespace CeresEngine {
 
    namespace internal {
        struct ConvertFunctionBase;
    } // namespace internal
 
    using TypeIdentityHash = UInt64;
 
    class Type final {
    private:
        const TypeInfo* mTypeInfo = nullptr;
 
    public:
        Type() noexcept = default;
        explicit Type(const TypeInfo& typeInfo) : mTypeInfo(&typeInfo) {}
 
        explicit Type(StringView name) noexcept;
 
        [[nodiscard]] static Type fromName(StringView name) noexcept;
 
        explicit Type(TypeID typeID) noexcept;
 
        [[nodiscard]] static Type fromID(TypeID id) noexcept;
 
    public:
        [[nodiscard]] TypeID getTypeID() const noexcept;
 
        [[nodiscard]] StringView getTypeName() const noexcept;
 
        [[nodiscard]] StringView getName() const noexcept { return getTypeName(); }
 
        [[nodiscard]] std::size_t getTypeSize() const noexcept;
 
        [[nodiscard]] std::align_val_t getTypeAlignment() const noexcept;
 
        [[nodiscard]] TypeIdentityHash getIdentityHash() const noexcept;
 
    public: // Associated types
        [[nodiscard]] bool isDecayed() const noexcept { return isValid() && (getTypeID() == getDecayTypeID()); }
 
        [[nodiscard]] Type getDecayType() const noexcept;
 
        [[nodiscard]] TypeID getDecayTypeID() const noexcept;
 
        [[nodiscard]] Type getUnderlyingType() const noexcept;
 
        [[nodiscard]] TypeID getUnderlyingTypeID() const noexcept;
 
    public: // Type flags
        [[nodiscard]] bool isConst() const noexcept;
 
        [[nodiscard]] bool isLvalueReference() const noexcept;
 
        [[nodiscard]] bool isRvalueReference() const noexcept;
 
        [[nodiscard]] bool isReference() const noexcept;
 
        [[nodiscard]] bool isClass() const noexcept;
 
        [[nodiscard]] bool isPointer() const noexcept;
 
        [[nodiscard]] bool isVoidPtr() const noexcept;
 
        [[nodiscard]] bool isClassPtr() const noexcept;
 
        [[nodiscard]] bool isFunctionPtr() const noexcept;
 
        [[nodiscard]] bool isArray() const noexcept;
 
        [[nodiscard]] uint16_t getPointerArity() const noexcept;
 
    public: // Meta interface
        template<typename T> [[nodiscard]] bool is() const;
 
        template<typename T> [[nodiscard]] const T* as() const;
 
        [[nodiscard]] const Class* getClass() const noexcept;
 
        [[nodiscard]] const Enum* getMetaEnum() const noexcept;
 
    public: // Type conversion
        [[nodiscard]] static bool compatible(Type fromType, Type toType) noexcept;
 
        [[nodiscard]] bool compatible(const Type& other) const noexcept { return compatible(*this, other); }
 
        template<typename T> [[nodiscard]] bool compatible() const noexcept;
 
        [[nodiscard]] static bool hasConverter(Type fromType, Type toType) noexcept;
 
        [[nodiscard]] static bool hasConverter(TypeID fromTypeID, TypeID toTypeID) noexcept;
 
        template<typename From, typename To> [[nodiscard]] static bool hasConverter() noexcept;
 
        template<typename From, typename To, typename Func> static bool registerConverter(Func&& func);
        template<typename From, typename To> static bool registerConverter(To (*func)(From));
        template<typename From, typename To> static bool registerConverter();
        template<typename From, typename To> static bool registerConverter(To (From::*func)() const);
        template<typename From, typename To> static bool registerConverter(To (From::*func)(bool&) const);
 
        static void unregisterConverter(TypeID fromTypeID, TypeID toTypeID);
        template<typename From, typename To> static void unregisterConverter();
 
    public:
        [[nodiscard]] Box construct() const;
 
        void destruct(void* instance) const;
 
    public:
        [[nodiscard]] bool isValid() const noexcept { return (mTypeInfo != nullptr); }
 
        [[nodiscard]] explicit operator bool() const noexcept { return isValid(); }
 
        [[nodiscard]] friend bool operator==(const Type& type, std::nullptr_t) noexcept { return type.isValid(); }
 
        [[nodiscard]] friend bool operator!=(const Type& type, std::nullptr_t) noexcept { return !type.isValid(); }
 
        [[nodiscard]] friend bool operator==(std::nullptr_t, const Type& type) noexcept { return type.isValid(); }
 
        [[nodiscard]] friend bool operator!=(std::nullptr_t, const Type& type) noexcept { return !type.isValid(); }
 
        [[nodiscard]] friend bool operator==(const Type& lhs, const Type& rhs) noexcept { return lhs.mTypeInfo == rhs.mTypeInfo; }
        [[nodiscard]] friend bool operator!=(const Type& lhs, const Type& rhs) noexcept { return lhs.mTypeInfo == rhs.mTypeInfo; }
 
        [[nodiscard]] friend bool operator<(const Type& lhs, const Type& rhs) noexcept { return lhs.mTypeInfo < rhs.mTypeInfo; }
        [[nodiscard]] friend bool operator<=(const Type& lhs, const Type& rhs) noexcept { return lhs.mTypeInfo <= rhs.mTypeInfo; }
        [[nodiscard]] friend bool operator>(const Type& lhs, const Type& rhs) noexcept { return lhs.mTypeInfo > rhs.mTypeInfo; }
        [[nodiscard]] friend bool operator>=(const Type& lhs, const Type& rhs) noexcept { return lhs.mTypeInfo >= rhs.mTypeInfo; }
 
    private:
        friend class Class;
        friend class Enum;
        friend class Box;
 
        [[nodiscard]] void* allocate() const;
        void deallocate(void* ptr) const;
        void defaultConstruct(void* where) const;
        void copyConstruct(const void* source, void* where) const;
        void moveConstruct(void* source, void* where) const;
        void moveOrCopy(void* source, void* where) const;
        void destroy(void* ptr) const noexcept;
        [[nodiscard]] bool compareEquality(const void* lhs, const void* rhs) const;
 
        template<typename From, typename To, typename Func> static bool registerConverterInternal(Func&& func);
        template<typename From, typename To> static bool registerConverterInternal(To (From::*func)() const);
        template<typename From, typename To> static bool registerConverterInternal(To (From::*func)(bool&) const);
        static bool registerConverter(TypeID fromTypeID, TypeID toTypeID, const internal::ConvertFunctionBase& converter);
 
        template<typename From, typename To> static bool registerConverterInternalNonChecked();
        static bool registerConverterInternalNonChecked(TypeID fromTypeID, TypeID toTypeID, const internal::ConvertFunctionBase& converter);
 
        [[nodiscard]] static bool convert(const void* from, Type fromType, void* to, Type toType);
        [[nodiscard]] static bool convert(const void* from, TypeID fromTypeID, void* to, TypeID toTypeID);
    };
 
    template<typename T> [[nodiscard]] constexpr TypeID getTypeID();
 
    template<> [[nodiscard]] CE_FLATTEN_INLINE inline TypeID getTypeID<void>() { return TypeID{}; }
    template<typename T> [[nodiscard]] CE_FLATTEN_INLINE inline Type getType() { return Type{getTypeID<T>()}; }
    template<typename T> [[nodiscard]] CE_FLATTEN_INLINE inline Type getType(T&&) { return Type{getTypeID<T>()}; }
 
    // ---------------------------------------------------------------------------------------------
 
    namespace internal {
 
        template<typename From, typename To> [[nodiscard]] To defaultConvert(const From& value) { return static_cast<To>(value); }
 
        struct ConvertFunctionBase {
            using converter_t = bool (*)(const ConvertFunctionBase&, const void*, void*);
 
            ConvertFunctionBase() = delete;
            ConvertFunctionBase(const ConvertFunctionBase&) = delete;
            ConvertFunctionBase(ConvertFunctionBase&&) = delete;
            ConvertFunctionBase& operator=(const ConvertFunctionBase&) = delete;
            ConvertFunctionBase& operator=(ConvertFunctionBase&&) = delete;
 
            explicit ConvertFunctionBase(const converter_t converter) : mConverter(converter) {}
 
            [[nodiscard]] bool invoke(const void* in, void* out) const { return mConverter(*this, in, out); }
 
        private:
            converter_t mConverter;
        };
 
        template<typename From, typename To, typename F> struct ConvertFunctor : ConvertFunctionBase {
            using this_t = ConvertFunctor<From, To, F>;
 
            explicit ConvertFunctor(const F& func) : ConvertFunctionBase{convert}, mFunc(func) {}
            explicit ConvertFunctor(F&& func) : ConvertFunctionBase{convert}, mFunc(std::move(func)) {}
            ~ConvertFunctor() { Type::unregisterConverter<From, To>(); }
 
            [[nodiscard]] static bool convert(const ConvertFunctionBase& self, const void* in, void* out) {
                try {
                    auto& _this = static_cast<const this_t&>(self);
                    auto from = static_cast<const From*>(in);
                    new(out) To(_this.mFunc(*from));
                    return true;
                } catch(...) {
                    return false;
                }
            }
 
        private:
            F const mFunc;
        };
 
        template<typename From, typename To, typename F> struct ConvertFunctorOk : ConvertFunctionBase {
            using this_t = ConvertFunctorOk<From, To, F>;
 
            explicit ConvertFunctorOk(const F& func) : ConvertFunctionBase{convert}, mFunc(func) {}
            explicit ConvertFunctorOk(F&& func) : ConvertFunctionBase{convert}, mFunc(std::move(func)) {}
            ~ConvertFunctorOk() { Type::unregisterConverter<From, To>(); }
 
            [[nodiscard]] static bool convert(const ConvertFunctionBase& self, const void* in, void* out) {
                auto& _this = static_cast<const this_t&>(self);
                auto from = static_cast<const From*>(in);
                auto result = false;
                new(out) To(_this.mFunc(*from, result));
                return result;
            }
 
        private:
            F const mFunc;
        };
 
        template<typename From, typename To> struct ConvertMethod : ConvertFunctionBase {
            using this_t = ConvertMethod<From, To>;
            using func_t = To (From::*)() const;
 
            explicit ConvertMethod(const func_t func) : ConvertFunctionBase{convert}, mFunc(func) {}
 
            ~ConvertMethod() { Type::unregisterConverter<From, To>(); }
 
            [[nodiscard]] static bool convert(const ConvertFunctionBase& self, const void* in, void* out) {
                try {
                    auto& _this = static_cast<const this_t&>(self);
                    auto from = static_cast<const From*>(in);
                    new(out) To(from->*_this.mFunc());
                    return true;
                } catch(...) {
                    return false;
                }
            }
 
        private:
            func_t const mFunc;
        };
 
        template<typename From, typename To> struct ConvertMethodOk : ConvertFunctionBase {
            using this_t = ConvertMethodOk<From, To>;
            using func_t = To (From::*)(bool&) const;
 
            explicit ConvertMethodOk(const func_t func) : ConvertFunctionBase{convert}, mFunc(func) {}
 
            ~ConvertMethodOk() { Type::unregisterConverter<From, To>(); }
 
            [[nodiscard]] static bool convert(const ConvertFunctionBase& self, const void* in, void* out) {
                auto& _this = static_cast<const this_t&>(self);
                auto from = static_cast<const From*>(in);
                auto result = false;
                new(out) To(from->*_this.mFunc(result));
                return result;
            }
 
        private:
            func_t const mFunc;
        };
 
    } // namespace internal
 
    template<typename From, typename To> inline bool Type::hasConverter() noexcept { return hasConverter(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>()); }
 
    // Functor converter
 
    template<typename From, typename To, typename Func> inline bool Type::registerConverterInternal(Func&& func) {
        using Fu = full_decay<Func>;
 
        if constexpr(std::is_invocable_r_v<To, Func, From, bool&>) {
            static internal::ConvertFunctorOk<From, To, Fu> converter{std::forward<Func>(func)};
            return registerConverter(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>(), converter);
        } else {
            static internal::ConvertFunctor<From, To, Fu> converter{std::forward<Func>(func)};
            return registerConverter(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>(), converter);
        }
    }
 
    template<typename From, typename To, typename Func> inline bool Type::registerConverter(Func&& func) {
        using F = full_decay<From>;
        using T = full_decay<To>;
        return registerConverterInternal<F, T>(std::forward<Func>(func));
    }
 
    template<typename From, typename To> inline bool Type::registerConverter(To (*func)(From)) {
        using Func = To (*)(From);
        return registerConverter<From, To, Func>(std::move(func));
    }
 
    template<typename From, typename To> inline bool Type::registerConverter() { return registerConverter<From, To>(internal::defaultConvert<From, To>); }
 
    template<typename From, typename To> inline bool Type::registerConverterInternalNonChecked() {
        static internal::ConvertFunctor<From, To, decltype(&internal::defaultConvert<From, To>)> converter{internal::defaultConvert<From, To>};
        return registerConverterInternalNonChecked(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>(), converter);
    }
 
    // Method converter
 
    template<typename From, typename To> inline bool Type::registerConverterInternal(To (From::*func)() const) {
        static internal::ConvertMethod<From, To> converter{func};
        return registerConverter(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>(), converter);
    }
 
    template<typename From, typename To> inline bool Type::registerConverter(To (From::*func)() const) {
        using F = full_decay<From>;
        using T = full_decay<To>;
        return registerConverterInternal<F, T>(func);
    }
 
    // Method extended converter
 
    template<typename From, typename To> inline bool Type::registerConverterInternal(To (From::*func)(bool&) const) {
        static internal::ConvertMethodOk<From, To> converter{func};
        return registerConverter(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>(), converter);
    }
 
    template<typename From, typename To> inline bool Type::registerConverter(To (From::*func)(bool&) const) {
        using F = full_decay<From>;
        using T = full_decay<To>;
        return registerConverterInternal<F, T>(func);
    }
 
    template<typename From, typename To> inline void Type::unregisterConverter() { unregisterConverter(CeresEngine::getTypeID<From>(), CeresEngine::getTypeID<To>()); }
 
    std::ostream& operator<<(std::ostream& stream, Type type);
 
    template<typename T> [[nodiscard]] CE_FLATTEN_INLINE constexpr TypeID getTypeID() { return TypeID(reinterpret_cast<UInt64>(&GetTypeInfo<T>::get())); }
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename T> [[nodiscard]] bool Type::is() const { return mTypeInfo != nullptr && mTypeInfo->is<T>(); }
    template<typename T> [[nodiscard]] const T* Type::as() const {
        if(mTypeInfo == nullptr) {
            return nullptr;
        }
        return mTypeInfo->as<T>();
    }
 
    template<typename T> [[nodiscard]] bool Type::compatible() const noexcept { return compatible(*this, getType<T>()); }
 
    // ---------------------------------------------------------------------------------------------
 
    struct TypeAutoRegistrationBase {
        const TypeInfo& type;
        TypeAutoRegistrationBase(const TypeInfo& type);
        ~TypeAutoRegistrationBase();
    };
 
    template<typename T> struct TypeAutoRegistration : public TypeAutoRegistrationBase {
        TypeAutoRegistration() : TypeAutoRegistrationBase(GetTypeInfo<T>::get()) {}
    };
 
    // ---------------------------------------------------------------------------------------------
 
    #define CE_META_CONCAT_IMPL(A, B) A##B
    #define CE_META_CONCAT(A, B) CE_META_CONCAT_IMPL(A, B)
 
#define CE_META_TYPE_AUTO_REGISTRATION_NAME(T) CE_META_CONCAT(gTypeAutoRegistrator, __COUNTER__)
#define CE_META_TYPE_AUTO_REGISTRATION(T) static const ::CeresEngine::TypeAutoRegistration<T> CE_META_TYPE_AUTO_REGISTRATION_NAME(T)
 
} //namespace CeresEngine
 
template<> struct std::hash<CeresEngine::Type> {
    using Type = CeresEngine::Type;
    [[nodiscard]] size_t operator()(const Type& value) const { return CeresEngine::hash(value.getTypeID().raw); }
};