Class.define.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 "Box.hpp"
#include "Class.hpp"
#include "Enum.hpp"
#include "MetaArgument.hpp"
#include "MetaContainer.hpp"
#include "MetaItem.hpp"
#include "MetaSignature.hpp"
#include "Type.define.hpp"
#include "Type.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
 
#include <type_traits>
 
namespace CeresEngine {
    namespace impl {
        template<typename T>
        concept ReflectableClass = requires(T& object, const T& constObject) {
            { object.getClassInfo() } -> std::convertible_to<ClassInfo>;
            { constObject.getClassInfo() } -> std::convertible_to<ClassInfo>;
        };
 
        template<typename T> class TMetaReflectableClassType {};
 
        template<typename T> requires ReflectableClass<T>
        class TMetaReflectableClassType<T> : public ReflectableClassTypeTrait {
        public:
            [[nodiscard]] ClassInfo getClassInfo(const void* target) const final { return static_cast<const T*>(target)->getClassInfo(); }
 
            [[nodiscard]] ClassInfo getClassInfo(void* target) const final { return static_cast<T*>(target)->getClassInfo(); }
        };
    } // namespace impl
 
    using MetaAttributeList = Vector<Box>;
 
    template<typename T>
    class TClass : public TTypeInfo<T>, //
                   public Class,
                   public impl::TMetaReflectableClassType<T> {
    public:
        explicit TClass() : Class(getTypeName<T>()) {
            if constexpr(std::is_default_constructible_v<T>) {
                constructor<>();
            }
 
            if constexpr(std::is_copy_constructible_v<T>) {
                constructor<const T&>();
            }
        }
 
    public:
        [[nodiscard]] StringView getName() const noexcept final { return name; }
 
    public: // Bases
        template<typename B> void base();
        template<typename Base0, typename... Bs> void bases();
 
    public: // Constructors
        template<typename... Args> void constructor();
 
    public: // Properties
        template<typename P> void property(StringView name, P&& property, MetaAttributeList&& attributes = {});
        template<typename G, typename S> void property(StringView name, G&& getter, S&& setter, MetaAttributeList&& attributes = {});
 
    public: // Methods
        template<typename F> void method(StringView name, F func, MetaAttributeList&& attributes = {});
    };
 
#define CE_META_CLASS_DEFINE_BASE(...)                                                   \
    class ::CeresEngine::TUserTypeInfo<__VA_ARGS__> final : public TClass<__VA_ARGS__> { \
        using ClassType = __VA_ARGS__;                                                   \
                                                                                         \
    public:                                                                              \
        explicit TUserTypeInfo() { define(*this); }                                      \
                                                                                         \
    private:                                                                             \
        inline void define(TUserTypeInfo& define);                                       \
    }
 
#define CE_META_REFLECTABLE_CLASS_BASE(...)                                             \
    [[nodiscard]] ::CeresEngine::ClassInfo __VA_ARGS__::getClassInfo() noexcept {       \
        return ::CeresEngine::ClassInfo{                                                \
            ::CeresEngine::getTypeID<std::decay_t<decltype(*this)>>(),                  \
            this,                                                                       \
        };                                                                              \
    }                                                                                   \
                                                                                        \
    [[nodiscard]] ::CeresEngine::ClassInfo __VA_ARGS__::getClassInfo() const noexcept { \
        return ::CeresEngine::ClassInfo{                                                \
            ::CeresEngine::getTypeID<std::decay_t<decltype(*this)>>(),                  \
            this,                                                                       \
        };                                                                              \
    }
 
#define CE_META_CLASS_DEFINE(...)                                                              \
    template<> CE_META_CLASS_DEFINE_BASE(__VA_ARGS__);                                         \
    template<> const ::CeresEngine::TypeInfo& ::CeresEngine::GetTypeInfo<__VA_ARGS__>::get() { \
        static const TUserTypeInfo<__VA_ARGS__> typeInfo;                                      \
        return typeInfo;                                                                       \
    }                                                                                          \
    CE_META_TYPE_AUTO_REGISTRATION(__VA_ARGS__);                                               \
    void ::CeresEngine::TUserTypeInfo<__VA_ARGS__>::define(TUserTypeInfo& define)
 
#define CE_META_REFLECTABLE_CLASS_DEFINE(...)                                                  \
    template<> CE_META_CLASS_DEFINE_BASE(__VA_ARGS__);                                         \
    template<> const ::CeresEngine::TypeInfo& ::CeresEngine::GetTypeInfo<__VA_ARGS__>::get() { \
        static const TUserTypeInfo<__VA_ARGS__> typeInfo;                                      \
        return typeInfo;                                                                       \
    }                                                                                          \
    CE_META_TYPE_AUTO_REGISTRATION(__VA_ARGS__);                                               \
    CE_META_REFLECTABLE_CLASS_BASE(__VA_ARGS__)                                                \
    void ::CeresEngine::TUserTypeInfo<__VA_ARGS__>::define(TUserTypeInfo& define)
 
#define CE_META_CLASS_TEMPLATE_DEFINE(TType, ...)                    \
    template<__VA_ARGS__> CE_META_CLASS_DEFINE_BASE(TType);          \
    template<__VA_ARGS__> struct ::CeresEngine::GetTypeInfo<TType> { \
        static const TypeInfo& get() noexcept {                      \
            static const TUserTypeInfo<TType> typeInfo;              \
            return typeInfo;                                         \
        }                                                            \
    };                                                               \
                                                                     \
    template<__VA_ARGS__> void ::CeresEngine::TUserTypeInfo<TType>::define(TUserTypeInfo& define)
 
#define CE_META_CLASS_TEMPLATE_SPECIALIZATION_EXTERN(...) extern template struct ::CeresEngine::GetTypeInfo<__VA_ARGS__>;
#define CE_META_CLASS_TEMPLATE_SPECIALIZATION_DEFINE(...)    \
    template struct ::CeresEngine::GetTypeInfo<__VA_ARGS__>; \
    CE_META_TYPE_AUTO_REGISTRATION(__VA_ARGS__);
 
    // ---------------------------------------------------------------------------------------------
 
    namespace internal {
        struct VoidStaticFunctionTag {};
        struct ReturnStaticFunctionTag {};
        struct VoidMemberFunctionTag {};
        struct ReturnMemberFunctionTag {};
 
        template<typename F>
        using MethodInvokerTag = std::conditional_t<std::is_void_v<typename function_traits<F>::result_type>,
            std::conditional_t<std::is_void_v<typename function_traits<F>::class_type>, VoidStaticFunctionTag, VoidMemberFunctionTag>,
            std::conditional_t<std::is_void_v<typename function_traits<F>::class_type>, ReturnStaticFunctionTag, ReturnMemberFunctionTag>>;
 
        template<typename F, typename Tag = MethodInvokerTag<F>> struct MethodInvokerInternal;
 
        template<typename F> struct MethodInvokerInternal<F, VoidStaticFunctionTag> {
            using Args = typename function_traits<F>::args;
 
            [[nodiscard]] static bool isStatic() { return true; }
            [[nodiscard]] static TypeID getReturnTypeID() { return getTypeID<void>(); }
            [[nodiscard]] static Vector<TypeID> getParametersTypeID() { return getParametersTypeID(argument_indexes_t{}); }
            [[nodiscard]] static String signature(StringView name) { return f_signature<F>::get(name); }
 
            [[nodiscard]] static Box invoke(const F& func, const MetaValues& arguments) { return invokeInternal(func, arguments, argument_indexes_t{}); }
 
        private:
            template<std::size_t I> using argument_get_t = MPL::Nth<I, Args>;
            using argument_indexes_t = std::make_index_sequence<function_traits<F>::arity>;
 
            template<std::size_t... I> [[nodiscard]] static Box invokeInternal(const F& func, const MetaValues& arguments, std::index_sequence<I...>) {
                func(MetaArgument(arguments[I]).getValue<argument_get_t<I>>()...);
                return Box();
            }
 
            template<std::size_t... I> [[nodiscard]] static Vector<TypeID> getParametersTypeID(mpl::index_sequence<I...>) {
                return {getTypeID<argument_get_t<I>>()...};
            }
        };
 
        template<typename F> struct MethodInvokerInternal<F, ReturnStaticFunctionTag> {
            using Args = typename function_traits<F>::args;
            using Result = typename function_traits<F>::result_type;
 
            [[nodiscard]] static bool isStatic() { return true; }
            [[nodiscard]] static TypeID getReturnTypeID() { return getTypeID<Result>(); }
            [[nodiscard]] static Vector<TypeID> getParametersTypeID() { return getParametersTypeID(argument_indexes_t{}); }
            [[nodiscard]] static String signature(StringView name) { return f_signature<F>::get(name); }
 
            [[nodiscard]] static Box invoke(const F& func, const MetaValues& arguments) { return invokeInternal(func, arguments, argument_indexes_t{}); }
 
        private:
            template<std::size_t I> using argument_get_t = MPL::Nth<I, Args>;
            using argument_indexes_t = mpl::index_sequence_for_t<Args>;
 
            template<std::size_t... I> [[nodiscard]] static Vector<TypeID> getParametersTypeID(mpl::index_sequence<I...>) {
                return {getTypeID<argument_get_t<I>>()...};
            }
 
            template<std::size_t... I> [[nodiscard]] static Box invokeInternal(const F& func, const MetaValues& arguments, std::index_sequence<I...>) {
                if constexpr(std::is_reference_v<Result>) {
                    return std::ref(func(MetaArgument(arguments[I]).getValue<argument_get_t<I>>()...));
                } else {
                    return func(MetaArgument(arguments[I]).getValue<argument_get_t<I>>()...);
                }
            }
        };
 
        template<typename F> struct MethodInvokerInternal<F, VoidMemberFunctionTag> {
            using Args = typename function_traits<F>::args;
 
            [[nodiscard]] static bool isStatic() { return false; }
            [[nodiscard]] static TypeID getReturnTypeID() { return getTypeID<void>(); }
            [[nodiscard]] static Vector<TypeID> getParametersTypeID() { return getParametersTypeID(argument_indexes_t{}); }
            [[nodiscard]] static String signature(StringView name) { return f_signature<F>::get(name); }
 
            [[nodiscard]] static Box invoke(const F& func, const MetaValues& arguments) { return invokeInternal(func, arguments, argument_indexes_t{}); }
 
        private:
            template<std::size_t I> using argument_get_t = MPL::Nth<I, Args>;
            using argument_indexes_t = mpl::index_sequence_for_t<Args>;
            //
            using C = typename function_traits<F>::class_type;
            using is_const_method = typename function_traits<F>::is_const;
            using class_t = std::conditional_t<is_const_method::value, std::add_const_t<C>, C>;
            using class_ref_t = std::add_lvalue_reference_t<class_t>;
            using class_ptr_t = std::add_pointer_t<class_t>;
 
            template<std::size_t... I> [[nodiscard]] static Vector<TypeID> getParametersTypeID(mpl::index_sequence<I...>) {
                return {getTypeID<argument_get_t<I>>()...};
            }
 
            template<std::size_t... I> [[nodiscard]] static Box invokeInternal(const F& func, const MetaValues& arguments, mpl::index_sequence<I...>) {
                const Box& instance = arguments[0];
                const Type type{arguments[0].getTypeID()};
                if(type.isClass()) {
                    if constexpr(is_const_method::value) {
                        (instance.ref<class_t>().*func)(MetaArgument(arguments[I + 1]).getValue<argument_get_t<I>>()...);
                    } else {
                        (instance.ref<class_ref_t>().*func)(MetaArgument(arguments[I + 1]).getValue<argument_get_t<I>>()...);
                    }
                } else if(type.isClassPtr()) {
                    (instance.to<class_ptr_t>()->*func)(MetaArgument(arguments[I + 1]).getValue<argument_get_t<I>>()...);
                }
 
                return Box();
            }
        };
 
        template<typename F> struct MethodInvokerInternal<F, ReturnMemberFunctionTag> {
            using Args = typename function_traits<F>::args;
            using Result = typename function_traits<F>::result_type;
 
            [[nodiscard]] static bool isStatic() { return false; }
            [[nodiscard]] static TypeID getReturnTypeID() { return getTypeID<Result>(); }
            [[nodiscard]] static Vector<TypeID> getParametersTypeID() { return getParametersTypeID(argument_indexes_t{}); }
            [[nodiscard]] static String signature(StringView name) { return f_signature<F>::get(name); }
 
            [[nodiscard]] static Box invoke(const F& func, const MetaValues& arguments) { return invokeInternal(func, arguments, argument_indexes_t{}); }
 
        private:
            template<std::size_t I> using argument_get_t = MPL::Nth<I, Args>;
            using argument_indexes_t = mpl::index_sequence_for_t<Args>;
            //
            using C = typename function_traits<F>::class_type;
            using is_const_method = typename function_traits<F>::is_const;
            using class_t = std::conditional_t<is_const_method::value, std::add_const_t<C>, C>;
            using class_ref_t = std::add_lvalue_reference_t<class_t>;
            using class_ptr_t = std::add_pointer_t<class_t>;
 
            template<std::size_t... I> [[nodiscard]] static Vector<TypeID> getParametersTypeID(mpl::index_sequence<I...>) {
                return {getTypeID<argument_get_t<I>>()...};
            }
 
            template<typename R> [[nodiscard]] static Box reference_get(R&& result) {
                if constexpr(std::is_reference_v<Result>) {
                    return std::ref(std::forward<R>(result));
                } else {
                    return std::forward<R>(result);
                }
            }
 
            template<std::size_t... I> [[nodiscard]] static Box invokeInternal(const F& func, const MetaValues& arguments, mpl::index_sequence<I...>) {
                const Box& instance = arguments[0];
                const Type type{instance.getTypeID()};
                if(type.isClass()) {
                    if constexpr(is_const_method::value) {
                        return reference_get((instance.ref<class_t>().*func)(MetaArgument(arguments[I + 1]).getValue<argument_get_t<I>>()...));
                    } else {
                        throw BadMetaValueCast("Incompatible types: const CeresEngine::MetaValue& -> {0}", getTypeName<class_ref_t>());
                    }
                } else if(type.isClassPtr()) {
                    return reference_get((instance.to<class_ptr_t>()->*func)(MetaArgument(arguments[I + 1]).getValue<argument_get_t<I>>()...));
                }
 
                throw BadMetaValueCast("Bad call");
            }
        };
 
        template<typename P> struct PropertyTypeTrait;
 
        template<typename P> struct PropertyTypeTrait<P*> : mpl::identity<P> {};
 
        template<typename C, typename T> struct PropertyTypeTrait<T C::*> : mpl::identity<T> {};
 
        template<typename P> using PropertyType = typename PropertyTypeTrait<P>::type;
        template<typename P> struct PropertyClassTrait;
 
        template<typename C, typename T> struct PropertyClassTrait<T C::*> : mpl::identity<C> {};
 
        template<typename P> using PropertyClass = typename PropertyClassTrait<P>::type;
 
        struct StaticPointerTag {};
 
        struct MemberPointerTag {};
 
        template<typename P> using MetaPropertyAccessorTag = std::conditional_t<std::is_member_pointer_v<P>, MemberPointerTag, StaticPointerTag>;
 
        template<typename P, typename Tag> struct MetaPropertyAccessorInternal;
 
        template<typename P> struct MetaPropertyAccessorInternal<P, StaticPointerTag> {
            static_assert(std::is_pointer_v<P> && !std::is_function_v<P>, "Type should be pointer");
 
            [[nodiscard]] static constexpr bool isStatic() { return true; }
            [[nodiscard]] static TypeID getTypeID() { return CeresEngine::getTypeID<T>(); }
            [[nodiscard]] static bool isReadOnly() { return std::is_const_v<T>; }
 
            [[nodiscard]] static Box getStatic(P property) { return std::cref(*property); }
 
            static void setStatic([[maybe_unused]] P property, const MetaArgument& arg) {
                if constexpr(std::is_const_v<T>) {
                    throw InvokeError("Write to readonly property");
                } else {
                    *property = arg.getValue<T>();
                }
            }
 
            [[nodiscard]] static Box getField(P, const Box&) {
                CE_ASSERT(false);
                return Box();
            }
 
            static void setField(P, const Box&, const MetaArgument&) { assert(false); }
            static void setField(P, Box&, const MetaArgument&) { assert(false); }
 
        private:
            using T = PropertyType<P>;
        };
 
        template<typename P> struct MetaPropertyAccessorInternal<P, MemberPointerTag> {
            static_assert(std::is_member_object_pointer_v<P>, "Type should be member object pointer");
 
            [[nodiscard]] static bool isStatic() { return false; }
            [[nodiscard]] static TypeID getTypeID() { return CeresEngine::getTypeID<T>(); }
            [[nodiscard]] static bool isReadOnly() { return std::is_const_v<T>; }
 
            [[nodiscard]] static Box getStatic(P) {
                CE_ASSERT(false);
                return Box();
            }
 
            static void setStatic(P, const MetaArgument&) { assert(false); }
 
            [[nodiscard]] static Box getField(P property, const Box& instance) {
                const auto type = Type{instance.getTypeID()};
                if(type.isClass()) {
                    if(type.isConst()) {
                        return std::ref(instance.cref<C>().*property);
                    } else {
                        return std::ref(instance.ref<C>().*property);
                    }
                } else if(type.isClassPtr()) {
                    return std::ref(instance.to<const C*>()->*property);
                }
                throw BadMetaValueCast("Unknown this type");
            }
 
            static void setField(P property, const Box& instance, const MetaArgument& arg) {
                if constexpr(std::is_const_v<T>) {
                    throw InvokeError("Write to readonly property");
                } else {
                    const Type type{instance.getTypeID()};
                    if(type.isClass()) {
                        if(type.isConst()) {
                            throw BadMetaValueCast("Incompatible types: const CeresEngine::MetaValue& -> {0}", getTypeName<class_ref_t>());
                        }
 
                        if constexpr(std::is_assignable_v<T, T>) {
                            instance.ref<C>().*property = arg.getValue<T>();
                        } else if constexpr(std::is_copy_constructible_v<T>) {
                            (instance.ref<C>().*property).~T();
                            new(&(instance.ref<C>().*property)) T(arg.getValue<T>());
                        } else {
                            throw BadMetaValueCast("Incompatible types: const CeresEngine::MetaValue& -> {0}", getTypeName<class_ref_t>());
                        }
                    } else if(type.isClassPtr()) {
                        if constexpr(std::is_assignable_v<T, T>) {
                            instance.to<C*>()->*property = arg.getValue<T>();
                        } else if constexpr(std::is_copy_constructible_v<T>) {
                            (instance.to<C*>()->*property).~T();
                            new(&(instance.to<C*>()->*property)) T(arg.getValue<T>());
                        } else {
                            throw BadMetaValueCast("Incompatible types: const CeresEngine::MetaValue& -> {0}", getTypeName<class_ref_t>());
                        }
                    }
                }
            }
 
            static void setField(P property, Box& instance, const MetaArgument& arg) {
                if constexpr(std::is_const_v<T>) {
                    throw InvokeError("Write to readonly property");
                } else {
                    const auto type = Type{instance.getTypeID()};
                    if(type.isClass()) {
                        instance.ref<C>().*property = arg.getValue<T>();
                    } else if(type.isClassPtr()) {
                        instance.to<C*>()->*property = arg.getValue<T>();
                    }
                }
            }
 
        private:
            using C = PropertyClass<P>;
            using T = PropertyType<P>;
            using class_ref_t = std::add_lvalue_reference_t<C>;
        };
    } // namespace internal
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename PointerType> class MetaPointerProperty : public ClassProperty {
        using AccessorTraits = internal::MetaPropertyAccessorInternal<PointerType, internal::MetaPropertyAccessorTag<PointerType>>;
 
        const PointerType mPointer;
 
    public:
        explicit MetaPointerProperty(Class& owner, const StringView name, PointerType pointer) noexcept : ClassProperty(owner, name), mPointer(pointer) {}
 
    public:
        [[nodiscard]] bool isStatic() const noexcept override { return AccessorTraits::isStatic(); }
 
        [[nodiscard]] bool isReadOnly() const noexcept override { return AccessorTraits::isReadOnly(); }
 
        [[nodiscard]] TypeID getGetterReturnTypeID() const noexcept override { return AccessorTraits::getTypeID(); }
 
        [[nodiscard]] TypeID getSetterParameterTypeID() const noexcept override { return AccessorTraits::getTypeID(); }
 
        [[nodiscard]] Box get(const Box& target) const override {
            if(isStatic()) {
                return AccessorTraits::getStatic(mPointer);
            } else {
                return AccessorTraits::getField(mPointer, target);
            }
        }
 
        void set(const Box& target, const Box& value) const override {
            if(isStatic()) {
                AccessorTraits::setStatic(mPointer, value);
            } else {
                AccessorTraits::setField(mPointer, target, value);
            }
        }
 
        void set(const Box& target, Box&& value) const override {
            if(isStatic()) {
                AccessorTraits::setStatic(mPointer, std::move(value));
            } else {
                AccessorTraits::setField(mPointer, target, std::move(value));
            }
        }
    };
 
    template<typename GetterType, typename SetterType> class MetaAccessorProperty : public ClassProperty {
    private:
        static constexpr auto valid = (std::is_function_v<GetterType> && (std::is_void_v<SetterType> || std::is_function_v<SetterType>)) ||
            (std::is_member_function_pointer_v<GetterType> && (std::is_void_v<SetterType> || std::is_member_function_pointer_v<SetterType>));
        static_assert(valid, "Getter and setter methods should be simultaneously static method or pointer to member");
 
        using GetterTraits = function_traits<GetterType>;
 
        using SetterTraits = function_traits<SetterType>;
 
        using T = typename GetterTraits::result_type;
 
        using SetterArgument = typename SetterTraits::template arg<0>;
 
        static_assert(!std::is_void_v<T>, "Getter method should have non void result type");
        static_assert(GetterTraits::arity == 0, "Getter method shouldn't have any parameters");
        static_assert(std::is_void_v<typename SetterTraits::result_type>, "Setter method should have void result type");
        static_assert(SetterTraits::arity == 1, "Setter method should have one parameters");
        static_assert(std::is_same_v<std::decay_t<T>, std::decay_t<SetterArgument>>, "Getter method return type and setter method parameter type do not match");
 
        const GetterType mGetter;
 
        const SetterType mSetter;
 
    public:
        explicit MetaAccessorProperty(Class& owner, const StringView name, GetterType getter, SetterType setter) noexcept
                : ClassProperty(owner, name), mGetter(getter), mSetter(setter) {}
 
    public:
        [[nodiscard]] bool isStatic() const noexcept override { return std::is_function_v<GetterType>; }
 
        [[nodiscard]] bool isReadOnly() const noexcept override { return !std::is_void_v<SetterType>; }
 
        [[nodiscard]] TypeID getGetterReturnTypeID() const noexcept override { return CeresEngine::getTypeID<T>(); }
 
        [[nodiscard]] TypeID getSetterParameterTypeID() const noexcept override { return CeresEngine::getTypeID<SetterArgument>(); }
 
        [[nodiscard]] Box get(const Box& target) const override {
            if(isStatic()) {
                return internal::MethodInvokerInternal<GetterType>::invoke(mGetter, {});
            } else {
                return internal::MethodInvokerInternal<GetterType>::invoke(mGetter, {target.ref()});
            }
        }
 
        void set(const Box& target, const Box& value) const override {
            if(isStatic()) {
                (void)internal::MethodInvokerInternal<SetterType>::invoke(mSetter, {value});
            } else {
                (void)internal::MethodInvokerInternal<SetterType>::invoke(mSetter, {target.ref(), value});
            }
        }
 
        void set(const Box& target, Box&& value) const override {
            if(isStatic()) {
                (void)internal::MethodInvokerInternal<SetterType>::invoke(mSetter, {std::move(value)});
            } else {
                (void)internal::MethodInvokerInternal<SetterType>::invoke(mSetter, {target.ref(), std::move(value)});
            }
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename F> class TMetaMethod : public ClassMethod {
    private:
        F const mFunc;
 
        using invoker_t = internal::MethodInvokerInternal<F, internal::MethodInvokerTag<F>>;
 
    public:
        TMetaMethod(Class& owner, const StringView name, const F& func) noexcept : ClassMethod(owner, name), mFunc(func) {}
 
        TMetaMethod(Class& owner, const StringView name, F&& func) noexcept : ClassMethod(owner, name), mFunc(std::move(func)) {}
 
    public:
        [[nodiscard]] bool isStatic() const noexcept override { return invoker_t::isStatic(); }
 
        [[nodiscard]] TypeID getReturnTypeID() const noexcept override { return invoker_t::getReturnTypeID(); }
 
        [[nodiscard]] Span<const TypeID> getParameterTypeIDs() const noexcept override {
            const Vector<TypeID> parameters = invoker_t::getParametersTypeID();
            return parameters;
        }
 
        [[nodiscard]] String signature(StringView name) const { return invoker_t::signature(name); }
 
        [[nodiscard]] Box invoke(const MetaValues& arguments) { invoker_t::invoke(mFunc, arguments); }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename C, typename... Args> class TMetaConstructor : public ClassConstructor {
    private:
        static_assert((sizeof...(Args) > 0) || std::is_default_constructible_v<C>, "Type is not default constructible");
        static_assert((sizeof...(Args) == 0) || std::is_constructible_v<C, Args...>, "Type can not be constructed with given arguments");
 
        template<std::size_t I> using argument_get_t = MPL::Nth<I, MPL::TypeList<Args...>>;
        using argument_indexes_t = mpl::index_sequence_for_t<Args...>;
 
    public:
        explicit TMetaConstructor(Class& owner) : ClassConstructor(owner, signature("ctor")) {}
 
    public:
        [[nodiscard]] Span<const TypeID> getParameterTypeIDs() const override {
            static const Array<const TypeID, sizeof...(Args)> parameters{getTypeID<Args>()...};
            return Span<const TypeID>(parameters);
        }
 
        [[nodiscard]] String signature(StringView name) const {
            using args_size_t = std::integral_constant<int, sizeof...(Args)>;
            return signature(name, args_size_t{});
        }
 
        [[nodiscard]] Box invoke(const MetaValues& arguments) const override { return invokeInternal(arguments, argument_indexes_t{}); }
 
    private:
        [[nodiscard]] static constexpr const char* signature(StringView, std::integral_constant<int, 0>) { return DefaultConstructorSignature; }
 
        [[nodiscard]] static String signature(StringView name, std::integral_constant<int, 1>) {
            using Argument = argument_get_t<0>;
            if constexpr(std::is_same_v<std::decay_t<Argument>, C>) {
                if constexpr(std::is_rvalue_reference_v<Argument>) {
                    return MoveConstructorSignature;
                } else {
                    return CopyConstructorSignature;
                }
            } else {
                return ::CeresEngine::MetaSignature<Args...>::get(name);
            }
        }
 
        template<int N> [[nodiscard]] static String signature(StringView name, std::integral_constant<int, N>) {
            return ::CeresEngine::MetaSignature<Args...>::get(name);
        }
 
        template<std::size_t... I> static Box invokeInternal(const MetaValues& args, mpl::index_sequence<I...>) {
            if constexpr(std::is_same_v<C, Box>) {
                throw "not supported";
            } else {
                return Box(std::in_place_type_t<C>{}, MetaArgument(args[I]).getValue<argument_get_t<I>>()...);
            }
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename DerivedType, typename BaseType> inline void const* metacast_to_base(void const* value) {
        return static_cast<void const*>(static_cast<BaseType const*>(static_cast<DerivedType const*>(value)));
    }
 
    template<typename T> template<typename B> void TClass<T>::base() { addBaseClass(::CeresEngine::getTypeID<B>(), &metacast_to_base<T, B>); }
 
    template<typename T> template<typename Base0, typename... Bs> void TClass<T>::bases() {
        base<Base0>();
        ((void)base<Bs>(), ...);
    }
 
    template<typename T> template<typename... Args> void TClass<T>::constructor() {
        // TODO: Use unique ptr.
        new TMetaConstructor<T, Args...>(*this);
        //registerConvertingConstructor<MPL::TypeList<Args...>>(is_converting_constructor_t<T, Args...>{});
    }
 
    template<typename T> template<typename P> void TClass<T>::property(StringView name, P&& property, MetaAttributeList&& attributes) {
        // TODO: Use unique ptr.
        ClassProperty* const p = new MetaPointerProperty<P>(*this, name, property);
        for(Box& attribute : attributes) {
            p->attributes.set(std::move(attribute));
        }
    }
 
    template<typename T> template<typename G, typename S> void TClass<T>::property(StringView name, G&& getter, S&& setter, MetaAttributeList&& attributes) {
        // TODO: Use unique ptr.
        ClassProperty* const p = new MetaAccessorProperty<std::decay_t<G>, std::decay_t<S>>(*this, name, std::forward<G>(getter), std::forward<S>(setter));
        for(Box& attribute : attributes) {
            p->attributes.set(std::move(attribute));
        }
    }
 
    template<typename T> template<typename F> void TClass<T>::method(StringView name, F func, MetaAttributeList&& attributes) {
        // TODO: Use unique ptr.
        ClassMethod* const m = new TMetaMethod<std::decay_t<F>>(*this, name, std::forward<F>(func));
        for(Box& attribute : attributes) {
            m->attributes.set(std::move(attribute));
        }
    }
} // namespace CeresEngine