From 61e5bcef2629e2d68b805a956a96fff264d4f74d Mon Sep 17 00:00:00 2001 From: untodesu Date: Sat, 28 Jun 2025 01:59:49 +0500 Subject: Restructure dependencies and update to C++20 - Nuked static_assert from almost everywhere in the project - Nuked binary dependency support. Might add one later though - Separated dependency headers into a separate include subdirectory - Grafted a thirdpartylegalnotices.txt generator from RITEG - Pushed development snapshot version to 2126 (26th week of 2025) --- deps/include/entt/meta/node.hpp | 298 ---------------------------------------- 1 file changed, 298 deletions(-) delete mode 100644 deps/include/entt/meta/node.hpp (limited to 'deps/include/entt/meta/node.hpp') diff --git a/deps/include/entt/meta/node.hpp b/deps/include/entt/meta/node.hpp deleted file mode 100644 index fc680a3..0000000 --- a/deps/include/entt/meta/node.hpp +++ /dev/null @@ -1,298 +0,0 @@ -#ifndef ENTT_META_NODE_HPP -#define ENTT_META_NODE_HPP - -#include -#include -#include -#include -#include "../config/config.h" -#include "../container/dense_map.hpp" -#include "../core/attribute.h" -#include "../core/bit.hpp" -#include "../core/enum.hpp" -#include "../core/fwd.hpp" -#include "../core/type_info.hpp" -#include "../core/type_traits.hpp" -#include "../core/utility.hpp" -#include "context.hpp" -#include "type_traits.hpp" - -namespace entt { - -class meta_any; -class meta_type; -struct meta_handle; - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -enum class meta_traits : std::uint32_t { - is_none = 0x0000, - is_const = 0x0001, - is_static = 0x0002, - is_arithmetic = 0x0004, - is_integral = 0x0008, - is_signed = 0x0010, - is_array = 0x0020, - is_enum = 0x0040, - is_class = 0x0080, - is_pointer = 0x0100, - is_meta_pointer_like = 0x0200, - is_meta_sequence_container = 0x0400, - is_meta_associative_container = 0x0800, - _user_defined_traits = 0xFFFF, - _entt_enum_as_bitmask = 0xFFFF -}; - -template -[[nodiscard]] auto meta_to_user_traits(const meta_traits traits) noexcept { - static_assert(std::is_enum_v, "Invalid enum type"); - constexpr auto shift = popcount(static_cast>(meta_traits::_user_defined_traits)); - return Type{static_cast>(static_cast>(traits) >> shift)}; -} - -template -[[nodiscard]] auto user_to_meta_traits(const Type value) noexcept { - static_assert(std::is_enum_v, "Invalid enum type"); - constexpr auto shift = popcount(static_cast>(meta_traits::_user_defined_traits)); - const auto traits = static_cast>(static_cast>(value)); - ENTT_ASSERT(traits < ((~static_cast>(meta_traits::_user_defined_traits)) >> shift), "Invalid traits"); - return meta_traits{traits << shift}; -} - -struct meta_type_node; - -struct meta_custom_node { - id_type type{}; - std::shared_ptr value{}; -}; - -struct meta_prop_node { - meta_type_node (*type)(const meta_context &) noexcept {}; - std::shared_ptr value{}; -}; - -struct meta_base_node { - meta_type_node (*type)(const meta_context &) noexcept {}; - const void *(*cast)(const void *) noexcept {}; -}; - -struct meta_conv_node { - meta_any (*conv)(const meta_ctx &, const void *){}; -}; - -struct meta_ctor_node { - using size_type = std::size_t; - - size_type arity{0u}; - meta_type (*arg)(const meta_ctx &, const size_type) noexcept {}; - meta_any (*invoke)(const meta_ctx &, meta_any *const){}; -}; - -struct meta_dtor_node { - void (*dtor)(void *){}; -}; - -struct meta_data_node { - using size_type = std::size_t; - - meta_traits traits{meta_traits::is_none}; - size_type arity{0u}; - meta_type_node (*type)(const meta_context &) noexcept {}; - meta_type (*arg)(const meta_ctx &, const size_type) noexcept {}; - bool (*set)(meta_handle, meta_any){}; - meta_any (*get)(const meta_ctx &, meta_handle){}; - meta_custom_node custom{}; - dense_map prop{}; -}; - -struct meta_func_node { - using size_type = std::size_t; - - meta_traits traits{meta_traits::is_none}; - size_type arity{0u}; - meta_type_node (*ret)(const meta_context &) noexcept {}; - meta_type (*arg)(const meta_ctx &, const size_type) noexcept {}; - meta_any (*invoke)(const meta_ctx &, meta_handle, meta_any *const){}; - std::shared_ptr next{}; - meta_custom_node custom{}; - dense_map prop{}; -}; - -struct meta_template_node { - using size_type = std::size_t; - - size_type arity{0u}; - meta_type_node (*type)(const meta_context &) noexcept {}; - meta_type_node (*arg)(const meta_context &, const size_type) noexcept {}; -}; - -struct meta_type_descriptor { - dense_map ctor{}; - dense_map base{}; - dense_map conv{}; - dense_map data{}; - dense_map func{}; - dense_map prop{}; -}; - -struct meta_type_node { - using size_type = std::size_t; - - const type_info *info{}; - id_type id{}; - meta_traits traits{meta_traits::is_none}; - size_type size_of{0u}; - meta_type_node (*resolve)(const meta_context &) noexcept {}; - meta_type_node (*remove_pointer)(const meta_context &) noexcept {}; - meta_any (*default_constructor)(const meta_ctx &){}; - double (*conversion_helper)(void *, const void *){}; - meta_any (*from_void)(const meta_ctx &, void *, const void *){}; - meta_template_node templ{}; - meta_dtor_node dtor{}; - meta_custom_node custom{}; - std::shared_ptr details{}; -}; - -template -auto *look_for(const meta_context &context, const meta_type_node &node, const id_type id) { - if(node.details) { - if(const auto it = (node.details.get()->*Member).find(id); it != (node.details.get()->*Member).cend()) { - return &it->second; - } - - for(auto &&curr: node.details->base) { - if(auto *elem = look_for(context, curr.second.type(context), id); elem) { - return elem; - } - } - } - - return static_cast*Member)>::mapped_type *>(nullptr); -} - -template -meta_type_node resolve(const meta_context &) noexcept; - -template -[[nodiscard]] auto meta_arg_node(const meta_context &context, type_list, [[maybe_unused]] const std::size_t index) noexcept { - [[maybe_unused]] std::size_t pos{}; - meta_type_node (*value)(const meta_context &) noexcept = nullptr; - ((value = (pos++ == index ? &resolve>> : value)), ...); - ENTT_ASSERT(value != nullptr, "Out of bounds"); - return value(context); -} - -[[nodiscard]] inline const void *try_cast(const meta_context &context, const meta_type_node &from, const meta_type_node &to, const void *instance) noexcept { - if(from.info && to.info && *from.info == *to.info) { - return instance; - } - - if(from.details) { - for(auto &&curr: from.details->base) { - if(const void *elem = try_cast(context, curr.second.type(context), to, curr.second.cast(instance)); elem) { - return elem; - } - } - } - - return nullptr; -} - -template -[[nodiscard]] inline auto try_convert(const meta_context &context, const meta_type_node &from, const type_info &to, const bool arithmetic_or_enum, const void *instance, Func func) { - if(from.info && *from.info == to) { - return func(instance, from); - } - - if(from.details) { - if(auto it = from.details->conv.find(to.hash()); it != from.details->conv.cend()) { - return func(instance, it->second); - } - - for(auto &&curr: from.details->base) { - if(auto other = try_convert(context, curr.second.type(context), to, arithmetic_or_enum, curr.second.cast(instance), func); other) { - return other; - } - } - } - - if(from.conversion_helper && arithmetic_or_enum) { - return func(instance, from.conversion_helper); - } - - return func(instance); -} - -[[nodiscard]] inline const meta_type_node *try_resolve(const meta_context &context, const type_info &info) noexcept { - const auto it = context.value.find(info.hash()); - return it != context.value.end() ? &it->second : nullptr; -} - -template -[[nodiscard]] meta_type_node resolve(const meta_context &context) noexcept { - static_assert(std::is_same_v>>, "Invalid type"); - - if(auto *elem = try_resolve(context, type_id()); elem) { - return *elem; - } - - meta_type_node node{ - &type_id(), - type_id().hash(), - (std::is_arithmetic_v ? meta_traits::is_arithmetic : meta_traits::is_none) - | (std::is_integral_v ? meta_traits::is_integral : meta_traits::is_none) - | (std::is_signed_v ? meta_traits::is_signed : meta_traits::is_none) - | (std::is_array_v ? meta_traits::is_array : meta_traits::is_none) - | (std::is_enum_v ? meta_traits::is_enum : meta_traits::is_none) - | (std::is_class_v ? meta_traits::is_class : meta_traits::is_none) - | (std::is_pointer_v ? meta_traits::is_pointer : meta_traits::is_none) - | (is_meta_pointer_like_v ? meta_traits::is_meta_pointer_like : meta_traits::is_none) - | (is_complete_v> ? meta_traits::is_meta_sequence_container : meta_traits::is_none) - | (is_complete_v> ? meta_traits::is_meta_associative_container : meta_traits::is_none), - size_of_v, - &resolve, - &resolve>>}; - - if constexpr(std::is_default_constructible_v) { - node.default_constructor = +[](const meta_ctx &ctx) { - return meta_any{ctx, std::in_place_type}; - }; - } - - if constexpr(std::is_arithmetic_v) { - node.conversion_helper = +[](void *lhs, const void *rhs) { - return lhs ? static_cast(*static_cast(lhs) = static_cast(*static_cast(rhs))) : static_cast(*static_cast(rhs)); - }; - } else if constexpr(std::is_enum_v) { - node.conversion_helper = +[](void *lhs, const void *rhs) { - return lhs ? static_cast(*static_cast(lhs) = static_cast(static_cast>(*static_cast(rhs)))) : static_cast(*static_cast(rhs)); - }; - } - - if constexpr(!std::is_void_v && !std::is_function_v) { - node.from_void = +[](const meta_ctx &ctx, void *elem, const void *celem) { - if(elem) { - return meta_any{ctx, std::in_place_type &>, *static_cast *>(elem)}; - } - - return meta_any{ctx, std::in_place_type &>, *static_cast *>(celem)}; - }; - } - - if constexpr(is_complete_v>) { - node.templ = meta_template_node{ - meta_template_traits::args_type::size, - &resolve::class_type>, - +[](const meta_context &area, const std::size_t index) noexcept { return meta_arg_node(area, typename meta_template_traits::args_type{}, index); }}; - } - - return node; -} - -} // namespace internal -/*! @endcond */ - -} // namespace entt - -#endif -- cgit