diff --git a/CMakeLists.txt b/CMakeLists.txt index ef3f146..a08a874 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,10 +9,7 @@ endif() project(meta.hpp) -add_subdirectory(vendors/enum.hpp) - add_library(${PROJECT_NAME} INTERFACE) -target_link_libraries(${PROJECT_NAME} INTERFACE enum.hpp) target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_20) target_include_directories(${PROJECT_NAME} INTERFACE headers) diff --git a/headers/meta.hpp/meta_all.hpp b/headers/meta.hpp/meta_all.hpp index feea92d..0a44744 100644 --- a/headers/meta.hpp/meta_all.hpp +++ b/headers/meta.hpp/meta_all.hpp @@ -13,7 +13,15 @@ #include "meta_binds/enum_bind.hpp" #include "meta_binds/scope_bind.hpp" -#include "meta_kinds.hpp" +#include "meta_indices.hpp" +#include "meta_indices/ctor_index.hpp" +#include "meta_indices/dtor_index.hpp" +#include "meta_indices/evalue_index.hpp" +#include "meta_indices/function_index.hpp" +#include "meta_indices/member_index.hpp" +#include "meta_indices/method_index.hpp" +#include "meta_indices/scope_index.hpp" +#include "meta_indices/variable_index.hpp" #include "meta_states.hpp" #include "meta_states/ctor.hpp" @@ -25,19 +33,6 @@ #include "meta_states/scope.hpp" #include "meta_states/variable.hpp" -#include "meta_traits.hpp" -#include "meta_traits/array_traits.hpp" -#include "meta_traits/class_traits.hpp" -#include "meta_traits/ctor_traits.hpp" -#include "meta_traits/dtor_traits.hpp" -#include "meta_traits/enum_traits.hpp" -#include "meta_traits/function_traits.hpp" -#include "meta_traits/member_traits.hpp" -#include "meta_traits/method_traits.hpp" -#include "meta_traits/number_traits.hpp" -#include "meta_traits/pointer_traits.hpp" -#include "meta_traits/reference_traits.hpp" - #include "meta_types.hpp" #include "meta_types/any_type.hpp" #include "meta_types/array_type.hpp" @@ -54,8 +49,14 @@ #include "meta_types/reference_type.hpp" #include "meta_types/void_type.hpp" -#include "meta_utilities.hpp" -#include "meta_utilities/arg.hpp" -#include "meta_utilities/inst.hpp" -#include "meta_utilities/value.hpp" -#include "meta_utilities/vinvoke.hpp" +#include "meta_value.hpp" +#include "meta_value/value.hpp" +#include "meta_value/vinvoke.hpp" + +namespace meta_hpp +{ + using detail::resolve_type; + using detail::resolve_polymorphic_type; + + using detail::resolve_scope; +} diff --git a/headers/meta.hpp/meta_base.hpp b/headers/meta.hpp/meta_base.hpp index 1cc4877..24c5330 100644 --- a/headers/meta.hpp/meta_base.hpp +++ b/headers/meta.hpp/meta_base.hpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -25,47 +26,34 @@ #include #include #include +#include +#include #include #include #include -#include -#include +#include "meta_base/cvref_traits.hpp" +#include "meta_base/enum_bitflags.hpp" +#include "meta_base/enum.hpp" +#include "meta_base/noncopyable.hpp" +#include "meta_base/overloaded.hpp" +#include "meta_base/select_overload.hpp" +#include "meta_base/stdex.hpp" +#include "meta_base/type_id.hpp" +#include "meta_base/type_kinds.hpp" +#include "meta_base/type_list.hpp" namespace meta_hpp { - template < typename Enum > - using bitflags = enum_hpp::bitflags::bitflags; -} + using detail::select_const; + using detail::select_non_const; + using detail::select_overload; -namespace meta_hpp -{ - template < typename Signature > - constexpr auto select(Signature* func) noexcept -> Signature* { - return func; - } + using detail::type_id; + using detail::type_kind; + using detail::type_list; - template < typename Signature, typename Class > - constexpr auto select(Signature Class::*func) noexcept -> Signature Class::* { - return func; - } - - namespace detail - { - template < typename... Types > - struct type_list {}; - - template < std::size_t Index, typename TypeList > - struct type_list_at; - - template < std::size_t Index, typename... Types > - struct type_list_at> { - using type = std::tuple_element_t>; - }; - - template < std::size_t Index, typename TypeList > - using type_list_at_t = typename type_list_at::type; - } + using enum_hpp::bitflags::bitflags; } namespace meta_hpp @@ -168,14 +156,14 @@ namespace meta_hpp namespace meta_hpp { - struct ctor_index; - struct dtor_index; - struct evalue_index; - struct function_index; - struct member_index; - struct method_index; - struct scope_index; - struct variable_index; + class ctor_index; + class dtor_index; + class evalue_index; + class function_index; + class member_index; + class method_index; + class scope_index; + class variable_index; using class_set = std::set>; using class_map = std::map>; @@ -192,50 +180,3 @@ namespace meta_hpp using scope_map = std::map>; using variable_map = std::map>; } - -namespace meta_hpp::detail::stdex -{ - template < typename T > - [[nodiscard]] constexpr std::underlying_type_t to_underlying(T v) noexcept { - return static_cast>(v); - } -} - -namespace meta_hpp::detail::stdex -{ - template < typename T, typename U > - concept same_as = - std::is_same_v && - std::is_same_v; - - template < typename Derived, typename Base > - concept derived_from = - std::is_base_of_v && - std::is_convertible_v; - - template < typename From, typename To > - concept convertible_to = - std::is_convertible_v && - requires { static_cast(std::declval()); }; - - template < typename T > - concept destructible = - std::is_nothrow_destructible_v; - - template < typename T, typename... Args > - concept constructible_from = - destructible && - std::is_constructible_v; - - template < typename T > - concept move_constructible = - constructible_from && - convertible_to; - - template - concept copy_constructible = - move_constructible && - constructible_from && convertible_to && - constructible_from && convertible_to && - constructible_from && convertible_to; -} diff --git a/headers/meta.hpp/meta_base/cvref_traits.hpp b/headers/meta.hpp/meta_base/cvref_traits.hpp new file mode 100644 index 0000000..743bba1 --- /dev/null +++ b/headers/meta.hpp/meta_base/cvref_traits.hpp @@ -0,0 +1,39 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include + +namespace meta_hpp::detail +{ + template < typename From > + struct cvref_traits { + static constexpr bool is_lvalue = std::is_lvalue_reference_v; + static constexpr bool is_rvalue = std::is_rvalue_reference_v; + static constexpr bool is_const = std::is_const_v>; + static constexpr bool is_volatile = std::is_volatile_v>; + + template < bool yesno, template < typename > typename Q, typename V > + using apply_t_if = std::conditional_t, V>; + + template < typename To > + using copy_to = + apply_t_if>>>>; + }; + + template < typename From, typename To > + struct copy_cvref { + using type = typename cvref_traits::template copy_to; + }; + + template < typename From, typename To > + using copy_cvref_t = typename copy_cvref::type; +} diff --git a/headers/meta.hpp/meta_base/enum.hpp b/headers/meta.hpp/meta_base/enum.hpp new file mode 100644 index 0000000..6cbe035 --- /dev/null +++ b/headers/meta.hpp/meta_base/enum.hpp @@ -0,0 +1,1436 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/enum.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2019-2022, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND) +# define ENUM_HPP_NO_EXCEPTIONS +#endif + +namespace enum_hpp +{ + constexpr std::size_t invalid_index = std::size_t(-1); + constexpr std::string_view empty_string = std::string_view(); + + class exception final : public std::runtime_error { + public: + explicit exception(const char* what) + : std::runtime_error(what) {} + }; +} + +namespace enum_hpp +{ + template < typename Enum > + using traits_t = decltype(enum_hpp_adl_find_registered_traits(std::declval())); + + template < typename Enum > + using underlying_type = typename traits_t::underlying_type; + + template < typename Enum > + constexpr std::size_t size() noexcept { + return traits_t::size; + } + + template < typename Enum > + constexpr const std::array()>& values() noexcept { + return traits_t::values; + } + + template < typename Enum > + constexpr const std::array()>& names() noexcept { + return traits_t::names; + } + + template < typename Enum > + constexpr typename traits_t::underlying_type to_underlying(Enum e) noexcept { + return traits_t::to_underlying(e); + } + + template < typename Enum > + constexpr std::optional to_string(Enum e) noexcept { + return traits_t::to_string(e); + } + + template < typename Enum > + constexpr std::string_view to_string_or_empty(Enum e) noexcept { + return traits_t::to_string_or_empty(e); + } + + template < typename Enum > + std::string_view to_string_or_throw(Enum e) { + return traits_t::to_string_or_throw(e); + } + + template < typename Enum > + constexpr std::optional from_string(std::string_view name) noexcept { + return traits_t::from_string(name); + } + + template < typename Enum > + constexpr Enum from_string_or_default(std::string_view name, Enum def) noexcept { + return traits_t::from_string_or_default(name, def); + } + + template < typename Enum > + Enum from_string_or_throw(std::string_view name) { + return traits_t::from_string_or_throw(name); + } + + template < typename Enum > + constexpr std::optional to_index(Enum e) noexcept { + return traits_t::to_index(e); + } + + template < typename Enum > + constexpr std::size_t to_index_or_invalid(Enum e) noexcept { + return traits_t::to_index_or_invalid(e); + } + + template < typename Enum > + std::size_t to_index_or_throw(Enum e) { + return traits_t::to_index_or_throw(e); + } + + template < typename Enum > + constexpr std::optional from_index(std::size_t index) noexcept { + return traits_t::from_index(index); + } + + template < typename Enum > + constexpr Enum from_index_or_default(std::size_t index, Enum def) noexcept { + return traits_t::from_index_or_default(index, def); + } + + template < typename Enum > + Enum from_index_or_throw(std::size_t index) { + return traits_t::from_index_or_throw(index); + } +} + +namespace enum_hpp::detail +{ + inline void throw_exception_with [[noreturn]] (const char* what) { + #ifndef ENUM_HPP_NO_EXCEPTIONS + throw ::enum_hpp::exception(what); + #else + (void)what; + std::abort(); + #endif + } + + template < typename Enum > + struct ignore_assign final { + Enum value; + + constexpr explicit ignore_assign(Enum value) noexcept + : value(value) {} + + template < typename Other > + // NOLINTNEXTLINE(readability-named-parameter) + constexpr ignore_assign& operator=(const Other&) noexcept { + return *this; + } + }; + + constexpr bool is_end_of_name(char ch) noexcept { + switch ( ch ) { + case ' ': + case '=': + case '\r': + case '\n': + case '\t': + return true; + default: + return false; + } + } + + constexpr std::string_view trim_raw_name(std::string_view raw_name) noexcept { + for ( std::size_t i = 0; i < raw_name.size(); ++i ) { + if ( is_end_of_name(raw_name[i]) ) { + return raw_name.substr(0, i); + } + } + return raw_name; + } +} + +// +// ENUM_HPP_GENERATE_FIELDS +// + +#define ENUM_HPP_GENERATE_FIELDS_OP(d, i, x)\ + x, + +#define ENUM_HPP_GENERATE_FIELDS(Fields)\ + ENUM_HPP_PP_SEQ_FOR_EACH(ENUM_HPP_GENERATE_FIELDS_OP, _, Fields) + +// +// ENUM_HPP_GENERATE_VALUES +// + +#define ENUM_HPP_GENERATE_VALUES_OP(Enum, i, x)\ + ((::enum_hpp::detail::ignore_assign)Enum::x).value, + +#define ENUM_HPP_GENERATE_VALUES(Enum, Fields)\ + ENUM_HPP_PP_SEQ_FOR_EACH(ENUM_HPP_GENERATE_VALUES_OP, Enum, Fields) + +// +// ENUM_HPP_GENERATE_NAMES +// + +#define ENUM_HPP_GENERATE_NAMES_OP(d, i, x)\ + ::enum_hpp::detail::trim_raw_name(ENUM_HPP_PP_STRINGIZE(x)), + +#define ENUM_HPP_GENERATE_NAMES(Fields)\ + ENUM_HPP_PP_SEQ_FOR_EACH(ENUM_HPP_GENERATE_NAMES_OP, _, Fields) + +// +// ENUM_HPP_GENERATE_VALUE_TO_NAME_CASES +// + +#define ENUM_HPP_GENERATE_VALUE_TO_NAME_CASES_OP(Enum, i, x)\ + case values[i]: return names[i]; + +#define ENUM_HPP_GENERATE_VALUE_TO_NAME_CASES(Enum, Fields)\ + ENUM_HPP_PP_SEQ_FOR_EACH(ENUM_HPP_GENERATE_VALUE_TO_NAME_CASES_OP, Enum, Fields) + +// +// ENUM_HPP_GENERATE_VALUE_TO_INDEX_CASES +// + +#define ENUM_HPP_GENERATE_VALUE_TO_INDEX_CASES_OP(Enum, i, x)\ + case values[i]: return i; + +#define ENUM_HPP_GENERATE_VALUE_TO_INDEX_CASES(Enum, Fields)\ + ENUM_HPP_PP_SEQ_FOR_EACH(ENUM_HPP_GENERATE_VALUE_TO_INDEX_CASES_OP, Enum, Fields) + +// +// ENUM_HPP_DECL +// + +#define ENUM_HPP_DECL(Enum, Type, Fields)\ + enum Enum : Type {\ + ENUM_HPP_GENERATE_FIELDS(Fields)\ + };\ + ENUM_HPP_TRAITS_DECL(Enum, Fields) + +// +// ENUM_HPP_CLASS_DECL +// + +#define ENUM_HPP_CLASS_DECL(Enum, Type, Fields)\ + enum class Enum : Type {\ + ENUM_HPP_GENERATE_FIELDS(Fields)\ + };\ + ENUM_HPP_TRAITS_DECL(Enum, Fields) + +// +// ENUM_HPP_TRAITS_DECL +// + +#define ENUM_HPP_TRAITS_DECL(Enum, Fields)\ + struct Enum##_traits final {\ + private:\ + enum enum_names_for_this_score_ {\ + ENUM_HPP_GENERATE_FIELDS(Fields)\ + };\ + public:\ + using enum_type = Enum;\ + using underlying_type = std::underlying_type_t;\ + static constexpr std::size_t size = ENUM_HPP_PP_SEQ_SIZE(Fields);\ + \ + static constexpr const std::array values = {\ + { ENUM_HPP_GENERATE_VALUES(Enum, Fields) }\ + };\ + \ + static constexpr const std::array names = {\ + { ENUM_HPP_GENERATE_NAMES(Fields) }\ + };\ + public:\ + [[maybe_unused]] static constexpr underlying_type to_underlying(enum_type e) noexcept {\ + return static_cast(e);\ + }\ + [[maybe_unused]] static constexpr std::optional to_string(enum_type e) noexcept {\ + switch ( e ) {\ + ENUM_HPP_GENERATE_VALUE_TO_NAME_CASES(Enum, Fields)\ + default: return std::nullopt;\ + }\ + }\ + [[maybe_unused]] static constexpr std::string_view to_string_or_empty(enum_type e) noexcept {\ + if ( auto s = to_string(e) ) {\ + return *s;\ + }\ + return ::enum_hpp::empty_string;\ + }\ + [[maybe_unused]] static std::string_view to_string_or_throw(enum_type e) {\ + if ( auto s = to_string(e) ) {\ + return *s;\ + }\ + ::enum_hpp::detail::throw_exception_with(#Enum "_traits::to_string_or_throw(): invalid argument");\ + }\ + [[maybe_unused]] static constexpr std::optional from_string(std::string_view name) noexcept {\ + for ( std::size_t i = 0; i < size; ++i) {\ + if ( name == names[i] ) {\ + return values[i];\ + }\ + }\ + return std::nullopt;\ + }\ + [[maybe_unused]] static constexpr enum_type from_string_or_default(std::string_view name, enum_type def) noexcept {\ + if ( auto e = from_string(name) ) {\ + return *e;\ + }\ + return def;\ + }\ + [[maybe_unused]] static enum_type from_string_or_throw(std::string_view name) {\ + if ( auto e = from_string(name) ) {\ + return *e;\ + }\ + ::enum_hpp::detail::throw_exception_with(#Enum "_traits::from_string_or_throw(): invalid argument");\ + }\ + [[maybe_unused]] static constexpr std::optional to_index(enum_type e) noexcept {\ + switch ( e ) {\ + ENUM_HPP_GENERATE_VALUE_TO_INDEX_CASES(Enum, Fields)\ + default: return std::nullopt;\ + }\ + }\ + [[maybe_unused]] static constexpr std::size_t to_index_or_invalid(enum_type e) noexcept {\ + if ( auto i = to_index(e) ) {\ + return *i;\ + }\ + return ::enum_hpp::invalid_index;\ + }\ + [[maybe_unused]] static std::size_t to_index_or_throw(enum_type e) {\ + if ( auto i = to_index(e) ) {\ + return *i;\ + }\ + ::enum_hpp::detail::throw_exception_with(#Enum "_traits::to_index_or_throw(): invalid argument");\ + }\ + [[maybe_unused]] static constexpr std::optional from_index(std::size_t index) noexcept {\ + if ( index < size ) {\ + return values[index];\ + }\ + return std::nullopt;\ + }\ + [[maybe_unused]] static constexpr enum_type from_index_or_default(std::size_t index, enum_type def) noexcept {\ + if ( auto e = from_index(index) ) {\ + return *e;\ + }\ + return def;\ + }\ + [[maybe_unused]] static enum_type from_index_or_throw(std::size_t index) {\ + if ( auto e = from_index(index) ) {\ + return *e;\ + }\ + ::enum_hpp::detail::throw_exception_with(#Enum "_traits::from_index_or_throw(): invalid argument");\ + }\ + }; + +// +// ENUM_HPP_REGISTER_TRAITS +// + +#define ENUM_HPP_REGISTER_TRAITS(Enum)\ + constexpr Enum##_traits enum_hpp_adl_find_registered_traits [[maybe_unused]] (Enum) noexcept {\ + return Enum##_traits{};\ + } + +// ----------------------------------------------------------------------------- +// +// ENUM_HPP_PP +// +// ----------------------------------------------------------------------------- + +// +// ENUM_HPP_PP_CAT +// + +#define ENUM_HPP_PP_CAT(x, y) ENUM_HPP_PP_CAT_I(x, y) +#define ENUM_HPP_PP_CAT_I(x, y) x ## y + +// +// ENUM_HPP_PP_STRINGIZE +// + +#define ENUM_HPP_PP_STRINGIZE(x) ENUM_HPP_PP_STRINGIZE_I(x) +#define ENUM_HPP_PP_STRINGIZE_I(x) #x + +// +// ENUM_HPP_PP_SEQ_HEAD +// + +#define ENUM_HPP_PP_SEQ_HEAD(seq) ENUM_HPP_PP_SEQ_HEAD_II((ENUM_HPP_PP_SEQ_HEAD_I seq)) +#define ENUM_HPP_PP_SEQ_HEAD_I(x) x, ENUM_HPP_PP_NOTHING +#define ENUM_HPP_PP_SEQ_HEAD_II(p) ENUM_HPP_PP_SEQ_HEAD_III p +#define ENUM_HPP_PP_SEQ_HEAD_III(x, _) x + +// +// ENUM_HPP_PP_SEQ_TAIL +// + +#define ENUM_HPP_PP_SEQ_TAIL(seq) ENUM_HPP_PP_SEQ_TAIL_I seq +#define ENUM_HPP_PP_SEQ_TAIL_I(_) + +// +// ENUM_HPP_PP_INC +// + +#define ENUM_HPP_PP_INC(x) ENUM_HPP_PP_INC_I(x) +#define ENUM_HPP_PP_INC_I(x) ENUM_HPP_PP_INC_ ## x + +#define ENUM_HPP_PP_INC_0 1 +#define ENUM_HPP_PP_INC_1 2 +#define ENUM_HPP_PP_INC_2 3 +#define ENUM_HPP_PP_INC_3 4 +#define ENUM_HPP_PP_INC_4 5 +#define ENUM_HPP_PP_INC_5 6 +#define ENUM_HPP_PP_INC_6 7 +#define ENUM_HPP_PP_INC_7 8 +#define ENUM_HPP_PP_INC_8 9 +#define ENUM_HPP_PP_INC_9 10 +#define ENUM_HPP_PP_INC_10 11 +#define ENUM_HPP_PP_INC_11 12 +#define ENUM_HPP_PP_INC_12 13 +#define ENUM_HPP_PP_INC_13 14 +#define ENUM_HPP_PP_INC_14 15 +#define ENUM_HPP_PP_INC_15 16 +#define ENUM_HPP_PP_INC_16 17 +#define ENUM_HPP_PP_INC_17 18 +#define ENUM_HPP_PP_INC_18 19 +#define ENUM_HPP_PP_INC_19 20 +#define ENUM_HPP_PP_INC_20 21 +#define ENUM_HPP_PP_INC_21 22 +#define ENUM_HPP_PP_INC_22 23 +#define ENUM_HPP_PP_INC_23 24 +#define ENUM_HPP_PP_INC_24 25 +#define ENUM_HPP_PP_INC_25 26 +#define ENUM_HPP_PP_INC_26 27 +#define ENUM_HPP_PP_INC_27 28 +#define ENUM_HPP_PP_INC_28 29 +#define ENUM_HPP_PP_INC_29 30 +#define ENUM_HPP_PP_INC_30 31 +#define ENUM_HPP_PP_INC_31 32 +#define ENUM_HPP_PP_INC_32 33 +#define ENUM_HPP_PP_INC_33 34 +#define ENUM_HPP_PP_INC_34 35 +#define ENUM_HPP_PP_INC_35 36 +#define ENUM_HPP_PP_INC_36 37 +#define ENUM_HPP_PP_INC_37 38 +#define ENUM_HPP_PP_INC_38 39 +#define ENUM_HPP_PP_INC_39 40 +#define ENUM_HPP_PP_INC_40 41 +#define ENUM_HPP_PP_INC_41 42 +#define ENUM_HPP_PP_INC_42 43 +#define ENUM_HPP_PP_INC_43 44 +#define ENUM_HPP_PP_INC_44 45 +#define ENUM_HPP_PP_INC_45 46 +#define ENUM_HPP_PP_INC_46 47 +#define ENUM_HPP_PP_INC_47 48 +#define ENUM_HPP_PP_INC_48 49 +#define ENUM_HPP_PP_INC_49 50 +#define ENUM_HPP_PP_INC_50 51 +#define ENUM_HPP_PP_INC_51 52 +#define ENUM_HPP_PP_INC_52 53 +#define ENUM_HPP_PP_INC_53 54 +#define ENUM_HPP_PP_INC_54 55 +#define ENUM_HPP_PP_INC_55 56 +#define ENUM_HPP_PP_INC_56 57 +#define ENUM_HPP_PP_INC_57 58 +#define ENUM_HPP_PP_INC_58 59 +#define ENUM_HPP_PP_INC_59 60 +#define ENUM_HPP_PP_INC_60 61 +#define ENUM_HPP_PP_INC_61 62 +#define ENUM_HPP_PP_INC_62 63 +#define ENUM_HPP_PP_INC_63 64 +#define ENUM_HPP_PP_INC_64 65 +#define ENUM_HPP_PP_INC_65 66 +#define ENUM_HPP_PP_INC_66 67 +#define ENUM_HPP_PP_INC_67 68 +#define ENUM_HPP_PP_INC_68 69 +#define ENUM_HPP_PP_INC_69 70 +#define ENUM_HPP_PP_INC_70 71 +#define ENUM_HPP_PP_INC_71 72 +#define ENUM_HPP_PP_INC_72 73 +#define ENUM_HPP_PP_INC_73 74 +#define ENUM_HPP_PP_INC_74 75 +#define ENUM_HPP_PP_INC_75 76 +#define ENUM_HPP_PP_INC_76 77 +#define ENUM_HPP_PP_INC_77 78 +#define ENUM_HPP_PP_INC_78 79 +#define ENUM_HPP_PP_INC_79 80 +#define ENUM_HPP_PP_INC_80 81 +#define ENUM_HPP_PP_INC_81 82 +#define ENUM_HPP_PP_INC_82 83 +#define ENUM_HPP_PP_INC_83 84 +#define ENUM_HPP_PP_INC_84 85 +#define ENUM_HPP_PP_INC_85 86 +#define ENUM_HPP_PP_INC_86 87 +#define ENUM_HPP_PP_INC_87 88 +#define ENUM_HPP_PP_INC_88 89 +#define ENUM_HPP_PP_INC_89 90 +#define ENUM_HPP_PP_INC_90 91 +#define ENUM_HPP_PP_INC_91 92 +#define ENUM_HPP_PP_INC_92 93 +#define ENUM_HPP_PP_INC_93 94 +#define ENUM_HPP_PP_INC_94 95 +#define ENUM_HPP_PP_INC_95 96 +#define ENUM_HPP_PP_INC_96 97 +#define ENUM_HPP_PP_INC_97 98 +#define ENUM_HPP_PP_INC_98 99 +#define ENUM_HPP_PP_INC_99 100 +#define ENUM_HPP_PP_INC_100 101 +#define ENUM_HPP_PP_INC_101 102 +#define ENUM_HPP_PP_INC_102 103 +#define ENUM_HPP_PP_INC_103 104 +#define ENUM_HPP_PP_INC_104 105 +#define ENUM_HPP_PP_INC_105 106 +#define ENUM_HPP_PP_INC_106 107 +#define ENUM_HPP_PP_INC_107 108 +#define ENUM_HPP_PP_INC_108 109 +#define ENUM_HPP_PP_INC_109 110 +#define ENUM_HPP_PP_INC_110 111 +#define ENUM_HPP_PP_INC_111 112 +#define ENUM_HPP_PP_INC_112 113 +#define ENUM_HPP_PP_INC_113 114 +#define ENUM_HPP_PP_INC_114 115 +#define ENUM_HPP_PP_INC_115 116 +#define ENUM_HPP_PP_INC_116 117 +#define ENUM_HPP_PP_INC_117 118 +#define ENUM_HPP_PP_INC_118 119 +#define ENUM_HPP_PP_INC_119 120 +#define ENUM_HPP_PP_INC_120 121 +#define ENUM_HPP_PP_INC_121 122 +#define ENUM_HPP_PP_INC_122 123 +#define ENUM_HPP_PP_INC_123 124 +#define ENUM_HPP_PP_INC_124 125 +#define ENUM_HPP_PP_INC_125 126 +#define ENUM_HPP_PP_INC_126 127 +#define ENUM_HPP_PP_INC_127 128 +#define ENUM_HPP_PP_INC_128 129 +#define ENUM_HPP_PP_INC_129 130 +#define ENUM_HPP_PP_INC_130 131 +#define ENUM_HPP_PP_INC_131 132 +#define ENUM_HPP_PP_INC_132 133 +#define ENUM_HPP_PP_INC_133 134 +#define ENUM_HPP_PP_INC_134 135 +#define ENUM_HPP_PP_INC_135 136 +#define ENUM_HPP_PP_INC_136 137 +#define ENUM_HPP_PP_INC_137 138 +#define ENUM_HPP_PP_INC_138 139 +#define ENUM_HPP_PP_INC_139 140 +#define ENUM_HPP_PP_INC_140 141 +#define ENUM_HPP_PP_INC_141 142 +#define ENUM_HPP_PP_INC_142 143 +#define ENUM_HPP_PP_INC_143 144 +#define ENUM_HPP_PP_INC_144 145 +#define ENUM_HPP_PP_INC_145 146 +#define ENUM_HPP_PP_INC_146 147 +#define ENUM_HPP_PP_INC_147 148 +#define ENUM_HPP_PP_INC_148 149 +#define ENUM_HPP_PP_INC_149 150 +#define ENUM_HPP_PP_INC_150 151 +#define ENUM_HPP_PP_INC_151 152 +#define ENUM_HPP_PP_INC_152 153 +#define ENUM_HPP_PP_INC_153 154 +#define ENUM_HPP_PP_INC_154 155 +#define ENUM_HPP_PP_INC_155 156 +#define ENUM_HPP_PP_INC_156 157 +#define ENUM_HPP_PP_INC_157 158 +#define ENUM_HPP_PP_INC_158 159 +#define ENUM_HPP_PP_INC_159 160 +#define ENUM_HPP_PP_INC_160 161 +#define ENUM_HPP_PP_INC_161 162 +#define ENUM_HPP_PP_INC_162 163 +#define ENUM_HPP_PP_INC_163 164 +#define ENUM_HPP_PP_INC_164 165 +#define ENUM_HPP_PP_INC_165 166 +#define ENUM_HPP_PP_INC_166 167 +#define ENUM_HPP_PP_INC_167 168 +#define ENUM_HPP_PP_INC_168 169 +#define ENUM_HPP_PP_INC_169 170 +#define ENUM_HPP_PP_INC_170 171 +#define ENUM_HPP_PP_INC_171 172 +#define ENUM_HPP_PP_INC_172 173 +#define ENUM_HPP_PP_INC_173 174 +#define ENUM_HPP_PP_INC_174 175 +#define ENUM_HPP_PP_INC_175 176 +#define ENUM_HPP_PP_INC_176 177 +#define ENUM_HPP_PP_INC_177 178 +#define ENUM_HPP_PP_INC_178 179 +#define ENUM_HPP_PP_INC_179 180 +#define ENUM_HPP_PP_INC_180 181 +#define ENUM_HPP_PP_INC_181 182 +#define ENUM_HPP_PP_INC_182 183 +#define ENUM_HPP_PP_INC_183 184 +#define ENUM_HPP_PP_INC_184 185 +#define ENUM_HPP_PP_INC_185 186 +#define ENUM_HPP_PP_INC_186 187 +#define ENUM_HPP_PP_INC_187 188 +#define ENUM_HPP_PP_INC_188 189 +#define ENUM_HPP_PP_INC_189 190 +#define ENUM_HPP_PP_INC_190 191 +#define ENUM_HPP_PP_INC_191 192 +#define ENUM_HPP_PP_INC_192 193 +#define ENUM_HPP_PP_INC_193 194 +#define ENUM_HPP_PP_INC_194 195 +#define ENUM_HPP_PP_INC_195 196 +#define ENUM_HPP_PP_INC_196 197 +#define ENUM_HPP_PP_INC_197 198 +#define ENUM_HPP_PP_INC_198 199 +#define ENUM_HPP_PP_INC_199 200 +#define ENUM_HPP_PP_INC_200 201 +#define ENUM_HPP_PP_INC_201 202 +#define ENUM_HPP_PP_INC_202 203 +#define ENUM_HPP_PP_INC_203 204 +#define ENUM_HPP_PP_INC_204 205 +#define ENUM_HPP_PP_INC_205 206 +#define ENUM_HPP_PP_INC_206 207 +#define ENUM_HPP_PP_INC_207 208 +#define ENUM_HPP_PP_INC_208 209 +#define ENUM_HPP_PP_INC_209 210 +#define ENUM_HPP_PP_INC_210 211 +#define ENUM_HPP_PP_INC_211 212 +#define ENUM_HPP_PP_INC_212 213 +#define ENUM_HPP_PP_INC_213 214 +#define ENUM_HPP_PP_INC_214 215 +#define ENUM_HPP_PP_INC_215 216 +#define ENUM_HPP_PP_INC_216 217 +#define ENUM_HPP_PP_INC_217 218 +#define ENUM_HPP_PP_INC_218 219 +#define ENUM_HPP_PP_INC_219 220 +#define ENUM_HPP_PP_INC_220 221 +#define ENUM_HPP_PP_INC_221 222 +#define ENUM_HPP_PP_INC_222 223 +#define ENUM_HPP_PP_INC_223 224 +#define ENUM_HPP_PP_INC_224 225 +#define ENUM_HPP_PP_INC_225 226 +#define ENUM_HPP_PP_INC_226 227 +#define ENUM_HPP_PP_INC_227 228 +#define ENUM_HPP_PP_INC_228 229 +#define ENUM_HPP_PP_INC_229 230 +#define ENUM_HPP_PP_INC_230 231 +#define ENUM_HPP_PP_INC_231 232 +#define ENUM_HPP_PP_INC_232 233 +#define ENUM_HPP_PP_INC_233 234 +#define ENUM_HPP_PP_INC_234 235 +#define ENUM_HPP_PP_INC_235 236 +#define ENUM_HPP_PP_INC_236 237 +#define ENUM_HPP_PP_INC_237 238 +#define ENUM_HPP_PP_INC_238 239 +#define ENUM_HPP_PP_INC_239 240 +#define ENUM_HPP_PP_INC_240 241 +#define ENUM_HPP_PP_INC_241 242 +#define ENUM_HPP_PP_INC_242 243 +#define ENUM_HPP_PP_INC_243 244 +#define ENUM_HPP_PP_INC_244 245 +#define ENUM_HPP_PP_INC_245 246 +#define ENUM_HPP_PP_INC_246 247 +#define ENUM_HPP_PP_INC_247 248 +#define ENUM_HPP_PP_INC_248 249 +#define ENUM_HPP_PP_INC_249 250 +#define ENUM_HPP_PP_INC_250 251 +#define ENUM_HPP_PP_INC_251 252 +#define ENUM_HPP_PP_INC_252 253 +#define ENUM_HPP_PP_INC_253 254 +#define ENUM_HPP_PP_INC_254 255 +#define ENUM_HPP_PP_INC_255 256 + +// +// ENUM_HPP_PP_SEQ_SIZE +// + +#define ENUM_HPP_PP_SEQ_SIZE(seq)\ + ENUM_HPP_PP_CAT(ENUM_HPP_PP_SEQ_SIZE_, ENUM_HPP_PP_SEQ_SIZE_0 seq) + +#define ENUM_HPP_PP_SEQ_SIZE_0(_) ENUM_HPP_PP_SEQ_SIZE_1 +#define ENUM_HPP_PP_SEQ_SIZE_1(_) ENUM_HPP_PP_SEQ_SIZE_2 +#define ENUM_HPP_PP_SEQ_SIZE_2(_) ENUM_HPP_PP_SEQ_SIZE_3 +#define ENUM_HPP_PP_SEQ_SIZE_3(_) ENUM_HPP_PP_SEQ_SIZE_4 +#define ENUM_HPP_PP_SEQ_SIZE_4(_) ENUM_HPP_PP_SEQ_SIZE_5 +#define ENUM_HPP_PP_SEQ_SIZE_5(_) ENUM_HPP_PP_SEQ_SIZE_6 +#define ENUM_HPP_PP_SEQ_SIZE_6(_) ENUM_HPP_PP_SEQ_SIZE_7 +#define ENUM_HPP_PP_SEQ_SIZE_7(_) ENUM_HPP_PP_SEQ_SIZE_8 +#define ENUM_HPP_PP_SEQ_SIZE_8(_) ENUM_HPP_PP_SEQ_SIZE_9 +#define ENUM_HPP_PP_SEQ_SIZE_9(_) ENUM_HPP_PP_SEQ_SIZE_10 +#define ENUM_HPP_PP_SEQ_SIZE_10(_) ENUM_HPP_PP_SEQ_SIZE_11 +#define ENUM_HPP_PP_SEQ_SIZE_11(_) ENUM_HPP_PP_SEQ_SIZE_12 +#define ENUM_HPP_PP_SEQ_SIZE_12(_) ENUM_HPP_PP_SEQ_SIZE_13 +#define ENUM_HPP_PP_SEQ_SIZE_13(_) ENUM_HPP_PP_SEQ_SIZE_14 +#define ENUM_HPP_PP_SEQ_SIZE_14(_) ENUM_HPP_PP_SEQ_SIZE_15 +#define ENUM_HPP_PP_SEQ_SIZE_15(_) ENUM_HPP_PP_SEQ_SIZE_16 +#define ENUM_HPP_PP_SEQ_SIZE_16(_) ENUM_HPP_PP_SEQ_SIZE_17 +#define ENUM_HPP_PP_SEQ_SIZE_17(_) ENUM_HPP_PP_SEQ_SIZE_18 +#define ENUM_HPP_PP_SEQ_SIZE_18(_) ENUM_HPP_PP_SEQ_SIZE_19 +#define ENUM_HPP_PP_SEQ_SIZE_19(_) ENUM_HPP_PP_SEQ_SIZE_20 +#define ENUM_HPP_PP_SEQ_SIZE_20(_) ENUM_HPP_PP_SEQ_SIZE_21 +#define ENUM_HPP_PP_SEQ_SIZE_21(_) ENUM_HPP_PP_SEQ_SIZE_22 +#define ENUM_HPP_PP_SEQ_SIZE_22(_) ENUM_HPP_PP_SEQ_SIZE_23 +#define ENUM_HPP_PP_SEQ_SIZE_23(_) ENUM_HPP_PP_SEQ_SIZE_24 +#define ENUM_HPP_PP_SEQ_SIZE_24(_) ENUM_HPP_PP_SEQ_SIZE_25 +#define ENUM_HPP_PP_SEQ_SIZE_25(_) ENUM_HPP_PP_SEQ_SIZE_26 +#define ENUM_HPP_PP_SEQ_SIZE_26(_) ENUM_HPP_PP_SEQ_SIZE_27 +#define ENUM_HPP_PP_SEQ_SIZE_27(_) ENUM_HPP_PP_SEQ_SIZE_28 +#define ENUM_HPP_PP_SEQ_SIZE_28(_) ENUM_HPP_PP_SEQ_SIZE_29 +#define ENUM_HPP_PP_SEQ_SIZE_29(_) ENUM_HPP_PP_SEQ_SIZE_30 +#define ENUM_HPP_PP_SEQ_SIZE_30(_) ENUM_HPP_PP_SEQ_SIZE_31 +#define ENUM_HPP_PP_SEQ_SIZE_31(_) ENUM_HPP_PP_SEQ_SIZE_32 +#define ENUM_HPP_PP_SEQ_SIZE_32(_) ENUM_HPP_PP_SEQ_SIZE_33 +#define ENUM_HPP_PP_SEQ_SIZE_33(_) ENUM_HPP_PP_SEQ_SIZE_34 +#define ENUM_HPP_PP_SEQ_SIZE_34(_) ENUM_HPP_PP_SEQ_SIZE_35 +#define ENUM_HPP_PP_SEQ_SIZE_35(_) ENUM_HPP_PP_SEQ_SIZE_36 +#define ENUM_HPP_PP_SEQ_SIZE_36(_) ENUM_HPP_PP_SEQ_SIZE_37 +#define ENUM_HPP_PP_SEQ_SIZE_37(_) ENUM_HPP_PP_SEQ_SIZE_38 +#define ENUM_HPP_PP_SEQ_SIZE_38(_) ENUM_HPP_PP_SEQ_SIZE_39 +#define ENUM_HPP_PP_SEQ_SIZE_39(_) ENUM_HPP_PP_SEQ_SIZE_40 +#define ENUM_HPP_PP_SEQ_SIZE_40(_) ENUM_HPP_PP_SEQ_SIZE_41 +#define ENUM_HPP_PP_SEQ_SIZE_41(_) ENUM_HPP_PP_SEQ_SIZE_42 +#define ENUM_HPP_PP_SEQ_SIZE_42(_) ENUM_HPP_PP_SEQ_SIZE_43 +#define ENUM_HPP_PP_SEQ_SIZE_43(_) ENUM_HPP_PP_SEQ_SIZE_44 +#define ENUM_HPP_PP_SEQ_SIZE_44(_) ENUM_HPP_PP_SEQ_SIZE_45 +#define ENUM_HPP_PP_SEQ_SIZE_45(_) ENUM_HPP_PP_SEQ_SIZE_46 +#define ENUM_HPP_PP_SEQ_SIZE_46(_) ENUM_HPP_PP_SEQ_SIZE_47 +#define ENUM_HPP_PP_SEQ_SIZE_47(_) ENUM_HPP_PP_SEQ_SIZE_48 +#define ENUM_HPP_PP_SEQ_SIZE_48(_) ENUM_HPP_PP_SEQ_SIZE_49 +#define ENUM_HPP_PP_SEQ_SIZE_49(_) ENUM_HPP_PP_SEQ_SIZE_50 +#define ENUM_HPP_PP_SEQ_SIZE_50(_) ENUM_HPP_PP_SEQ_SIZE_51 +#define ENUM_HPP_PP_SEQ_SIZE_51(_) ENUM_HPP_PP_SEQ_SIZE_52 +#define ENUM_HPP_PP_SEQ_SIZE_52(_) ENUM_HPP_PP_SEQ_SIZE_53 +#define ENUM_HPP_PP_SEQ_SIZE_53(_) ENUM_HPP_PP_SEQ_SIZE_54 +#define ENUM_HPP_PP_SEQ_SIZE_54(_) ENUM_HPP_PP_SEQ_SIZE_55 +#define ENUM_HPP_PP_SEQ_SIZE_55(_) ENUM_HPP_PP_SEQ_SIZE_56 +#define ENUM_HPP_PP_SEQ_SIZE_56(_) ENUM_HPP_PP_SEQ_SIZE_57 +#define ENUM_HPP_PP_SEQ_SIZE_57(_) ENUM_HPP_PP_SEQ_SIZE_58 +#define ENUM_HPP_PP_SEQ_SIZE_58(_) ENUM_HPP_PP_SEQ_SIZE_59 +#define ENUM_HPP_PP_SEQ_SIZE_59(_) ENUM_HPP_PP_SEQ_SIZE_60 +#define ENUM_HPP_PP_SEQ_SIZE_60(_) ENUM_HPP_PP_SEQ_SIZE_61 +#define ENUM_HPP_PP_SEQ_SIZE_61(_) ENUM_HPP_PP_SEQ_SIZE_62 +#define ENUM_HPP_PP_SEQ_SIZE_62(_) ENUM_HPP_PP_SEQ_SIZE_63 +#define ENUM_HPP_PP_SEQ_SIZE_63(_) ENUM_HPP_PP_SEQ_SIZE_64 +#define ENUM_HPP_PP_SEQ_SIZE_64(_) ENUM_HPP_PP_SEQ_SIZE_65 +#define ENUM_HPP_PP_SEQ_SIZE_65(_) ENUM_HPP_PP_SEQ_SIZE_66 +#define ENUM_HPP_PP_SEQ_SIZE_66(_) ENUM_HPP_PP_SEQ_SIZE_67 +#define ENUM_HPP_PP_SEQ_SIZE_67(_) ENUM_HPP_PP_SEQ_SIZE_68 +#define ENUM_HPP_PP_SEQ_SIZE_68(_) ENUM_HPP_PP_SEQ_SIZE_69 +#define ENUM_HPP_PP_SEQ_SIZE_69(_) ENUM_HPP_PP_SEQ_SIZE_70 +#define ENUM_HPP_PP_SEQ_SIZE_70(_) ENUM_HPP_PP_SEQ_SIZE_71 +#define ENUM_HPP_PP_SEQ_SIZE_71(_) ENUM_HPP_PP_SEQ_SIZE_72 +#define ENUM_HPP_PP_SEQ_SIZE_72(_) ENUM_HPP_PP_SEQ_SIZE_73 +#define ENUM_HPP_PP_SEQ_SIZE_73(_) ENUM_HPP_PP_SEQ_SIZE_74 +#define ENUM_HPP_PP_SEQ_SIZE_74(_) ENUM_HPP_PP_SEQ_SIZE_75 +#define ENUM_HPP_PP_SEQ_SIZE_75(_) ENUM_HPP_PP_SEQ_SIZE_76 +#define ENUM_HPP_PP_SEQ_SIZE_76(_) ENUM_HPP_PP_SEQ_SIZE_77 +#define ENUM_HPP_PP_SEQ_SIZE_77(_) ENUM_HPP_PP_SEQ_SIZE_78 +#define ENUM_HPP_PP_SEQ_SIZE_78(_) ENUM_HPP_PP_SEQ_SIZE_79 +#define ENUM_HPP_PP_SEQ_SIZE_79(_) ENUM_HPP_PP_SEQ_SIZE_80 +#define ENUM_HPP_PP_SEQ_SIZE_80(_) ENUM_HPP_PP_SEQ_SIZE_81 +#define ENUM_HPP_PP_SEQ_SIZE_81(_) ENUM_HPP_PP_SEQ_SIZE_82 +#define ENUM_HPP_PP_SEQ_SIZE_82(_) ENUM_HPP_PP_SEQ_SIZE_83 +#define ENUM_HPP_PP_SEQ_SIZE_83(_) ENUM_HPP_PP_SEQ_SIZE_84 +#define ENUM_HPP_PP_SEQ_SIZE_84(_) ENUM_HPP_PP_SEQ_SIZE_85 +#define ENUM_HPP_PP_SEQ_SIZE_85(_) ENUM_HPP_PP_SEQ_SIZE_86 +#define ENUM_HPP_PP_SEQ_SIZE_86(_) ENUM_HPP_PP_SEQ_SIZE_87 +#define ENUM_HPP_PP_SEQ_SIZE_87(_) ENUM_HPP_PP_SEQ_SIZE_88 +#define ENUM_HPP_PP_SEQ_SIZE_88(_) ENUM_HPP_PP_SEQ_SIZE_89 +#define ENUM_HPP_PP_SEQ_SIZE_89(_) ENUM_HPP_PP_SEQ_SIZE_90 +#define ENUM_HPP_PP_SEQ_SIZE_90(_) ENUM_HPP_PP_SEQ_SIZE_91 +#define ENUM_HPP_PP_SEQ_SIZE_91(_) ENUM_HPP_PP_SEQ_SIZE_92 +#define ENUM_HPP_PP_SEQ_SIZE_92(_) ENUM_HPP_PP_SEQ_SIZE_93 +#define ENUM_HPP_PP_SEQ_SIZE_93(_) ENUM_HPP_PP_SEQ_SIZE_94 +#define ENUM_HPP_PP_SEQ_SIZE_94(_) ENUM_HPP_PP_SEQ_SIZE_95 +#define ENUM_HPP_PP_SEQ_SIZE_95(_) ENUM_HPP_PP_SEQ_SIZE_96 +#define ENUM_HPP_PP_SEQ_SIZE_96(_) ENUM_HPP_PP_SEQ_SIZE_97 +#define ENUM_HPP_PP_SEQ_SIZE_97(_) ENUM_HPP_PP_SEQ_SIZE_98 +#define ENUM_HPP_PP_SEQ_SIZE_98(_) ENUM_HPP_PP_SEQ_SIZE_99 +#define ENUM_HPP_PP_SEQ_SIZE_99(_) ENUM_HPP_PP_SEQ_SIZE_100 +#define ENUM_HPP_PP_SEQ_SIZE_100(_) ENUM_HPP_PP_SEQ_SIZE_101 +#define ENUM_HPP_PP_SEQ_SIZE_101(_) ENUM_HPP_PP_SEQ_SIZE_102 +#define ENUM_HPP_PP_SEQ_SIZE_102(_) ENUM_HPP_PP_SEQ_SIZE_103 +#define ENUM_HPP_PP_SEQ_SIZE_103(_) ENUM_HPP_PP_SEQ_SIZE_104 +#define ENUM_HPP_PP_SEQ_SIZE_104(_) ENUM_HPP_PP_SEQ_SIZE_105 +#define ENUM_HPP_PP_SEQ_SIZE_105(_) ENUM_HPP_PP_SEQ_SIZE_106 +#define ENUM_HPP_PP_SEQ_SIZE_106(_) ENUM_HPP_PP_SEQ_SIZE_107 +#define ENUM_HPP_PP_SEQ_SIZE_107(_) ENUM_HPP_PP_SEQ_SIZE_108 +#define ENUM_HPP_PP_SEQ_SIZE_108(_) ENUM_HPP_PP_SEQ_SIZE_109 +#define ENUM_HPP_PP_SEQ_SIZE_109(_) ENUM_HPP_PP_SEQ_SIZE_110 +#define ENUM_HPP_PP_SEQ_SIZE_110(_) ENUM_HPP_PP_SEQ_SIZE_111 +#define ENUM_HPP_PP_SEQ_SIZE_111(_) ENUM_HPP_PP_SEQ_SIZE_112 +#define ENUM_HPP_PP_SEQ_SIZE_112(_) ENUM_HPP_PP_SEQ_SIZE_113 +#define ENUM_HPP_PP_SEQ_SIZE_113(_) ENUM_HPP_PP_SEQ_SIZE_114 +#define ENUM_HPP_PP_SEQ_SIZE_114(_) ENUM_HPP_PP_SEQ_SIZE_115 +#define ENUM_HPP_PP_SEQ_SIZE_115(_) ENUM_HPP_PP_SEQ_SIZE_116 +#define ENUM_HPP_PP_SEQ_SIZE_116(_) ENUM_HPP_PP_SEQ_SIZE_117 +#define ENUM_HPP_PP_SEQ_SIZE_117(_) ENUM_HPP_PP_SEQ_SIZE_118 +#define ENUM_HPP_PP_SEQ_SIZE_118(_) ENUM_HPP_PP_SEQ_SIZE_119 +#define ENUM_HPP_PP_SEQ_SIZE_119(_) ENUM_HPP_PP_SEQ_SIZE_120 +#define ENUM_HPP_PP_SEQ_SIZE_120(_) ENUM_HPP_PP_SEQ_SIZE_121 +#define ENUM_HPP_PP_SEQ_SIZE_121(_) ENUM_HPP_PP_SEQ_SIZE_122 +#define ENUM_HPP_PP_SEQ_SIZE_122(_) ENUM_HPP_PP_SEQ_SIZE_123 +#define ENUM_HPP_PP_SEQ_SIZE_123(_) ENUM_HPP_PP_SEQ_SIZE_124 +#define ENUM_HPP_PP_SEQ_SIZE_124(_) ENUM_HPP_PP_SEQ_SIZE_125 +#define ENUM_HPP_PP_SEQ_SIZE_125(_) ENUM_HPP_PP_SEQ_SIZE_126 +#define ENUM_HPP_PP_SEQ_SIZE_126(_) ENUM_HPP_PP_SEQ_SIZE_127 +#define ENUM_HPP_PP_SEQ_SIZE_127(_) ENUM_HPP_PP_SEQ_SIZE_128 +#define ENUM_HPP_PP_SEQ_SIZE_128(_) ENUM_HPP_PP_SEQ_SIZE_129 +#define ENUM_HPP_PP_SEQ_SIZE_129(_) ENUM_HPP_PP_SEQ_SIZE_130 +#define ENUM_HPP_PP_SEQ_SIZE_130(_) ENUM_HPP_PP_SEQ_SIZE_131 +#define ENUM_HPP_PP_SEQ_SIZE_131(_) ENUM_HPP_PP_SEQ_SIZE_132 +#define ENUM_HPP_PP_SEQ_SIZE_132(_) ENUM_HPP_PP_SEQ_SIZE_133 +#define ENUM_HPP_PP_SEQ_SIZE_133(_) ENUM_HPP_PP_SEQ_SIZE_134 +#define ENUM_HPP_PP_SEQ_SIZE_134(_) ENUM_HPP_PP_SEQ_SIZE_135 +#define ENUM_HPP_PP_SEQ_SIZE_135(_) ENUM_HPP_PP_SEQ_SIZE_136 +#define ENUM_HPP_PP_SEQ_SIZE_136(_) ENUM_HPP_PP_SEQ_SIZE_137 +#define ENUM_HPP_PP_SEQ_SIZE_137(_) ENUM_HPP_PP_SEQ_SIZE_138 +#define ENUM_HPP_PP_SEQ_SIZE_138(_) ENUM_HPP_PP_SEQ_SIZE_139 +#define ENUM_HPP_PP_SEQ_SIZE_139(_) ENUM_HPP_PP_SEQ_SIZE_140 +#define ENUM_HPP_PP_SEQ_SIZE_140(_) ENUM_HPP_PP_SEQ_SIZE_141 +#define ENUM_HPP_PP_SEQ_SIZE_141(_) ENUM_HPP_PP_SEQ_SIZE_142 +#define ENUM_HPP_PP_SEQ_SIZE_142(_) ENUM_HPP_PP_SEQ_SIZE_143 +#define ENUM_HPP_PP_SEQ_SIZE_143(_) ENUM_HPP_PP_SEQ_SIZE_144 +#define ENUM_HPP_PP_SEQ_SIZE_144(_) ENUM_HPP_PP_SEQ_SIZE_145 +#define ENUM_HPP_PP_SEQ_SIZE_145(_) ENUM_HPP_PP_SEQ_SIZE_146 +#define ENUM_HPP_PP_SEQ_SIZE_146(_) ENUM_HPP_PP_SEQ_SIZE_147 +#define ENUM_HPP_PP_SEQ_SIZE_147(_) ENUM_HPP_PP_SEQ_SIZE_148 +#define ENUM_HPP_PP_SEQ_SIZE_148(_) ENUM_HPP_PP_SEQ_SIZE_149 +#define ENUM_HPP_PP_SEQ_SIZE_149(_) ENUM_HPP_PP_SEQ_SIZE_150 +#define ENUM_HPP_PP_SEQ_SIZE_150(_) ENUM_HPP_PP_SEQ_SIZE_151 +#define ENUM_HPP_PP_SEQ_SIZE_151(_) ENUM_HPP_PP_SEQ_SIZE_152 +#define ENUM_HPP_PP_SEQ_SIZE_152(_) ENUM_HPP_PP_SEQ_SIZE_153 +#define ENUM_HPP_PP_SEQ_SIZE_153(_) ENUM_HPP_PP_SEQ_SIZE_154 +#define ENUM_HPP_PP_SEQ_SIZE_154(_) ENUM_HPP_PP_SEQ_SIZE_155 +#define ENUM_HPP_PP_SEQ_SIZE_155(_) ENUM_HPP_PP_SEQ_SIZE_156 +#define ENUM_HPP_PP_SEQ_SIZE_156(_) ENUM_HPP_PP_SEQ_SIZE_157 +#define ENUM_HPP_PP_SEQ_SIZE_157(_) ENUM_HPP_PP_SEQ_SIZE_158 +#define ENUM_HPP_PP_SEQ_SIZE_158(_) ENUM_HPP_PP_SEQ_SIZE_159 +#define ENUM_HPP_PP_SEQ_SIZE_159(_) ENUM_HPP_PP_SEQ_SIZE_160 +#define ENUM_HPP_PP_SEQ_SIZE_160(_) ENUM_HPP_PP_SEQ_SIZE_161 +#define ENUM_HPP_PP_SEQ_SIZE_161(_) ENUM_HPP_PP_SEQ_SIZE_162 +#define ENUM_HPP_PP_SEQ_SIZE_162(_) ENUM_HPP_PP_SEQ_SIZE_163 +#define ENUM_HPP_PP_SEQ_SIZE_163(_) ENUM_HPP_PP_SEQ_SIZE_164 +#define ENUM_HPP_PP_SEQ_SIZE_164(_) ENUM_HPP_PP_SEQ_SIZE_165 +#define ENUM_HPP_PP_SEQ_SIZE_165(_) ENUM_HPP_PP_SEQ_SIZE_166 +#define ENUM_HPP_PP_SEQ_SIZE_166(_) ENUM_HPP_PP_SEQ_SIZE_167 +#define ENUM_HPP_PP_SEQ_SIZE_167(_) ENUM_HPP_PP_SEQ_SIZE_168 +#define ENUM_HPP_PP_SEQ_SIZE_168(_) ENUM_HPP_PP_SEQ_SIZE_169 +#define ENUM_HPP_PP_SEQ_SIZE_169(_) ENUM_HPP_PP_SEQ_SIZE_170 +#define ENUM_HPP_PP_SEQ_SIZE_170(_) ENUM_HPP_PP_SEQ_SIZE_171 +#define ENUM_HPP_PP_SEQ_SIZE_171(_) ENUM_HPP_PP_SEQ_SIZE_172 +#define ENUM_HPP_PP_SEQ_SIZE_172(_) ENUM_HPP_PP_SEQ_SIZE_173 +#define ENUM_HPP_PP_SEQ_SIZE_173(_) ENUM_HPP_PP_SEQ_SIZE_174 +#define ENUM_HPP_PP_SEQ_SIZE_174(_) ENUM_HPP_PP_SEQ_SIZE_175 +#define ENUM_HPP_PP_SEQ_SIZE_175(_) ENUM_HPP_PP_SEQ_SIZE_176 +#define ENUM_HPP_PP_SEQ_SIZE_176(_) ENUM_HPP_PP_SEQ_SIZE_177 +#define ENUM_HPP_PP_SEQ_SIZE_177(_) ENUM_HPP_PP_SEQ_SIZE_178 +#define ENUM_HPP_PP_SEQ_SIZE_178(_) ENUM_HPP_PP_SEQ_SIZE_179 +#define ENUM_HPP_PP_SEQ_SIZE_179(_) ENUM_HPP_PP_SEQ_SIZE_180 +#define ENUM_HPP_PP_SEQ_SIZE_180(_) ENUM_HPP_PP_SEQ_SIZE_181 +#define ENUM_HPP_PP_SEQ_SIZE_181(_) ENUM_HPP_PP_SEQ_SIZE_182 +#define ENUM_HPP_PP_SEQ_SIZE_182(_) ENUM_HPP_PP_SEQ_SIZE_183 +#define ENUM_HPP_PP_SEQ_SIZE_183(_) ENUM_HPP_PP_SEQ_SIZE_184 +#define ENUM_HPP_PP_SEQ_SIZE_184(_) ENUM_HPP_PP_SEQ_SIZE_185 +#define ENUM_HPP_PP_SEQ_SIZE_185(_) ENUM_HPP_PP_SEQ_SIZE_186 +#define ENUM_HPP_PP_SEQ_SIZE_186(_) ENUM_HPP_PP_SEQ_SIZE_187 +#define ENUM_HPP_PP_SEQ_SIZE_187(_) ENUM_HPP_PP_SEQ_SIZE_188 +#define ENUM_HPP_PP_SEQ_SIZE_188(_) ENUM_HPP_PP_SEQ_SIZE_189 +#define ENUM_HPP_PP_SEQ_SIZE_189(_) ENUM_HPP_PP_SEQ_SIZE_190 +#define ENUM_HPP_PP_SEQ_SIZE_190(_) ENUM_HPP_PP_SEQ_SIZE_191 +#define ENUM_HPP_PP_SEQ_SIZE_191(_) ENUM_HPP_PP_SEQ_SIZE_192 +#define ENUM_HPP_PP_SEQ_SIZE_192(_) ENUM_HPP_PP_SEQ_SIZE_193 +#define ENUM_HPP_PP_SEQ_SIZE_193(_) ENUM_HPP_PP_SEQ_SIZE_194 +#define ENUM_HPP_PP_SEQ_SIZE_194(_) ENUM_HPP_PP_SEQ_SIZE_195 +#define ENUM_HPP_PP_SEQ_SIZE_195(_) ENUM_HPP_PP_SEQ_SIZE_196 +#define ENUM_HPP_PP_SEQ_SIZE_196(_) ENUM_HPP_PP_SEQ_SIZE_197 +#define ENUM_HPP_PP_SEQ_SIZE_197(_) ENUM_HPP_PP_SEQ_SIZE_198 +#define ENUM_HPP_PP_SEQ_SIZE_198(_) ENUM_HPP_PP_SEQ_SIZE_199 +#define ENUM_HPP_PP_SEQ_SIZE_199(_) ENUM_HPP_PP_SEQ_SIZE_200 +#define ENUM_HPP_PP_SEQ_SIZE_200(_) ENUM_HPP_PP_SEQ_SIZE_201 +#define ENUM_HPP_PP_SEQ_SIZE_201(_) ENUM_HPP_PP_SEQ_SIZE_202 +#define ENUM_HPP_PP_SEQ_SIZE_202(_) ENUM_HPP_PP_SEQ_SIZE_203 +#define ENUM_HPP_PP_SEQ_SIZE_203(_) ENUM_HPP_PP_SEQ_SIZE_204 +#define ENUM_HPP_PP_SEQ_SIZE_204(_) ENUM_HPP_PP_SEQ_SIZE_205 +#define ENUM_HPP_PP_SEQ_SIZE_205(_) ENUM_HPP_PP_SEQ_SIZE_206 +#define ENUM_HPP_PP_SEQ_SIZE_206(_) ENUM_HPP_PP_SEQ_SIZE_207 +#define ENUM_HPP_PP_SEQ_SIZE_207(_) ENUM_HPP_PP_SEQ_SIZE_208 +#define ENUM_HPP_PP_SEQ_SIZE_208(_) ENUM_HPP_PP_SEQ_SIZE_209 +#define ENUM_HPP_PP_SEQ_SIZE_209(_) ENUM_HPP_PP_SEQ_SIZE_210 +#define ENUM_HPP_PP_SEQ_SIZE_210(_) ENUM_HPP_PP_SEQ_SIZE_211 +#define ENUM_HPP_PP_SEQ_SIZE_211(_) ENUM_HPP_PP_SEQ_SIZE_212 +#define ENUM_HPP_PP_SEQ_SIZE_212(_) ENUM_HPP_PP_SEQ_SIZE_213 +#define ENUM_HPP_PP_SEQ_SIZE_213(_) ENUM_HPP_PP_SEQ_SIZE_214 +#define ENUM_HPP_PP_SEQ_SIZE_214(_) ENUM_HPP_PP_SEQ_SIZE_215 +#define ENUM_HPP_PP_SEQ_SIZE_215(_) ENUM_HPP_PP_SEQ_SIZE_216 +#define ENUM_HPP_PP_SEQ_SIZE_216(_) ENUM_HPP_PP_SEQ_SIZE_217 +#define ENUM_HPP_PP_SEQ_SIZE_217(_) ENUM_HPP_PP_SEQ_SIZE_218 +#define ENUM_HPP_PP_SEQ_SIZE_218(_) ENUM_HPP_PP_SEQ_SIZE_219 +#define ENUM_HPP_PP_SEQ_SIZE_219(_) ENUM_HPP_PP_SEQ_SIZE_220 +#define ENUM_HPP_PP_SEQ_SIZE_220(_) ENUM_HPP_PP_SEQ_SIZE_221 +#define ENUM_HPP_PP_SEQ_SIZE_221(_) ENUM_HPP_PP_SEQ_SIZE_222 +#define ENUM_HPP_PP_SEQ_SIZE_222(_) ENUM_HPP_PP_SEQ_SIZE_223 +#define ENUM_HPP_PP_SEQ_SIZE_223(_) ENUM_HPP_PP_SEQ_SIZE_224 +#define ENUM_HPP_PP_SEQ_SIZE_224(_) ENUM_HPP_PP_SEQ_SIZE_225 +#define ENUM_HPP_PP_SEQ_SIZE_225(_) ENUM_HPP_PP_SEQ_SIZE_226 +#define ENUM_HPP_PP_SEQ_SIZE_226(_) ENUM_HPP_PP_SEQ_SIZE_227 +#define ENUM_HPP_PP_SEQ_SIZE_227(_) ENUM_HPP_PP_SEQ_SIZE_228 +#define ENUM_HPP_PP_SEQ_SIZE_228(_) ENUM_HPP_PP_SEQ_SIZE_229 +#define ENUM_HPP_PP_SEQ_SIZE_229(_) ENUM_HPP_PP_SEQ_SIZE_230 +#define ENUM_HPP_PP_SEQ_SIZE_230(_) ENUM_HPP_PP_SEQ_SIZE_231 +#define ENUM_HPP_PP_SEQ_SIZE_231(_) ENUM_HPP_PP_SEQ_SIZE_232 +#define ENUM_HPP_PP_SEQ_SIZE_232(_) ENUM_HPP_PP_SEQ_SIZE_233 +#define ENUM_HPP_PP_SEQ_SIZE_233(_) ENUM_HPP_PP_SEQ_SIZE_234 +#define ENUM_HPP_PP_SEQ_SIZE_234(_) ENUM_HPP_PP_SEQ_SIZE_235 +#define ENUM_HPP_PP_SEQ_SIZE_235(_) ENUM_HPP_PP_SEQ_SIZE_236 +#define ENUM_HPP_PP_SEQ_SIZE_236(_) ENUM_HPP_PP_SEQ_SIZE_237 +#define ENUM_HPP_PP_SEQ_SIZE_237(_) ENUM_HPP_PP_SEQ_SIZE_238 +#define ENUM_HPP_PP_SEQ_SIZE_238(_) ENUM_HPP_PP_SEQ_SIZE_239 +#define ENUM_HPP_PP_SEQ_SIZE_239(_) ENUM_HPP_PP_SEQ_SIZE_240 +#define ENUM_HPP_PP_SEQ_SIZE_240(_) ENUM_HPP_PP_SEQ_SIZE_241 +#define ENUM_HPP_PP_SEQ_SIZE_241(_) ENUM_HPP_PP_SEQ_SIZE_242 +#define ENUM_HPP_PP_SEQ_SIZE_242(_) ENUM_HPP_PP_SEQ_SIZE_243 +#define ENUM_HPP_PP_SEQ_SIZE_243(_) ENUM_HPP_PP_SEQ_SIZE_244 +#define ENUM_HPP_PP_SEQ_SIZE_244(_) ENUM_HPP_PP_SEQ_SIZE_245 +#define ENUM_HPP_PP_SEQ_SIZE_245(_) ENUM_HPP_PP_SEQ_SIZE_246 +#define ENUM_HPP_PP_SEQ_SIZE_246(_) ENUM_HPP_PP_SEQ_SIZE_247 +#define ENUM_HPP_PP_SEQ_SIZE_247(_) ENUM_HPP_PP_SEQ_SIZE_248 +#define ENUM_HPP_PP_SEQ_SIZE_248(_) ENUM_HPP_PP_SEQ_SIZE_249 +#define ENUM_HPP_PP_SEQ_SIZE_249(_) ENUM_HPP_PP_SEQ_SIZE_250 +#define ENUM_HPP_PP_SEQ_SIZE_250(_) ENUM_HPP_PP_SEQ_SIZE_251 +#define ENUM_HPP_PP_SEQ_SIZE_251(_) ENUM_HPP_PP_SEQ_SIZE_252 +#define ENUM_HPP_PP_SEQ_SIZE_252(_) ENUM_HPP_PP_SEQ_SIZE_253 +#define ENUM_HPP_PP_SEQ_SIZE_253(_) ENUM_HPP_PP_SEQ_SIZE_254 +#define ENUM_HPP_PP_SEQ_SIZE_254(_) ENUM_HPP_PP_SEQ_SIZE_255 +#define ENUM_HPP_PP_SEQ_SIZE_255(_) ENUM_HPP_PP_SEQ_SIZE_256 + +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_0 0 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_1 1 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_2 2 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_3 3 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_4 4 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_5 5 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_6 6 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_7 7 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_8 8 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_9 9 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_10 10 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_11 11 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_12 12 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_13 13 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_14 14 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_15 15 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_16 16 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_17 17 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_18 18 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_19 19 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_20 20 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_21 21 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_22 22 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_23 23 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_24 24 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_25 25 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_26 26 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_27 27 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_28 28 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_29 29 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_30 30 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_31 31 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_32 32 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_33 33 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_34 34 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_35 35 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_36 36 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_37 37 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_38 38 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_39 39 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_40 40 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_41 41 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_42 42 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_43 43 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_44 44 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_45 45 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_46 46 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_47 47 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_48 48 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_49 49 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_50 50 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_51 51 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_52 52 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_53 53 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_54 54 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_55 55 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_56 56 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_57 57 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_58 58 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_59 59 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_60 60 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_61 61 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_62 62 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_63 63 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_64 64 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_65 65 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_66 66 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_67 67 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_68 68 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_69 69 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_70 70 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_71 71 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_72 72 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_73 73 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_74 74 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_75 75 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_76 76 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_77 77 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_78 78 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_79 79 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_80 80 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_81 81 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_82 82 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_83 83 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_84 84 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_85 85 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_86 86 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_87 87 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_88 88 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_89 89 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_90 90 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_91 91 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_92 92 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_93 93 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_94 94 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_95 95 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_96 96 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_97 97 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_98 98 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_99 99 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_100 100 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_101 101 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_102 102 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_103 103 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_104 104 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_105 105 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_106 106 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_107 107 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_108 108 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_109 109 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_110 110 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_111 111 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_112 112 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_113 113 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_114 114 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_115 115 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_116 116 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_117 117 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_118 118 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_119 119 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_120 120 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_121 121 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_122 122 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_123 123 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_124 124 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_125 125 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_126 126 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_127 127 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_128 128 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_129 129 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_130 130 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_131 131 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_132 132 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_133 133 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_134 134 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_135 135 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_136 136 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_137 137 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_138 138 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_139 139 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_140 140 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_141 141 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_142 142 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_143 143 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_144 144 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_145 145 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_146 146 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_147 147 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_148 148 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_149 149 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_150 150 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_151 151 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_152 152 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_153 153 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_154 154 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_155 155 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_156 156 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_157 157 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_158 158 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_159 159 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_160 160 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_161 161 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_162 162 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_163 163 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_164 164 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_165 165 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_166 166 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_167 167 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_168 168 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_169 169 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_170 170 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_171 171 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_172 172 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_173 173 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_174 174 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_175 175 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_176 176 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_177 177 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_178 178 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_179 179 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_180 180 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_181 181 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_182 182 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_183 183 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_184 184 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_185 185 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_186 186 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_187 187 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_188 188 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_189 189 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_190 190 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_191 191 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_192 192 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_193 193 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_194 194 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_195 195 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_196 196 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_197 197 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_198 198 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_199 199 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_200 200 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_201 201 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_202 202 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_203 203 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_204 204 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_205 205 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_206 206 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_207 207 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_208 208 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_209 209 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_210 210 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_211 211 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_212 212 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_213 213 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_214 214 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_215 215 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_216 216 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_217 217 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_218 218 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_219 219 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_220 220 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_221 221 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_222 222 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_223 223 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_224 224 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_225 225 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_226 226 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_227 227 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_228 228 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_229 229 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_230 230 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_231 231 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_232 232 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_233 233 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_234 234 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_235 235 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_236 236 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_237 237 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_238 238 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_239 239 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_240 240 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_241 241 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_242 242 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_243 243 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_244 244 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_245 245 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_246 246 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_247 247 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_248 248 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_249 249 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_250 250 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_251 251 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_252 252 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_253 253 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_254 254 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_255 255 +# define ENUM_HPP_PP_SEQ_SIZE_ENUM_HPP_PP_SEQ_SIZE_256 256 + +// +// ENUM_HPP_PP_SEQ_FOR_EACH +// + +#define ENUM_HPP_PP_SEQ_FOR_EACH(m, d, s)\ + ENUM_HPP_PP_CAT(ENUM_HPP_PP_SEQ_FOR_EACH_, ENUM_HPP_PP_SEQ_SIZE(s)) (m, d, 0, s) + +#define ENUM_HPP_PP_SEQ_FOR_EACH_1(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_2(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_1(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_3(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_2(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_4(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_3(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_5(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_4(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_6(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_5(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_7(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_6(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_8(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_7(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_9(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_8(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_10(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_9(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_11(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_10(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_12(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_11(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_13(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_12(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_14(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_13(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_15(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_14(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_16(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_15(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_17(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_16(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_18(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_17(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_19(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_18(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_20(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_19(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_21(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_20(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_22(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_21(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_23(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_22(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_24(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_23(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_25(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_24(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_26(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_25(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_27(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_26(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_28(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_27(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_29(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_28(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_30(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_29(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_31(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_30(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_32(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_31(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_33(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_32(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_34(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_33(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_35(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_34(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_36(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_35(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_37(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_36(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_38(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_37(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_39(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_38(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_40(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_39(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_41(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_40(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_42(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_41(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_43(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_42(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_44(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_43(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_45(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_44(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_46(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_45(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_47(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_46(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_48(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_47(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_49(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_48(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_50(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_49(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_51(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_50(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_52(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_51(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_53(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_52(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_54(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_53(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_55(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_54(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_56(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_55(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_57(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_56(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_58(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_57(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_59(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_58(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_60(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_59(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_61(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_60(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_62(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_61(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_63(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_62(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_64(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_63(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_65(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_64(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_66(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_65(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_67(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_66(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_68(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_67(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_69(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_68(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_70(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_69(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_71(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_70(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_72(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_71(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_73(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_72(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_74(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_73(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_75(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_74(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_76(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_75(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_77(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_76(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_78(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_77(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_79(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_78(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_80(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_79(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_81(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_80(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_82(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_81(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_83(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_82(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_84(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_83(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_85(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_84(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_86(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_85(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_87(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_86(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_88(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_87(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_89(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_88(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_90(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_89(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_91(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_90(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_92(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_91(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_93(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_92(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_94(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_93(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_95(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_94(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_96(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_95(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_97(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_96(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_98(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_97(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_99(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_98(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_100(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_99(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_101(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_100(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_102(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_101(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_103(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_102(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_104(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_103(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_105(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_104(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_106(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_105(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_107(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_106(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_108(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_107(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_109(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_108(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_110(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_109(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_111(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_110(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_112(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_111(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_113(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_112(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_114(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_113(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_115(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_114(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_116(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_115(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_117(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_116(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_118(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_117(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_119(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_118(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_120(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_119(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_121(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_120(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_122(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_121(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_123(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_122(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_124(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_123(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_125(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_124(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_126(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_125(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_127(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_126(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_128(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_127(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_129(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_128(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_130(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_129(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_131(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_130(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_132(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_131(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_133(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_132(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_134(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_133(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_135(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_134(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_136(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_135(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_137(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_136(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_138(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_137(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_139(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_138(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_140(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_139(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_141(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_140(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_142(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_141(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_143(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_142(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_144(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_143(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_145(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_144(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_146(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_145(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_147(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_146(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_148(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_147(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_149(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_148(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_150(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_149(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_151(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_150(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_152(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_151(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_153(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_152(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_154(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_153(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_155(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_154(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_156(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_155(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_157(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_156(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_158(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_157(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_159(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_158(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_160(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_159(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_161(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_160(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_162(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_161(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_163(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_162(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_164(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_163(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_165(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_164(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_166(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_165(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_167(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_166(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_168(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_167(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_169(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_168(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_170(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_169(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_171(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_170(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_172(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_171(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_173(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_172(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_174(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_173(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_175(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_174(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_176(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_175(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_177(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_176(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_178(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_177(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_179(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_178(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_180(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_179(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_181(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_180(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_182(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_181(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_183(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_182(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_184(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_183(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_185(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_184(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_186(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_185(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_187(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_186(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_188(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_187(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_189(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_188(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_190(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_189(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_191(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_190(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_192(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_191(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_193(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_192(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_194(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_193(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_195(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_194(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_196(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_195(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_197(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_196(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_198(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_197(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_199(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_198(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_200(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_199(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_201(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_200(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_202(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_201(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_203(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_202(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_204(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_203(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_205(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_204(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_206(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_205(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_207(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_206(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_208(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_207(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_209(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_208(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_210(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_209(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_211(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_210(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_212(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_211(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_213(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_212(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_214(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_213(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_215(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_214(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_216(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_215(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_217(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_216(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_218(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_217(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_219(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_218(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_220(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_219(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_221(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_220(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_222(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_221(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_223(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_222(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_224(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_223(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_225(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_224(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_226(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_225(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_227(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_226(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_228(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_227(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_229(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_228(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_230(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_229(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_231(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_230(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_232(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_231(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_233(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_232(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_234(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_233(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_235(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_234(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_236(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_235(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_237(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_236(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_238(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_237(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_239(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_238(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_240(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_239(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_241(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_240(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_242(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_241(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_243(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_242(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_244(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_243(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_245(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_244(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_246(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_245(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_247(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_246(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_248(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_247(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_249(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_248(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_250(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_249(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_251(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_250(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_252(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_251(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_253(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_252(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_254(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_253(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_255(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_254(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) +#define ENUM_HPP_PP_SEQ_FOR_EACH_256(m, d, i, s) m(d, i, ENUM_HPP_PP_SEQ_HEAD(s)) ENUM_HPP_PP_SEQ_FOR_EACH_255(m, d, ENUM_HPP_PP_INC(i), ENUM_HPP_PP_SEQ_TAIL(s)) diff --git a/headers/meta.hpp/meta_base/enum_bitflags.hpp b/headers/meta.hpp/meta_base/enum_bitflags.hpp new file mode 100644 index 0000000..5b021cb --- /dev/null +++ b/headers/meta.hpp/meta_base/enum_bitflags.hpp @@ -0,0 +1,332 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/enum.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2019-2022, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include +#include +#include + +namespace enum_hpp::bitflags +{ + template < typename Enum > + class bitflags final { + static_assert(std::is_enum_v); + public: + using enum_type = Enum; + using underlying_type = std::underlying_type_t; + + bitflags() = default; + bitflags(const bitflags&) = default; + bitflags& operator=(const bitflags&) = default; + bitflags(bitflags&&) noexcept = default; + bitflags& operator=(bitflags&&) noexcept = default; + ~bitflags() = default; + + constexpr bitflags(enum_type flags) + : flags_(static_cast(flags)) {} + + constexpr explicit bitflags(underlying_type flags) + : flags_(flags) {} + + constexpr void swap(bitflags& other) noexcept { + using std::swap; + swap(flags_, other.flags_); + } + + constexpr explicit operator bool() const noexcept { + return !!flags_; + } + + constexpr underlying_type as_raw() const noexcept { + return flags_; + } + + constexpr enum_type as_enum() const noexcept { + return static_cast(flags_); + } + + constexpr bool has(bitflags flags) const noexcept { + return flags.flags_ == (flags_ & flags.flags_); + } + + constexpr bitflags& set(bitflags flags) noexcept { + flags_ |= flags.flags_; + return *this; + } + + constexpr bitflags& toggle(bitflags flags) noexcept { + flags_ ^= flags.flags_; + return *this; + } + + constexpr bitflags& clear(bitflags flags) noexcept { + flags_ &= ~flags.flags_; + return *this; + } + private: + underlying_type flags_{}; + }; + + template < typename Enum > + constexpr void swap(bitflags& l, bitflags& r) noexcept { + l.swap(r); + } +} + +namespace std +{ + template < typename Enum > + struct hash> { + size_t operator()(enum_hpp::bitflags::bitflags bf) const noexcept { + return hash{}(bf.as_enum()); + } + }; +} + +namespace enum_hpp::bitflags +{ + #define ENUM_HPP_DEFINE_BINARY_OPERATOR(op)\ + template < typename Enum >\ + constexpr bool operator op(Enum l, bitflags r) noexcept {\ + return l op r.as_enum();\ + }\ + template < typename Enum >\ + constexpr bool operator op(bitflags l, Enum r) noexcept {\ + return l.as_enum() op r;\ + }\ + template < typename Enum >\ + constexpr bool operator op(std::underlying_type_t l, bitflags r) noexcept {\ + return l op r.as_raw();\ + }\ + template < typename Enum >\ + constexpr bool operator op(bitflags l, std::underlying_type_t r) noexcept {\ + return l.as_raw() op r;\ + }\ + template < typename Enum >\ + constexpr bool operator op(bitflags l, bitflags r) noexcept {\ + return l.as_raw() op r.as_raw();\ + } + ENUM_HPP_DEFINE_BINARY_OPERATOR(<) + ENUM_HPP_DEFINE_BINARY_OPERATOR(>) + ENUM_HPP_DEFINE_BINARY_OPERATOR(<=) + ENUM_HPP_DEFINE_BINARY_OPERATOR(>=) + ENUM_HPP_DEFINE_BINARY_OPERATOR(==) + ENUM_HPP_DEFINE_BINARY_OPERATOR(!=) + #undef ENUM_HPP_DEFINE_BINARY_OPERATOR +} + +namespace enum_hpp::bitflags +{ + template < typename Enum > + constexpr bitflags operator~(bitflags l) noexcept { + return static_cast(~l.as_raw()); + } + + #define ENUM_HPP_DEFINE_BINARY_OPERATOR(op)\ + template < typename Enum >\ + constexpr bitflags operator op (Enum l, bitflags r) noexcept {\ + return bitflags{l} op r;\ + }\ + template < typename Enum >\ + constexpr bitflags operator op (bitflags l, Enum r) noexcept {\ + return l op bitflags{r};\ + }\ + template < typename Enum >\ + constexpr bitflags operator op (bitflags l, bitflags r) noexcept {\ + return static_cast(l.as_raw() op r.as_raw());\ + }\ + template < typename Enum >\ + constexpr bitflags& operator op##= (bitflags& l, Enum r) noexcept {\ + return l = l op bitflags{r};\ + }\ + template < typename Enum >\ + constexpr bitflags& operator op##= (bitflags& l, bitflags r) noexcept {\ + return l = l op r;\ + } + ENUM_HPP_DEFINE_BINARY_OPERATOR(|) + ENUM_HPP_DEFINE_BINARY_OPERATOR(&) + ENUM_HPP_DEFINE_BINARY_OPERATOR(^) + #undef ENUM_HPP_DEFINE_BINARY_OPERATOR +} + +namespace enum_hpp::bitflags +{ + // + // any + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool any(Enum flags) noexcept { + return any(bitflags{flags}); + } + + template < typename Enum > + constexpr bool any(bitflags flags) noexcept { + return 0 != flags.as_raw(); + } + + // + // none + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool none(Enum flags) noexcept { + return none(bitflags{flags}); + } + + template < typename Enum > + constexpr bool none(bitflags flags) noexcept { + return 0 == flags.as_raw(); + } + + // + // all_of + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool all_of(Enum flags, Enum mask) noexcept { + return all_of(bitflags{flags}, bitflags{mask}); + } + + template < typename Enum > + constexpr bool all_of(Enum flags, bitflags mask) noexcept { + return all_of(bitflags{flags}, mask); + } + + template < typename Enum > + constexpr bool all_of(bitflags flags, Enum mask) noexcept { + return all_of(flags, bitflags{mask}); + } + + template < typename Enum > + constexpr bool all_of(bitflags flags, bitflags mask) noexcept { + return (flags.as_raw() & mask.as_raw()) == mask.as_raw(); + } + + // + // any_of + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool any_of(Enum flags, Enum mask) noexcept { + return any_of(bitflags{flags}, bitflags{mask}); + } + + template < typename Enum > + constexpr bool any_of(Enum flags, bitflags mask) noexcept { + return any_of(bitflags{flags}, mask); + } + + template < typename Enum > + constexpr bool any_of(bitflags flags, Enum mask) noexcept { + return any_of(flags, bitflags{mask}); + } + + template < typename Enum > + constexpr bool any_of(bitflags flags, bitflags mask) noexcept { + return mask.as_raw() == 0 + || (flags.as_raw() & mask.as_raw()) != 0; + } + + // + // none_of + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool none_of(Enum flags, Enum mask) noexcept { + return none_of(bitflags{flags}, bitflags{mask}); + } + + template < typename Enum > + constexpr bool none_of(Enum flags, bitflags mask) noexcept { + return none_of(bitflags{flags}, mask); + } + + template < typename Enum > + constexpr bool none_of(bitflags flags, Enum mask) noexcept { + return none_of(flags, bitflags{mask}); + } + + template < typename Enum > + constexpr bool none_of(bitflags flags, bitflags mask) noexcept { + return mask.as_raw() != 0 + && (flags.as_raw() & mask.as_raw()) == 0; + } + + // + // any_except + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool any_except(Enum flags, Enum mask) noexcept { + return any_except(bitflags{flags}, bitflags{mask}); + } + + template < typename Enum > + constexpr bool any_except(Enum flags, bitflags mask) noexcept { + return any_except(bitflags{flags}, mask); + } + + template < typename Enum > + constexpr bool any_except(bitflags flags, Enum mask) noexcept { + return any_except(flags, bitflags{mask}); + } + + template < typename Enum > + constexpr bool any_except(bitflags flags, bitflags mask) noexcept { + return any_of(flags, ~mask); + } + + // + // none_except + // + + template < typename Enum + , std::enable_if_t, int> = 0 > + constexpr bool none_except(Enum flags, Enum mask) noexcept { + return none_except(bitflags{flags}, bitflags{mask}); + } + + template < typename Enum > + constexpr bool none_except(Enum flags, bitflags mask) noexcept { + return none_except(bitflags{flags}, mask); + } + + template < typename Enum > + constexpr bool none_except(bitflags flags, Enum mask) noexcept { + return none_except(flags, bitflags{mask}); + } + + template < typename Enum > + constexpr bool none_except(bitflags flags, bitflags mask) noexcept { + return none_of(flags, ~mask); + } +} + +// +// ENUM_HPP_OPERATORS_DECL +// + +#define ENUM_HPP_OPERATORS_DECL(Enum)\ + constexpr ::enum_hpp::bitflags::bitflags operator~ [[maybe_unused]] (Enum l) noexcept {\ + return ~::enum_hpp::bitflags::bitflags(l);\ + }\ + constexpr ::enum_hpp::bitflags::bitflags operator| [[maybe_unused]] (Enum l, Enum r) noexcept {\ + return ::enum_hpp::bitflags::bitflags(l) | ::enum_hpp::bitflags::bitflags(r);\ + }\ + constexpr ::enum_hpp::bitflags::bitflags operator& [[maybe_unused]] (Enum l, Enum r) noexcept {\ + return ::enum_hpp::bitflags::bitflags(l) & ::enum_hpp::bitflags::bitflags(r);\ + }\ + constexpr ::enum_hpp::bitflags::bitflags operator^ [[maybe_unused]] (Enum l, Enum r) noexcept {\ + return ::enum_hpp::bitflags::bitflags(l) ^ ::enum_hpp::bitflags::bitflags(r);\ + } diff --git a/headers/meta.hpp/meta_base/noncopyable.hpp b/headers/meta.hpp/meta_base/noncopyable.hpp new file mode 100644 index 0000000..2f26483 --- /dev/null +++ b/headers/meta.hpp/meta_base/noncopyable.hpp @@ -0,0 +1,21 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +namespace meta_hpp::detail +{ + class noncopyable { + protected: + noncopyable() = default; + ~noncopyable() = default; + public: + noncopyable(noncopyable&&) = delete; + noncopyable(const noncopyable&) = delete; + noncopyable& operator=(noncopyable&&) = delete; + noncopyable& operator=(const noncopyable&) = delete; + }; +} diff --git a/headers/meta.hpp/meta_base/overloaded.hpp b/headers/meta.hpp/meta_base/overloaded.hpp new file mode 100644 index 0000000..4135fef --- /dev/null +++ b/headers/meta.hpp/meta_base/overloaded.hpp @@ -0,0 +1,18 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +namespace meta_hpp::detail +{ + template < typename... Ts > + struct overloaded : Ts... { + using Ts::operator()...; + }; + + template < typename... Ts > + overloaded(Ts...) -> overloaded; +} diff --git a/headers/meta.hpp/meta_base/select_overload.hpp b/headers/meta.hpp/meta_base/select_overload.hpp new file mode 100644 index 0000000..f561a5c --- /dev/null +++ b/headers/meta.hpp/meta_base/select_overload.hpp @@ -0,0 +1,40 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +namespace meta_hpp::detail +{ + template < typename C, typename R, typename... Args > + constexpr auto select_const(R (C::*func)(Args...) const) -> decltype(func) { + return func; + } + + template < typename C, typename R, typename... Args > + constexpr auto select_const(R (C::*func)(Args...) const noexcept) -> decltype(func) { + return func; + } + + template < typename C, typename R, typename... Args > + constexpr auto select_non_const(R (C::*func)(Args...)) -> decltype(func) { + return func; + } + + template < typename C, typename R, typename... Args > + constexpr auto select_non_const(R (C::*func)(Args...) noexcept) -> decltype(func) { + return func; + } + + template < typename Signature > + constexpr auto select_overload(Signature* func) noexcept -> decltype(func) { + return func; + } + + template < typename Signature, typename C > + constexpr auto select_overload(Signature C::*func) noexcept -> decltype(func) { + return func; + } +} diff --git a/headers/meta.hpp/meta_base/stdex.hpp b/headers/meta.hpp/meta_base/stdex.hpp new file mode 100644 index 0000000..5e6e30d --- /dev/null +++ b/headers/meta.hpp/meta_base/stdex.hpp @@ -0,0 +1,56 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include + +namespace meta_hpp::stdex +{ + template < typename T, typename U > + concept same_as = + std::is_same_v && + std::is_same_v; + + template < typename Derived, typename Base > + concept derived_from = + std::is_base_of_v && + std::is_convertible_v; + + template < typename From, typename To > + concept convertible_to = + std::is_convertible_v && + requires { static_cast(std::declval()); }; + + template < typename T > + concept destructible = + std::is_nothrow_destructible_v; + + template < typename T, typename... Args > + concept constructible_from = + destructible && + std::is_constructible_v; + + template < typename T > + concept move_constructible = + constructible_from && + convertible_to; + + template + concept copy_constructible = + move_constructible && + constructible_from && convertible_to && + constructible_from && convertible_to && + constructible_from && convertible_to; +} + +namespace meta_hpp::stdex +{ + template < typename Enum > + [[nodiscard]] constexpr std::underlying_type_t to_underlying(Enum e) noexcept { + return static_cast>(e); + } +} diff --git a/headers/meta.hpp/meta_base/type_id.hpp b/headers/meta.hpp/meta_base/type_id.hpp new file mode 100644 index 0000000..7b0da4f --- /dev/null +++ b/headers/meta.hpp/meta_base/type_id.hpp @@ -0,0 +1,62 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include +#include +#include + +#include "type_list.hpp" + +namespace meta_hpp::detail +{ + class type_id final { + public: + template < typename T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit type_id(type_list) noexcept + : id_{type_to_id()} {} + + type_id(type_id&&) = default; + type_id(const type_id&) = default; + + type_id& operator=(type_id&&) = default; + type_id& operator=(const type_id&) = default; + + ~type_id() = default; + + [[nodiscard]] std::size_t get_hash() const noexcept { + return std::hash{}(id_); + } + + [[nodiscard]] friend bool operator<(type_id l, type_id r) noexcept { + return l.id_ < r.id_; + } + + [[nodiscard]] friend bool operator==(type_id l, type_id r) noexcept { + return l.id_ == r.id_; + } + + [[nodiscard]] friend bool operator!=(type_id l, type_id r) noexcept { + return l.id_ != r.id_; + } + private: + using underlying_type = std::uint32_t; + underlying_type id_{}; + private: + [[nodiscard]] static underlying_type next() noexcept { + static std::atomic id{}; + return ++id; + } + + template < typename T > + [[nodiscard]] static underlying_type type_to_id() noexcept { + static const underlying_type id{next()}; + return id; + } + }; +} diff --git a/headers/meta.hpp/meta_kinds.hpp b/headers/meta.hpp/meta_base/type_kinds.hpp similarity index 50% rename from headers/meta.hpp/meta_kinds.hpp rename to headers/meta.hpp/meta_base/type_kinds.hpp index 72691a6..dd39caf 100644 --- a/headers/meta.hpp/meta_kinds.hpp +++ b/headers/meta.hpp/meta_base/type_kinds.hpp @@ -6,26 +6,8 @@ #pragma once -#include "meta_base.hpp" - -namespace meta_hpp -{ - enum class type_kind : std::uint32_t { - array_, - class_, - ctor_, - dtor_, - enum_, - function_, - member_, - method_, - nullptr_, - number_, - pointer_, - reference_, - void_, - }; -} +#include +#include namespace meta_hpp::detail { @@ -61,6 +43,25 @@ namespace meta_hpp::detail template < typename T > concept void_kind = std::is_void_v; +} + +namespace meta_hpp::detail +{ + enum class type_kind : std::uint32_t { + array_, + class_, + ctor_, + dtor_, + enum_, + function_, + member_, + method_, + nullptr_, + number_, + pointer_, + reference_, + void_, + }; template < typename T > constexpr type_kind make_type_kind() noexcept { @@ -77,96 +78,3 @@ namespace meta_hpp::detail if constexpr ( void_kind ) { return type_kind::void_; } } } - -namespace meta_hpp::detail -{ - template < type_kind Kind > - struct type_kind_traits; - - template <> - struct type_kind_traits { - using kind_type = array_type; - using kind_type_data = array_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = class_type; - using kind_type_data = class_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = ctor_type; - using kind_type_data = ctor_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = dtor_type; - using kind_type_data = dtor_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = enum_type; - using kind_type_data = enum_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = function_type; - using kind_type_data = function_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = member_type; - using kind_type_data = member_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = method_type; - using kind_type_data = method_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = nullptr_type; - using kind_type_data = nullptr_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = number_type; - using kind_type_data = number_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = pointer_type; - using kind_type_data = pointer_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = reference_type; - using kind_type_data = reference_type_data; - }; - - template <> - struct type_kind_traits { - using kind_type = void_type; - using kind_type_data = void_type_data; - }; - - template < typename T > - using kind_type = typename type_kind_traits()>::kind_type; - - template < typename T > - using kind_type_data = typename type_kind_traits()>::kind_type_data; - - template < typename T > - using kind_type_data_ptr = std::shared_ptr>; -} diff --git a/headers/meta.hpp/meta_base/type_list.hpp b/headers/meta.hpp/meta_base/type_list.hpp new file mode 100644 index 0000000..f6c5854 --- /dev/null +++ b/headers/meta.hpp/meta_base/type_list.hpp @@ -0,0 +1,26 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include + +namespace meta_hpp::detail +{ + template < typename... Types > + struct type_list {}; + + template < std::size_t Index, typename TypeList > + struct type_list_at; + + template < std::size_t Index, typename... Types > + struct type_list_at> { + using type = std::tuple_element_t>; + }; + + template < std::size_t Index, typename TypeList > + using type_list_at_t = typename type_list_at::type; +} diff --git a/headers/meta.hpp/meta_binds/class_bind.hpp b/headers/meta.hpp/meta_binds/class_bind.hpp index 3633f6c..ea00403 100644 --- a/headers/meta.hpp/meta_binds/class_bind.hpp +++ b/headers/meta.hpp/meta_binds/class_bind.hpp @@ -9,11 +9,13 @@ #include "../meta_base.hpp" #include "../meta_binds.hpp" +#include "../meta_detail/type_registry.hpp" + namespace meta_hpp { template < detail::class_kind Class > class_bind::class_bind() - : data_{detail::class_type_data::get_static()} {} + : data_{detail::type_access(detail::resolve_type())} {} template < detail::class_kind Class > class_bind::operator class_type() const noexcept { @@ -45,8 +47,8 @@ namespace meta_hpp class_bind& class_bind::base_() requires detail::class_bind_base_kind { - data_->bases.emplace(resolve_type()); - data_->bases_info.emplace(resolve_type(), detail::class_type_data::base_info{ + data_->bases.emplace(detail::resolve_type()); + data_->bases_info.emplace(detail::resolve_type(), detail::class_type_data::base_info{ .upcast = +[](void* derived) -> void* { return static_cast(static_cast(derived)); } diff --git a/headers/meta.hpp/meta_binds/enum_bind.hpp b/headers/meta.hpp/meta_binds/enum_bind.hpp index 2543892..28d91d6 100644 --- a/headers/meta.hpp/meta_binds/enum_bind.hpp +++ b/headers/meta.hpp/meta_binds/enum_bind.hpp @@ -9,11 +9,13 @@ #include "../meta_base.hpp" #include "../meta_binds.hpp" +#include "../meta_detail/type_registry.hpp" + namespace meta_hpp { template < detail::enum_kind Enum > enum_bind::enum_bind() - : data_{detail::enum_type_data::get_static()} {} + : data_{detail::type_access(detail::resolve_type())} {} template < detail::enum_kind Enum > enum_bind::operator enum_type() const noexcept { diff --git a/headers/meta.hpp/meta_binds/scope_bind.hpp b/headers/meta.hpp/meta_binds/scope_bind.hpp index 6f4c03c..9e3648a 100644 --- a/headers/meta.hpp/meta_binds/scope_bind.hpp +++ b/headers/meta.hpp/meta_binds/scope_bind.hpp @@ -9,6 +9,9 @@ #include "../meta_base.hpp" #include "../meta_binds.hpp" +#include "../meta_detail/state_registry.hpp" +#include "../meta_detail/type_registry.hpp" + namespace meta_hpp { // NOLINTNEXTLINE(readability-named-parameter) @@ -17,7 +20,7 @@ namespace meta_hpp // NOLINTNEXTLINE(readability-named-parameter) inline scope_bind::scope_bind(std::string_view name, static_tag) - : state_{detail::scope_state::get_static(name)} {} + : state_{detail::state_access(detail::resolve_scope(name))} {} inline scope_bind::operator scope() const noexcept { return scope{state_}; @@ -25,13 +28,13 @@ namespace meta_hpp template < detail::class_kind Class > scope_bind& scope_bind::class_(std::string name) { - state_->classes.emplace(std::move(name), resolve_type()); + state_->classes.emplace(std::move(name), detail::resolve_type()); return *this; } template < detail::enum_kind Enum > scope_bind& scope_bind::enum_(std::string name) { - state_->enums.emplace(std::move(name), resolve_type()); + state_->enums.emplace(std::move(name), detail::resolve_type()); return *this; } diff --git a/headers/meta.hpp/meta_detail/state_family.hpp b/headers/meta.hpp/meta_detail/state_family.hpp new file mode 100644 index 0000000..4954aa3 --- /dev/null +++ b/headers/meta.hpp/meta_detail/state_family.hpp @@ -0,0 +1,28 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" + +namespace meta_hpp::detail +{ + template < typename T > + concept state_family = + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as; + + template < state_family T > + [[nodiscard]] auto state_access(const T& state) { + return state.state_; + } +} diff --git a/headers/meta.hpp/meta_detail/state_registry.hpp b/headers/meta.hpp/meta_detail/state_registry.hpp new file mode 100644 index 0000000..9a21ced --- /dev/null +++ b/headers/meta.hpp/meta_detail/state_registry.hpp @@ -0,0 +1,54 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_states.hpp" + +namespace meta_hpp::detail +{ + class state_registry final { + public: + [[nodiscard]] static state_registry& instance() { + static state_registry instance; + return instance; + } + + [[nodiscard]] scope get_scope_by_name(std::string_view name) const noexcept { + if ( auto iter = scopes_.find(name); iter != scopes_.end() ) { + return iter->second; + } + return scope{}; + } + + [[nodiscard]] scope resolve_scope(std::string_view name) { + return ensure_scope(name); + } + private: + state_registry() = default; + + scope ensure_scope(std::string_view name) { + if ( auto iter = scopes_.find(name); iter != scopes_.end() ) { + return iter->second; + } + + return scopes_.emplace( + std::string{name}, + scope_state::make(std::string{name})).first->second; + } + private: + std::map> scopes_; + }; +} + +namespace meta_hpp::detail +{ + [[nodiscard]] inline scope resolve_scope(std::string_view name) { + state_registry& registry = state_registry::instance(); + return registry.resolve_scope(name); + } +} diff --git a/headers/meta.hpp/meta_detail/type_family.hpp b/headers/meta.hpp/meta_detail/type_family.hpp new file mode 100644 index 0000000..f6adfe3 --- /dev/null +++ b/headers/meta.hpp/meta_detail/type_family.hpp @@ -0,0 +1,34 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" + +namespace meta_hpp::detail +{ + template < typename T > + concept type_family = + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as; + + template < type_family T > + [[nodiscard]] auto type_access(const T& type) { + return type.data_; + } +} diff --git a/headers/meta.hpp/meta_detail/type_registry.hpp b/headers/meta.hpp/meta_detail/type_registry.hpp new file mode 100644 index 0000000..be9fb0d --- /dev/null +++ b/headers/meta.hpp/meta_detail/type_registry.hpp @@ -0,0 +1,265 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_types.hpp" + +namespace meta_hpp::detail +{ + class type_registry final { + public: + [[nodiscard]] static type_registry& instance() { + static type_registry instance; + return instance; + } + + [[nodiscard]] any_type get_type_by_id(type_id id) const noexcept { + if ( auto iter = type_by_id_.find(id); iter != type_by_id_.end() ) { + return iter->second; + } + return any_type{}; + } + + [[nodiscard]] any_type get_type_by_rtti(const std::type_index& index) const noexcept { + if ( auto iter = type_by_rtti_.find(index); iter != type_by_rtti_.end() ) { + return iter->second; + } + return any_type{}; + } + + // + // + // + + template < array_kind Array > + [[nodiscard]] array_type resolve_type() { return resolve_array_type(); } + + template < class_kind Class > + [[nodiscard]] class_type resolve_type() { return resolve_class_type(); } + + template < enum_kind Enum > + [[nodiscard]] enum_type resolve_type() { return resolve_enum_type(); } + + template < function_kind Function > + [[nodiscard]] function_type resolve_type() { return resolve_function_type(); } + + template < member_kind Member > + [[nodiscard]] member_type resolve_type() { return resolve_member_type(); } + + template < method_kind Method > + [[nodiscard]] method_type resolve_type() { return resolve_method_type(); } + + template < nullptr_kind Nullptr > + [[nodiscard]] nullptr_type resolve_type() { return resolve_nullptr_type(); } + + template < number_kind Number > + [[nodiscard]] number_type resolve_type() { return resolve_number_type(); } + + template < pointer_kind Pointer > + [[nodiscard]] pointer_type resolve_type() { return resolve_pointer_type(); } + + template < reference_kind Reference > + [[nodiscard]] reference_type resolve_type() { return resolve_reference_type(); } + + template < void_kind Void > + [[nodiscard]] void_type resolve_type() { return resolve_void_type(); } + + // + // + // + + template < array_kind Array > + [[nodiscard]] array_type resolve_array_type() { return array_type{resolve_array_type_data()}; } + + template < class_kind Class > + [[nodiscard]] class_type resolve_class_type() { return class_type{resolve_class_type_data()}; } + + template < class_kind Class, typename... Args > + [[nodiscard]] ctor_type resolve_ctor_type() { return ctor_type{resolve_ctor_type_data()}; } + + template < class_kind Class > + [[nodiscard]] dtor_type resolve_dtor_type() { return dtor_type{resolve_dtor_type_data()}; } + + template < enum_kind Enum > + [[nodiscard]] enum_type resolve_enum_type() { return enum_type{resolve_enum_type_data()}; } + + template < function_kind Function > + [[nodiscard]] function_type resolve_function_type() { return function_type{resolve_function_type_data()}; } + + template < member_kind Member > + [[nodiscard]] member_type resolve_member_type() { return member_type{resolve_member_type_data()}; } + + template < method_kind Method > + [[nodiscard]] method_type resolve_method_type() { return method_type{resolve_method_type_data()}; } + + template < nullptr_kind Nullptr > + [[nodiscard]] nullptr_type resolve_nullptr_type() { return nullptr_type{resolve_nullptr_type_data()}; } + + template < number_kind Number > + [[nodiscard]] number_type resolve_number_type() { return number_type{resolve_number_type_data()}; } + + template < pointer_kind Pointer > + [[nodiscard]] pointer_type resolve_pointer_type() { return pointer_type{resolve_pointer_type_data()}; } + + template < reference_kind Reference > + [[nodiscard]] reference_type resolve_reference_type() { return reference_type{resolve_reference_type_data()}; } + + template < void_kind Void > + [[nodiscard]] void_type resolve_void_type() { return void_type{resolve_void_type_data()}; } + + // + // + // + + template < array_kind Array > + [[nodiscard]] array_type_data_ptr resolve_array_type_data() { + static array_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < class_kind Class > + [[nodiscard]] class_type_data_ptr resolve_class_type_data() { + static class_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < class_kind Class, typename... Args > + [[nodiscard]] ctor_type_data_ptr resolve_ctor_type_data() { + static ctor_type_data_ptr data{std::make_shared(type_list{}, type_list{})}; + return data; + } + + template < class_kind Class > + [[nodiscard]] dtor_type_data_ptr resolve_dtor_type_data() { + static dtor_type_data_ptr data{std::make_shared(type_list{})}; + return data; + } + + template < enum_kind Enum > + [[nodiscard]] enum_type_data_ptr resolve_enum_type_data() { + static enum_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < function_kind Function > + [[nodiscard]] function_type_data_ptr resolve_function_type_data() { + static function_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < member_kind Member > + [[nodiscard]] member_type_data_ptr resolve_member_type_data() { + static member_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < method_kind Method > + [[nodiscard]] method_type_data_ptr resolve_method_type_data() { + static method_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < nullptr_kind Nullptr > + [[nodiscard]] nullptr_type_data_ptr resolve_nullptr_type_data() { + static nullptr_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < number_kind Number > + [[nodiscard]] number_type_data_ptr resolve_number_type_data() { + static number_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < pointer_kind Pointer > + [[nodiscard]] pointer_type_data_ptr resolve_pointer_type_data() { + static pointer_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < reference_kind Reference > + [[nodiscard]] reference_type_data_ptr resolve_reference_type_data() { + static reference_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + + template < void_kind Void > + [[nodiscard]] void_type_data_ptr resolve_void_type_data() { + static void_type_data_ptr data{std::make_shared(type_list{})}; + return ensure_type(data); + } + private: + type_registry() = default; + + template < typename Type, typename TypeData > + TypeData ensure_type(const TypeData& type_data) { + static std::once_flag init_flag{}; + std::call_once(init_flag, [this, &type_data](){ + type_by_id_[type_data->id] = any_type{type_data}; + type_by_rtti_[typeid(Type)] = any_type{type_data}; + }); + return type_data; + } + private: + std::map> type_by_id_; + std::map> type_by_rtti_; + }; +} + +namespace meta_hpp::detail +{ + template < typename T > + [[nodiscard]] auto resolve_type() { + type_registry& registry = type_registry::instance(); + return registry.resolve_type>(); + } + + template < typename... Ts > + [[nodiscard]] std::vector resolve_types() { + return { resolve_type()... }; + } +} + +namespace meta_hpp::detail +{ + template < class_kind Class, typename... Args > + ctor_type resolve_ctor_type() { + type_registry& registry = type_registry::instance(); + return registry.resolve_ctor_type(); + } + + template < class_kind Class > + dtor_type resolve_dtor_type() { + type_registry& registry = type_registry::instance(); + return registry.resolve_dtor_type(); + } +} + +namespace meta_hpp::detail +{ + template < typename T > + // NOLINTNEXTLINE(readability-named-parameter) + [[nodiscard]] auto resolve_type(T&&) { + return resolve_type>(); + } + + template < typename... Ts > + // NOLINTNEXTLINE(readability-named-parameter) + [[nodiscard]] std::vector resolve_types(type_list) { + return { resolve_type()... }; + } +} + +namespace meta_hpp::detail +{ + template < typename T > + [[nodiscard]] any_type resolve_polymorphic_type(T&& v) noexcept { + type_registry& registry = type_registry::instance(); + return registry.get_type_by_rtti(typeid(v)); + } +} diff --git a/headers/meta.hpp/meta_traits/array_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/array_traits.hpp similarity index 82% rename from headers/meta.hpp/meta_traits/array_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/array_traits.hpp index ce73e58..a5439bf 100644 --- a/headers/meta.hpp/meta_traits/array_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/array_traits.hpp @@ -6,8 +6,17 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class array_flags : std::uint32_t { + is_bounded = 1 << 0, + is_unbounded = 1 << 1, + }; + + ENUM_HPP_OPERATORS_DECL(array_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_traits/class_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/class_traits.hpp similarity index 86% rename from headers/meta.hpp/meta_traits/class_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/class_traits.hpp index e95665b..d5e8591 100644 --- a/headers/meta.hpp/meta_traits/class_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/class_traits.hpp @@ -6,8 +6,20 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class class_flags : std::uint32_t { + is_empty = 1 << 0, + is_final = 1 << 1, + is_abstract = 1 << 2, + is_polymorphic = 1 << 3, + is_template_instantiation = 1 << 4, + }; + + ENUM_HPP_OPERATORS_DECL(class_flags) +} namespace meta_hpp::detail { @@ -22,10 +34,6 @@ namespace meta_hpp::detail [[nodiscard]] static constexpr bitflags make_flags() noexcept { return {}; } - - [[nodiscard]] static std::vector make_argument_types() { - return {}; - } }; template < template < typename... > typename Class, typename... Args > @@ -37,10 +45,6 @@ namespace meta_hpp::detail [[nodiscard]] static constexpr bitflags make_flags() noexcept { return class_flags::is_template_instantiation; } - - [[nodiscard]] static std::vector make_argument_types() { - return { resolve_type()... }; - } }; } diff --git a/headers/meta.hpp/meta_traits/ctor_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/ctor_traits.hpp similarity index 83% rename from headers/meta.hpp/meta_traits/ctor_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/ctor_traits.hpp index e80e899..e910274 100644 --- a/headers/meta.hpp/meta_traits/ctor_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/ctor_traits.hpp @@ -6,8 +6,16 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class ctor_flags : std::uint32_t { + is_noexcept = 1 << 0, + }; + + ENUM_HPP_OPERATORS_DECL(ctor_flags) +} namespace meta_hpp::detail { @@ -27,9 +35,5 @@ namespace meta_hpp::detail return flags; } - - [[nodiscard]] static std::vector make_argument_types() { - return { resolve_type()... }; - } }; } diff --git a/headers/meta.hpp/meta_traits/dtor_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/dtor_traits.hpp similarity index 81% rename from headers/meta.hpp/meta_traits/dtor_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/dtor_traits.hpp index 1838343..8037180 100644 --- a/headers/meta.hpp/meta_traits/dtor_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/dtor_traits.hpp @@ -6,8 +6,16 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class dtor_flags : std::uint32_t { + is_noexcept = 1 << 0, + }; + + ENUM_HPP_OPERATORS_DECL(dtor_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_traits/enum_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/enum_traits.hpp similarity index 82% rename from headers/meta.hpp/meta_traits/enum_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/enum_traits.hpp index 45265a6..f347d8f 100644 --- a/headers/meta.hpp/meta_traits/enum_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/enum_traits.hpp @@ -6,8 +6,16 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class enum_flags : std::uint32_t { + is_scoped = 1 << 0, + }; + + ENUM_HPP_OPERATORS_DECL(enum_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_traits/function_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/function_traits.hpp similarity index 85% rename from headers/meta.hpp/meta_traits/function_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/function_traits.hpp index 0046345..e82fb71 100644 --- a/headers/meta.hpp/meta_traits/function_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/function_traits.hpp @@ -6,8 +6,16 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class function_flags : std::uint32_t { + is_noexcept = 1 << 0, + }; + + ENUM_HPP_OPERATORS_DECL(function_flags) +} namespace meta_hpp::detail { @@ -24,10 +32,6 @@ namespace meta_hpp::detail [[nodiscard]] static constexpr bitflags make_flags() noexcept { return {}; } - - [[nodiscard]] static std::vector make_argument_types() { - return { resolve_type()... }; - } }; template < typename R, typename... Args > diff --git a/headers/meta.hpp/meta_traits/member_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/member_traits.hpp similarity index 82% rename from headers/meta.hpp/meta_traits/member_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/member_traits.hpp index 8bf227a..adaf932 100644 --- a/headers/meta.hpp/meta_traits/member_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/member_traits.hpp @@ -6,8 +6,16 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class member_flags : std::uint32_t { + is_readonly = 1 << 0, + }; + + ENUM_HPP_OPERATORS_DECL(member_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_traits/method_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/method_traits.hpp similarity index 94% rename from headers/meta.hpp/meta_traits/method_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/method_traits.hpp index c82eea8..75384d5 100644 --- a/headers/meta.hpp/meta_traits/method_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/method_traits.hpp @@ -6,8 +6,19 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class method_flags : std::uint32_t { + is_const = 1 << 0, + is_noexcept = 1 << 1, + is_lvalue_qualified = 1 << 2, + is_rvalue_qualified = 1 << 3, + }; + + ENUM_HPP_OPERATORS_DECL(method_flags) +} namespace meta_hpp::detail { @@ -26,10 +37,6 @@ namespace meta_hpp::detail [[nodiscard]] static constexpr bitflags make_flags() noexcept { return {}; } - - [[nodiscard]] static std::vector make_argument_types() { - return { resolve_type()... }; - } }; template < typename R, typename C, typename... Args > diff --git a/headers/meta.hpp/meta_traits/number_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/number_traits.hpp similarity index 81% rename from headers/meta.hpp/meta_traits/number_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/number_traits.hpp index d6ec6df..c438770 100644 --- a/headers/meta.hpp/meta_traits/number_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/number_traits.hpp @@ -6,8 +6,19 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class number_flags : std::uint32_t { + is_signed = 1 << 0, + is_unsigned = 1 << 1, + is_integral = 1 << 2, + is_floating_point = 1 << 3, + }; + + ENUM_HPP_OPERATORS_DECL(number_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_traits/pointer_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/pointer_traits.hpp similarity index 81% rename from headers/meta.hpp/meta_traits/pointer_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/pointer_traits.hpp index f33682e..beebc8a 100644 --- a/headers/meta.hpp/meta_traits/pointer_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/pointer_traits.hpp @@ -6,8 +6,16 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class pointer_flags : std::uint32_t { + is_readonly = 1 << 0, + }; + + ENUM_HPP_OPERATORS_DECL(pointer_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_traits/reference_traits.hpp b/headers/meta.hpp/meta_detail/type_traits/reference_traits.hpp similarity index 81% rename from headers/meta.hpp/meta_traits/reference_traits.hpp rename to headers/meta.hpp/meta_detail/type_traits/reference_traits.hpp index ce04482..efd179e 100644 --- a/headers/meta.hpp/meta_traits/reference_traits.hpp +++ b/headers/meta.hpp/meta_detail/type_traits/reference_traits.hpp @@ -6,8 +6,18 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_traits.hpp" +#include "../../meta_base.hpp" + +namespace meta_hpp::detail +{ + enum class reference_flags : std::uint32_t { + is_readonly = 1 << 0, + is_lvalue = 1 << 1, + is_rvalue = 1 << 2, + }; + + ENUM_HPP_OPERATORS_DECL(reference_flags) +} namespace meta_hpp::detail { diff --git a/headers/meta.hpp/meta_utilities/value_traits/deref_traits.hpp b/headers/meta.hpp/meta_detail/value_traits/deref_traits.hpp similarity index 74% rename from headers/meta.hpp/meta_utilities/value_traits/deref_traits.hpp rename to headers/meta.hpp/meta_detail/value_traits/deref_traits.hpp index 6ac5ad0..b7a5f3f 100644 --- a/headers/meta.hpp/meta_utilities/value_traits/deref_traits.hpp +++ b/headers/meta.hpp/meta_detail/value_traits/deref_traits.hpp @@ -7,44 +7,44 @@ #pragma once #include "../../meta_base.hpp" -#include "../../meta_utilities.hpp" +#include "../../meta_value.hpp" namespace meta_hpp::detail { template < typename T > - struct value_deref_traits; + struct deref_traits; template < typename T > - concept has_value_deref_traits = requires(const T& v) { - { value_deref_traits{}(v) } -> stdex::convertible_to; + concept has_deref_traits = requires(const T& v) { + { deref_traits{}(v) } -> stdex::convertible_to; }; } namespace meta_hpp::detail { template < stdex::copy_constructible T > - struct value_deref_traits { + struct deref_traits { value operator()(T* v) const { return value{*v}; } }; template < stdex::copy_constructible T > - struct value_deref_traits { + struct deref_traits { value operator()(const T* v) const { return value{*v}; } }; template < stdex::copy_constructible T > - struct value_deref_traits> { + struct deref_traits> { value operator()(const std::shared_ptr& v) const { return value{*v}; } }; template < stdex::copy_constructible T > - struct value_deref_traits> { + struct deref_traits> { value operator()(const std::unique_ptr& v) const { return value{*v}; } diff --git a/headers/meta.hpp/meta_utilities/value_traits/equals_traits.hpp b/headers/meta.hpp/meta_detail/value_traits/equals_traits.hpp similarity index 75% rename from headers/meta.hpp/meta_utilities/value_traits/equals_traits.hpp rename to headers/meta.hpp/meta_detail/value_traits/equals_traits.hpp index 23ce64b..bd87246 100644 --- a/headers/meta.hpp/meta_utilities/value_traits/equals_traits.hpp +++ b/headers/meta.hpp/meta_detail/value_traits/equals_traits.hpp @@ -7,16 +7,16 @@ #pragma once #include "../../meta_base.hpp" -#include "../../meta_utilities.hpp" +#include "../../meta_value.hpp" namespace meta_hpp::detail { template < typename T > - struct value_equals_traits; + struct equals_traits; template < typename T > - concept has_value_equals_traits = requires(const T& l, const T& r) { - { value_equals_traits{}(l, r) } -> stdex::convertible_to; + concept has_equals_traits = requires(const T& l, const T& r) { + { equals_traits{}(l, r) } -> stdex::convertible_to; }; } @@ -26,7 +26,7 @@ namespace meta_hpp::detail requires requires(const T& l, const T& r) { { l == r } -> stdex::convertible_to; } - struct value_equals_traits { + struct equals_traits { bool operator()(const T& l, const T& r) const { return l == r; } diff --git a/headers/meta.hpp/meta_utilities/value_traits/index_traits.hpp b/headers/meta.hpp/meta_detail/value_traits/index_traits.hpp similarity index 75% rename from headers/meta.hpp/meta_utilities/value_traits/index_traits.hpp rename to headers/meta.hpp/meta_detail/value_traits/index_traits.hpp index 2382f84..22c5cce 100644 --- a/headers/meta.hpp/meta_utilities/value_traits/index_traits.hpp +++ b/headers/meta.hpp/meta_detail/value_traits/index_traits.hpp @@ -7,58 +7,58 @@ #pragma once #include "../../meta_base.hpp" -#include "../../meta_utilities.hpp" +#include "../../meta_value.hpp" namespace meta_hpp::detail { template < typename T > - struct value_index_traits; + struct index_traits; template < typename T > - concept has_value_index_traits = requires(const T& v, std::size_t i) { - { value_index_traits{}(v, i) } -> stdex::convertible_to; + concept has_index_traits = requires(const T& v, std::size_t i) { + { index_traits{}(v, i) } -> stdex::convertible_to; }; } namespace meta_hpp::detail { template < stdex::copy_constructible T > - struct value_index_traits { + struct index_traits { value operator()(T* v, std::size_t i) const { return value{*(v + i)}; } }; template < stdex::copy_constructible T > - struct value_index_traits { + struct index_traits { value operator()(const T* v, std::size_t i) const { return value{*(v + i)}; } }; template < stdex::copy_constructible T, std::size_t Size > - struct value_index_traits> { + struct index_traits> { value operator()(const std::array& v, std::size_t i) const { return value{v[i]}; } }; template < stdex::copy_constructible T, std::size_t Extent > - struct value_index_traits> { + struct index_traits> { value operator()(const std::span& v, std::size_t i) const { return value{v[i]}; } }; template < stdex::copy_constructible T, typename Traits, typename Allocator > - struct value_index_traits> { + struct index_traits> { value operator()(const std::basic_string& v, std::size_t i) const { return value{v[i]}; } }; template < stdex::copy_constructible T, typename Allocator > - struct value_index_traits> { + struct index_traits> { value operator()(const std::vector& v, std::size_t i) { return value{v[i]}; } diff --git a/headers/meta.hpp/meta_utilities/value_traits/istream_traits.hpp b/headers/meta.hpp/meta_detail/value_traits/istream_traits.hpp similarity index 75% rename from headers/meta.hpp/meta_utilities/value_traits/istream_traits.hpp rename to headers/meta.hpp/meta_detail/value_traits/istream_traits.hpp index 9d0f333..112a98a 100644 --- a/headers/meta.hpp/meta_utilities/value_traits/istream_traits.hpp +++ b/headers/meta.hpp/meta_detail/value_traits/istream_traits.hpp @@ -7,16 +7,16 @@ #pragma once #include "../../meta_base.hpp" -#include "../../meta_utilities.hpp" +#include "../../meta_value.hpp" namespace meta_hpp::detail { template < typename T > - struct value_istream_traits; + struct istream_traits; template < typename T > - concept has_value_istream_traits = requires(std::istream& is, T& v) { - { value_istream_traits{}(is, v) } -> stdex::convertible_to; + concept has_istream_traits = requires(std::istream& is, T& v) { + { istream_traits{}(is, v) } -> stdex::convertible_to; }; } @@ -26,7 +26,7 @@ namespace meta_hpp::detail requires requires(std::istream& is, T& v) { { is >> v } -> stdex::convertible_to; } - struct value_istream_traits { + struct istream_traits { std::istream& operator()(std::istream& is, T& v) const { return is >> v; } diff --git a/headers/meta.hpp/meta_utilities/value_traits/less_traits.hpp b/headers/meta.hpp/meta_detail/value_traits/less_traits.hpp similarity index 76% rename from headers/meta.hpp/meta_utilities/value_traits/less_traits.hpp rename to headers/meta.hpp/meta_detail/value_traits/less_traits.hpp index e79e1b2..ac39ce4 100644 --- a/headers/meta.hpp/meta_utilities/value_traits/less_traits.hpp +++ b/headers/meta.hpp/meta_detail/value_traits/less_traits.hpp @@ -7,16 +7,16 @@ #pragma once #include "../../meta_base.hpp" -#include "../../meta_utilities.hpp" +#include "../../meta_value.hpp" namespace meta_hpp::detail { template < typename T > - struct value_less_traits; + struct less_traits; template < typename T > - concept has_value_less_traits = requires(const T& l, const T& r) { - { value_less_traits{}(l, r) } -> stdex::convertible_to; + concept has_less_traits = requires(const T& l, const T& r) { + { less_traits{}(l, r) } -> stdex::convertible_to; }; } @@ -26,7 +26,7 @@ namespace meta_hpp::detail requires requires(const T& l, const T& r) { { l < r } -> stdex::convertible_to; } - struct value_less_traits { + struct less_traits { bool operator()(const T& l, const T& r) const { return l < r; } diff --git a/headers/meta.hpp/meta_utilities/value_traits/ostream_traits.hpp b/headers/meta.hpp/meta_detail/value_traits/ostream_traits.hpp similarity index 75% rename from headers/meta.hpp/meta_utilities/value_traits/ostream_traits.hpp rename to headers/meta.hpp/meta_detail/value_traits/ostream_traits.hpp index 95f8601..ee8b701 100644 --- a/headers/meta.hpp/meta_utilities/value_traits/ostream_traits.hpp +++ b/headers/meta.hpp/meta_detail/value_traits/ostream_traits.hpp @@ -7,16 +7,16 @@ #pragma once #include "../../meta_base.hpp" -#include "../../meta_utilities.hpp" +#include "../../meta_value.hpp" namespace meta_hpp::detail { template < typename T > - struct value_ostream_traits; + struct ostream_traits; template < typename T > - concept has_value_ostream_traits = requires(std::ostream& os, const T& v) { - { value_ostream_traits{}(os, v) } -> stdex::convertible_to; + concept has_ostream_traits = requires(std::ostream& os, const T& v) { + { ostream_traits{}(os, v) } -> stdex::convertible_to; }; } @@ -26,7 +26,7 @@ namespace meta_hpp::detail requires requires(std::ostream& os, const T& v) { { os << v } -> stdex::convertible_to; } - struct value_ostream_traits { + struct ostream_traits { std::ostream& operator()(std::ostream& os, const T& v) const { return os << v; } diff --git a/headers/meta.hpp/meta_utilities/arg.hpp b/headers/meta.hpp/meta_detail/value_utilities/arg.hpp similarity index 69% rename from headers/meta.hpp/meta_utilities/arg.hpp rename to headers/meta.hpp/meta_detail/value_utilities/arg.hpp index 9181066..efff645 100644 --- a/headers/meta.hpp/meta_utilities/arg.hpp +++ b/headers/meta.hpp/meta_detail/value_utilities/arg.hpp @@ -6,76 +6,140 @@ #pragma once -#include "../meta_base.hpp" -#include "../meta_utilities.hpp" +#include "../../meta_base.hpp" +#include "../../meta_value.hpp" + +#include "utraits.hpp" namespace meta_hpp::detail { - template < decay_value_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - arg_base::arg_base(T&&) - : arg_base{type_list{}} {} + class arg_base { + public: + enum class ref_types { + lvalue, + const_lvalue, + rvalue, + const_rvalue, + }; + public: + arg_base() = delete; - template < decay_non_uvalue_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - arg_base::arg_base(T&&) - : arg_base{type_list{}} {} + arg_base(arg_base&&) = default; + arg_base(const arg_base&) = default; - template < arg_lvalue_ref_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - arg_base::arg_base(type_list) - : ref_type_{std::is_const_v> - ? ref_types::const_lvalue - : ref_types::lvalue} - , raw_type_{resolve_type>()} {} + arg_base& operator=(arg_base&&) = delete; + arg_base& operator=(const arg_base&) = delete; - template < arg_rvalue_ref_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - arg_base::arg_base(type_list) - : ref_type_{std::is_const_v> - ? ref_types::const_rvalue - : ref_types::rvalue} - , raw_type_{resolve_type>()} {} + virtual ~arg_base() = default; - inline arg_base::arg_base(value& v) - : ref_type_{ref_types::lvalue} - , raw_type_{v.get_type()} {} + template < decay_value_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit arg_base(T&&) + : arg_base{type_list{}} {} - inline arg_base::arg_base(const value& v) - : ref_type_{ref_types::const_lvalue} - , raw_type_{v.get_type()} {} + template < decay_non_uvalue_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit arg_base(T&&) + : arg_base{type_list{}} {} - inline arg_base::arg_base(value&& v) - : ref_type_{ref_types::rvalue} - , raw_type_{v.get_type()} {} + template < arg_lvalue_ref_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit arg_base(type_list) + : ref_type_{std::is_const_v> + ? ref_types::const_lvalue + : ref_types::lvalue} + , raw_type_{resolve_type>()} {} - inline arg_base::arg_base(const value&& v) - : ref_type_{ref_types::const_rvalue} - , raw_type_{v.get_type()} {} + template < arg_rvalue_ref_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit arg_base(type_list) + : ref_type_{std::is_const_v> + ? ref_types::const_rvalue + : ref_types::rvalue} + , raw_type_{resolve_type>()} {} - inline bool arg_base::is_const() const noexcept { - return ref_type_ == ref_types::const_lvalue - || ref_type_ == ref_types::const_rvalue; - } + explicit arg_base(value& v) + : ref_type_{ref_types::lvalue} + , raw_type_{v.get_type()} {} - inline bool arg_base::is_lvalue() const noexcept { - return ref_type_ == ref_types::lvalue - || ref_type_ == ref_types::const_lvalue; - } + explicit arg_base(const value& v) + : ref_type_{ref_types::const_lvalue} + , raw_type_{v.get_type()} {} - inline bool arg_base::is_rvalue() const noexcept { - return ref_type_ == ref_types::rvalue - || ref_type_ == ref_types::const_rvalue; - } + explicit arg_base(value&& v) + : ref_type_{ref_types::rvalue} + , raw_type_{v.get_type()} {} - inline arg_base::ref_types arg_base::get_ref_type() const noexcept { - return ref_type_; - } + explicit arg_base(const value&& v) + : ref_type_{ref_types::const_rvalue} + , raw_type_{v.get_type()} {} - inline const any_type& arg_base::get_raw_type() const noexcept { - return raw_type_; - } + [[nodiscard]] bool is_const() const noexcept { + return ref_type_ == ref_types::const_lvalue + || ref_type_ == ref_types::const_rvalue; + } + [[nodiscard]] bool is_lvalue() const noexcept { + return ref_type_ == ref_types::lvalue + || ref_type_ == ref_types::const_lvalue; + } + + [[nodiscard]] bool is_rvalue() const noexcept { + return ref_type_ == ref_types::rvalue + || ref_type_ == ref_types::const_rvalue; + } + + [[nodiscard]] ref_types get_ref_type() const noexcept { + return ref_type_; + } + + [[nodiscard]] const any_type& get_raw_type() const noexcept { + return raw_type_; + } + + template < typename To > + [[nodiscard]] bool can_cast_to() const noexcept; + private: + ref_types ref_type_{}; + any_type raw_type_{}; + }; +} + +namespace meta_hpp::detail +{ + class arg final : public arg_base { + public: + arg() = delete; + + arg(arg&&) = default; + arg(const arg&) = default; + + arg& operator=(arg&&) = delete; + arg& operator=(const arg&) = delete; + + ~arg() override = default; + + template < decay_value_kind T > + explicit arg(T&& v) + : arg_base{std::forward(v)} + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) + , data_{const_cast(v.data())} {} + + template < decay_non_uvalue_kind T > + explicit arg(T&& v) + : arg_base{std::forward(v)} + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) + , data_{const_cast*>(std::addressof(v))} {} + + template < typename To > + [[nodiscard]] To cast() const; + private: + void* data_{}; + }; +} + +namespace meta_hpp::detail +{ template < typename To > // NOLINTNEXTLINE(readability-function-cognitive-complexity) bool arg_base::can_cast_to() const noexcept { @@ -182,18 +246,6 @@ namespace meta_hpp::detail namespace meta_hpp::detail { - template < decay_value_kind T > - arg::arg(T&& v) - : arg_base{std::forward(v)} - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) - , data_{const_cast(v.data())} {} - - template < decay_non_uvalue_kind T > - arg::arg(T&& v) - : arg_base{std::forward(v)} - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) - , data_{const_cast*>(std::addressof(v))} {} - template < typename To > // NOLINTNEXTLINE(readability-function-cognitive-complexity) To arg::cast() const { @@ -227,7 +279,7 @@ namespace meta_hpp::detail const class_type& to_data_class = to_data_type.as_class(); const class_type& from_data_class = from_data_type.as_class(); - void* to_ptr = detail::pointer_upcast(data_, from_data_class, to_data_class); + void* to_ptr = pointer_upcast(data_, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -249,7 +301,7 @@ namespace meta_hpp::detail const class_type& to_data_class = to_data_type.as_class(); const class_type& from_data_class = from_data_type.as_class(); - void* to_ptr = detail::pointer_upcast(*from_data_ptr, from_data_class, to_data_class); + void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -270,7 +322,7 @@ namespace meta_hpp::detail const class_type& to_class = to_type.as_class(); const class_type& from_class = from_type.as_class(); - void* to_ptr = detail::pointer_upcast(data_, from_class, to_class); + void* to_ptr = pointer_upcast(data_, from_class, to_class); if constexpr ( std::is_lvalue_reference_v ) { return *static_cast(to_ptr); diff --git a/headers/meta.hpp/meta_detail/value_utilities/inst.hpp b/headers/meta.hpp/meta_detail/value_utilities/inst.hpp new file mode 100644 index 0000000..e1dc7eb --- /dev/null +++ b/headers/meta.hpp/meta_detail/value_utilities/inst.hpp @@ -0,0 +1,210 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../../meta_base.hpp" +#include "../../meta_value.hpp" + +#include "utraits.hpp" + +namespace meta_hpp::detail +{ + class inst_base { + public: + enum class ref_types { + lvalue, + const_lvalue, + rvalue, + const_rvalue, + }; + public: + inst_base() = delete; + + inst_base(inst_base&&) = default; + inst_base(const inst_base&) = default; + + inst_base& operator=(inst_base&&) = delete; + inst_base& operator=(const inst_base&) = delete; + + virtual ~inst_base() = default; + + template < decay_value_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit inst_base(T&&) + : inst_base{type_list{}} {} + + template < decay_non_uvalue_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit inst_base(T&&) + : inst_base{type_list{}} {} + + template < inst_class_lvalue_ref_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit inst_base(type_list) + : ref_type_{std::is_const_v> + ? ref_types::const_lvalue + : ref_types::lvalue} + , raw_type_{resolve_type>()} {} + + template < inst_class_rvalue_ref_kind T > + // NOLINTNEXTLINE(readability-named-parameter) + explicit inst_base(type_list) + : ref_type_{std::is_const_v> + ? ref_types::const_rvalue + : ref_types::rvalue} + , raw_type_{resolve_type>()} {} + + explicit inst_base(value& v) + : ref_type_{ref_types::lvalue} + , raw_type_{v.get_type()} {} + + explicit inst_base(const value& v) + : ref_type_{ref_types::const_lvalue} + , raw_type_{v.get_type()} {} + + explicit inst_base(value&& v) + : ref_type_{ref_types::rvalue} + , raw_type_{v.get_type()} {} + + explicit inst_base(const value&& v) + : ref_type_{ref_types::const_rvalue} + , raw_type_{v.get_type()} {} + + [[nodiscard]] bool is_const() const noexcept { + return ref_type_ == ref_types::const_lvalue + || ref_type_ == ref_types::const_rvalue; + } + + [[nodiscard]] bool is_lvalue() const noexcept { + return ref_type_ == ref_types::lvalue + || ref_type_ == ref_types::const_lvalue; + } + + [[nodiscard]] bool is_rvalue() const noexcept { + return ref_type_ == ref_types::rvalue + || ref_type_ == ref_types::const_rvalue; + } + + [[nodiscard]] ref_types get_ref_type() const noexcept { + return ref_type_; + } + + [[nodiscard]] const any_type& get_raw_type() const noexcept { + return raw_type_; + } + + template < inst_class_ref_kind Q > + [[nodiscard]] bool can_cast_to() const noexcept; + private: + ref_types ref_type_{}; + any_type raw_type_{}; + }; +} + +namespace meta_hpp::detail +{ + class inst final : public inst_base { + public: + inst() = delete; + + inst(inst&&) = default; + inst(const inst&) = default; + + inst& operator=(inst&&) = delete; + inst& operator=(const inst&) = delete; + + ~inst() override = default; + + template < decay_value_kind T > + explicit inst(T&& v) + : inst_base{std::forward(v)} + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) + , data_{const_cast(v.data())} {} + + template < decay_non_uvalue_kind T > + explicit inst(T&& v) + : inst_base{std::forward(v)} + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) + , data_{const_cast*>(std::addressof(v))} {} + + template < inst_class_ref_kind Q > + [[nodiscard]] decltype(auto) cast() const; + private: + void* data_{}; + }; +} + +namespace meta_hpp::detail +{ + template < inst_class_ref_kind Q > + bool inst_base::can_cast_to() const noexcept { + using inst_class = typename inst_traits::class_type; + using inst_method = typename inst_traits::method_type; + + const any_type& from_type = get_raw_type(); + const any_type& to_type = resolve_type(); + + const auto is_a = [](const any_type& base, const any_type& derived){ + return (base == derived) + || (base.is_class() && derived.is_class() && base.as_class().is_base_of(derived.as_class())); + }; + + const auto is_invocable = [this](){ + switch ( get_ref_type() ) { + case ref_types::lvalue: + return std::is_invocable_v; + case ref_types::const_lvalue: + return std::is_invocable_v; + case ref_types::rvalue: + return std::is_invocable_v; + case ref_types::const_rvalue: + return std::is_invocable_v; + default: + return false; + } + }; + + return is_a(to_type, from_type) && is_invocable(); + } +} + +namespace meta_hpp::detail +{ + template < inst_class_ref_kind Q > + decltype(auto) inst::cast() const { + if ( !can_cast_to() ) { + throw std::logic_error("bad instance cast"); + } + + using inst_class_cv = std::remove_reference_t; + using inst_class = std::remove_cv_t; + + const any_type& from_type = get_raw_type(); + const any_type& to_type = resolve_type(); + + if ( from_type.is_class() && to_type.is_class() ) { + const class_type& from_class = from_type.as_class(); + const class_type& to_class = to_type.as_class(); + + void* to_ptr = pointer_upcast(data_, from_class, to_class); + + if constexpr ( !std::is_reference_v ) { + return *static_cast(to_ptr); + } + + if constexpr ( std::is_lvalue_reference_v ) { + return *static_cast(to_ptr); + } + + if constexpr ( std::is_rvalue_reference_v ) { + return std::move(*static_cast(to_ptr)); + } + } + + throw std::logic_error("bad instance cast"); + } +} diff --git a/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp b/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp new file mode 100644 index 0000000..5e1b18c --- /dev/null +++ b/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp @@ -0,0 +1,145 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../../meta_base.hpp" +#include "../../meta_value.hpp" + +namespace meta_hpp::detail +{ + template < typename T > + concept uvalue_kind = + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as || + stdex::same_as; + + template < typename T > + concept decay_uvalue_kind = uvalue_kind>; + + template < typename T > + concept decay_non_uvalue_kind = !decay_uvalue_kind; +} + +namespace meta_hpp::detail +{ + template < typename T > + concept arg_lvalue_ref_kind = + (decay_non_uvalue_kind) && + (std::is_lvalue_reference_v); + + template < typename T > + concept arg_rvalue_ref_kind = + (decay_non_uvalue_kind) && + (!std::is_reference_v || std::is_rvalue_reference_v); +} + +namespace meta_hpp::detail +{ + template < typename T > + concept inst_class_ref_kind = + (std::is_class_v) || + (std::is_reference_v && std::is_class_v>); + + template < typename T > + concept inst_class_lvalue_ref_kind = + (decay_non_uvalue_kind) && + (std::is_lvalue_reference_v && std::is_class_v>); + + template < typename T > + concept inst_class_rvalue_ref_kind = + (decay_non_uvalue_kind) && + (std::is_class_v || (std::is_rvalue_reference_v && std::is_class_v>)); +} + +namespace meta_hpp::detail +{ + namespace impl + { + template < inst_class_ref_kind Q, bool is_const, bool is_lvalue, bool is_rvalue > + struct inst_traits_impl; + + template < inst_class_ref_kind Q > + struct inst_traits_impl { + using class_type = std::remove_cvref_t; + using method_type = void(class_type::*)(); + }; + + template < inst_class_ref_kind Q > + struct inst_traits_impl { + using class_type = std::remove_cvref_t; + using method_type = void(class_type::*)() &; + }; + + template < inst_class_ref_kind Q > + struct inst_traits_impl { + using class_type = std::remove_cvref_t; + using method_type = void(class_type::*)() &&; + }; + + template < inst_class_ref_kind Q > + struct inst_traits_impl { + using class_type = std::remove_cvref_t; + using method_type = void(class_type::*)() const; + }; + + template < inst_class_ref_kind Q > + struct inst_traits_impl { + using class_type = std::remove_cvref_t; + using method_type = void(class_type::*)() const &; + }; + + template < inst_class_ref_kind Q > + struct inst_traits_impl { + using class_type = std::remove_cvref_t; + using method_type = void(class_type::*)() const &&; + }; + } + + template < inst_class_ref_kind Q > + struct inst_traits final : impl::inst_traits_impl::is_const, + cvref_traits::is_lvalue, + cvref_traits::is_rvalue> {}; +} + +namespace meta_hpp::detail +{ + [[nodiscard]] inline void* pointer_upcast(void* ptr, const class_type& from, const class_type& to) { + if ( nullptr == ptr || !from || !to ) { + return nullptr; + } + + if ( from == to ) { + return ptr; + } + + for ( auto&& [base, base_info] : type_access(from)->bases_info ) { + if ( base == to ) { + return base_info.upcast(ptr); + } + + if ( base.is_derived_from(to) ) { + return pointer_upcast(base_info.upcast(ptr), base, to); + } + } + + return nullptr; + } + + template < class_kind To, class_kind From > + [[nodiscard]] To* pointer_upcast(From* ptr) { + return static_cast(pointer_upcast(ptr, resolve_type(), resolve_type())); + } + + template < class_kind To, class_kind From > + [[nodiscard]] const To* pointer_upcast(const From* ptr) { + // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) + return pointer_upcast(const_cast(ptr)); + } +} diff --git a/headers/meta.hpp/meta_indices.hpp b/headers/meta.hpp/meta_indices.hpp new file mode 100644 index 0000000..581de66 --- /dev/null +++ b/headers/meta.hpp/meta_indices.hpp @@ -0,0 +1,150 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "meta_base.hpp" +#include "meta_types.hpp" + +namespace meta_hpp +{ + class ctor_index final { + public: + ctor_index() = delete; + + template < detail::class_kind Class, typename... Args > + [[nodiscard]] static ctor_index make(); + + [[nodiscard]] const ctor_type& get_type() const noexcept; + private: + explicit ctor_index(ctor_type type); + friend bool operator<(const ctor_index& l, const ctor_index& r) noexcept; + friend bool operator==(const ctor_index& l, const ctor_index& r) noexcept; + private: + ctor_type type_; + }; + + class dtor_index final { + public: + dtor_index() = delete; + + template < detail::class_kind Class > + [[nodiscard]] static dtor_index make(); + + [[nodiscard]] const dtor_type& get_type() const noexcept; + private: + explicit dtor_index(dtor_type type); + friend bool operator<(const dtor_index& l, const dtor_index& r) noexcept; + friend bool operator==(const dtor_index& l, const dtor_index& r) noexcept; + private: + dtor_type type_; + }; + + class evalue_index final { + public: + evalue_index() = delete; + + template < detail::enum_kind Enum > + [[nodiscard]] static evalue_index make(std::string name); + + [[nodiscard]] const enum_type& get_type() const noexcept; + [[nodiscard]] const std::string& get_name() const noexcept; + private: + explicit evalue_index(enum_type type, std::string name); + friend bool operator<(const evalue_index& l, const evalue_index& r) noexcept; + friend bool operator==(const evalue_index& l, const evalue_index& r) noexcept; + private: + enum_type type_; + std::string name_; + }; + + class function_index final { + public: + function_index() = delete; + + template < detail::function_kind Function > + [[nodiscard]] static function_index make(std::string name); + + [[nodiscard]] const function_type& get_type() const noexcept; + [[nodiscard]] const std::string& get_name() const noexcept; + private: + explicit function_index(function_type type, std::string name); + friend bool operator<(const function_index& l, const function_index& r) noexcept; + friend bool operator==(const function_index& l, const function_index& r) noexcept; + private: + function_type type_; + std::string name_; + }; + + class member_index final { + public: + member_index() = delete; + + template < detail::member_kind Member > + [[nodiscard]] static member_index make(std::string name); + + [[nodiscard]] const member_type& get_type() const noexcept; + [[nodiscard]] const std::string& get_name() const noexcept; + private: + explicit member_index(member_type type, std::string name); + friend bool operator<(const member_index& l, const member_index& r) noexcept; + friend bool operator==(const member_index& l, const member_index& r) noexcept; + private: + member_type type_; + std::string name_; + }; + + class method_index final { + public: + method_index() = delete; + + template < detail::method_kind Method > + [[nodiscard]] static method_index make(std::string name); + + [[nodiscard]] const method_type& get_type() const noexcept; + [[nodiscard]] const std::string& get_name() const noexcept; + private: + explicit method_index(method_type type, std::string name); + friend bool operator<(const method_index& l, const method_index& r) noexcept; + friend bool operator==(const method_index& l, const method_index& r) noexcept; + private: + method_type type_; + std::string name_; + }; + + class scope_index final { + public: + scope_index() = delete; + + [[nodiscard]] static scope_index make(std::string name); + + [[nodiscard]] const std::string& get_name() const noexcept; + private: + explicit scope_index(std::string name); + friend bool operator<(const scope_index& l, const scope_index& r) noexcept; + friend bool operator==(const scope_index& l, const scope_index& r) noexcept; + private: + std::string name_; + }; + + class variable_index final { + public: + variable_index() = delete; + + template < detail::pointer_kind Pointer > + [[nodiscard]] static variable_index make(std::string name); + + [[nodiscard]] const pointer_type& get_type() const noexcept; + [[nodiscard]] const std::string& get_name() const noexcept; + private: + explicit variable_index(pointer_type type, std::string name); + friend bool operator<(const variable_index& l, const variable_index& r) noexcept; + friend bool operator==(const variable_index& l, const variable_index& r) noexcept; + private: + pointer_type type_; + std::string name_; + }; +} diff --git a/headers/meta.hpp/meta_indices/ctor_index.hpp b/headers/meta.hpp/meta_indices/ctor_index.hpp new file mode 100644 index 0000000..0d83eb6 --- /dev/null +++ b/headers/meta.hpp/meta_indices/ctor_index.hpp @@ -0,0 +1,36 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline ctor_index::ctor_index(ctor_type type) + : type_{std::move(type)} {} + + template < detail::class_kind Class, typename... Args > + ctor_index ctor_index::make() { + return ctor_index{detail::resolve_ctor_type()}; + } + + inline const ctor_type& ctor_index::get_type() const noexcept { + return type_; + } + + inline bool operator<(const ctor_index& l, const ctor_index& r) noexcept { + return l.type_ < r.type_; + } + + inline bool operator==(const ctor_index& l, const ctor_index& r) noexcept { + return l.type_ == r.type_; + } +} diff --git a/headers/meta.hpp/meta_indices/dtor_index.hpp b/headers/meta.hpp/meta_indices/dtor_index.hpp new file mode 100644 index 0000000..e62828d --- /dev/null +++ b/headers/meta.hpp/meta_indices/dtor_index.hpp @@ -0,0 +1,36 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline dtor_index::dtor_index(dtor_type type) + : type_{std::move(type)} {} + + template < detail::class_kind Class > + dtor_index dtor_index::make() { + return dtor_index{detail::resolve_dtor_type()}; + } + + inline const dtor_type& dtor_index::get_type() const noexcept { + return type_; + } + + inline bool operator<(const dtor_index& l, const dtor_index& r) noexcept { + return l.type_ < r.type_; + } + + inline bool operator==(const dtor_index& l, const dtor_index& r) noexcept { + return l.type_ == r.type_; + } +} diff --git a/headers/meta.hpp/meta_indices/evalue_index.hpp b/headers/meta.hpp/meta_indices/evalue_index.hpp new file mode 100644 index 0000000..8381bc8 --- /dev/null +++ b/headers/meta.hpp/meta_indices/evalue_index.hpp @@ -0,0 +1,41 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline evalue_index::evalue_index(enum_type type, std::string name) + : type_{std::move(type)} + , name_{std::move(name)} {} + + template < detail::enum_kind Enum > + evalue_index evalue_index::make(std::string name) { + return evalue_index{detail::resolve_type(), std::move(name)}; + } + + inline const enum_type& evalue_index::get_type() const noexcept { + return type_; + } + + inline const std::string& evalue_index::get_name() const noexcept { + return name_; + } + + inline bool operator<(const evalue_index& l, const evalue_index& r) noexcept { + return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_); + } + + inline bool operator==(const evalue_index& l, const evalue_index& r) noexcept { + return l.type_ == r.type_ && l.name_ == r.name_; + } +} diff --git a/headers/meta.hpp/meta_indices/function_index.hpp b/headers/meta.hpp/meta_indices/function_index.hpp new file mode 100644 index 0000000..a63aaad --- /dev/null +++ b/headers/meta.hpp/meta_indices/function_index.hpp @@ -0,0 +1,41 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline function_index::function_index(function_type type, std::string name) + : type_{std::move(type)} + , name_{std::move(name)} {} + + template < detail::function_kind Function > + function_index function_index::make(std::string name) { + return function_index{detail::resolve_type(), std::move(name)}; + } + + inline const function_type& function_index::get_type() const noexcept { + return type_; + } + + inline const std::string& function_index::get_name() const noexcept { + return name_; + } + + inline bool operator<(const function_index& l, const function_index& r) noexcept { + return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_); + } + + inline bool operator==(const function_index& l, const function_index& r) noexcept { + return l.type_ == r.type_ && l.name_ == r.name_; + } +} diff --git a/headers/meta.hpp/meta_indices/member_index.hpp b/headers/meta.hpp/meta_indices/member_index.hpp new file mode 100644 index 0000000..3101f0f --- /dev/null +++ b/headers/meta.hpp/meta_indices/member_index.hpp @@ -0,0 +1,41 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline member_index::member_index(member_type type, std::string name) + : type_{std::move(type)} + , name_{std::move(name)} {} + + template < detail::member_kind Member > + member_index member_index::make(std::string name) { + return member_index{detail::resolve_type(), std::move(name)}; + } + + inline const member_type& member_index::get_type() const noexcept { + return type_; + } + + inline const std::string& member_index::get_name() const noexcept { + return name_; + } + + inline bool operator<(const member_index& l, const member_index& r) noexcept { + return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_); + } + + inline bool operator==(const member_index& l, const member_index& r) noexcept { + return l.type_ == r.type_ && l.name_ == r.name_; + } +} diff --git a/headers/meta.hpp/meta_indices/method_index.hpp b/headers/meta.hpp/meta_indices/method_index.hpp new file mode 100644 index 0000000..8ad0a3a --- /dev/null +++ b/headers/meta.hpp/meta_indices/method_index.hpp @@ -0,0 +1,41 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline method_index::method_index(method_type type, std::string name) + : type_{std::move(type)} + , name_{std::move(name)} {} + + template < detail::method_kind Method > + method_index method_index::make(std::string name) { + return method_index{detail::resolve_type(), std::move(name)}; + } + + inline const method_type& method_index::get_type() const noexcept { + return type_; + } + + inline const std::string& method_index::get_name() const noexcept { + return name_; + } + + inline bool operator<(const method_index& l, const method_index& r) noexcept { + return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_); + } + + inline bool operator==(const method_index& l, const method_index& r) noexcept { + return l.type_ == r.type_ && l.name_ == r.name_; + } +} diff --git a/headers/meta.hpp/meta_indices/scope_index.hpp b/headers/meta.hpp/meta_indices/scope_index.hpp new file mode 100644 index 0000000..2beb83a --- /dev/null +++ b/headers/meta.hpp/meta_indices/scope_index.hpp @@ -0,0 +1,35 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_states.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline scope_index::scope_index(std::string name) + : name_{std::move(name)} {} + + inline scope_index scope_index::make(std::string name) { + return scope_index{std::move(name)}; + } + + inline const std::string& scope_index::get_name() const noexcept { + return name_; + } + + inline bool operator<(const scope_index& l, const scope_index& r) noexcept { + return l.name_ < r.name_; + } + + inline bool operator==(const scope_index& l, const scope_index& r) noexcept { + return l.name_ == r.name_; + } +} diff --git a/headers/meta.hpp/meta_indices/variable_index.hpp b/headers/meta.hpp/meta_indices/variable_index.hpp new file mode 100644 index 0000000..1bc700f --- /dev/null +++ b/headers/meta.hpp/meta_indices/variable_index.hpp @@ -0,0 +1,41 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "../meta_base.hpp" +#include "../meta_indices.hpp" +#include "../meta_types.hpp" + +#include "../meta_detail/type_registry.hpp" + +namespace meta_hpp +{ + inline variable_index::variable_index(pointer_type type, std::string name) + : type_{std::move(type)} + , name_{std::move(name)} {} + + template < detail::pointer_kind Pointer > + variable_index variable_index::make(std::string name) { + return variable_index{detail::resolve_type(), std::move(name)}; + } + + inline const pointer_type& variable_index::get_type() const noexcept { + return type_; + } + + inline const std::string& variable_index::get_name() const noexcept { + return name_; + } + + inline bool operator<(const variable_index& l, const variable_index& r) noexcept { + return l.type_ < r.type_ || (l.type_ == r.type_ && l.name_ < r.name_); + } + + inline bool operator==(const variable_index& l, const variable_index& r) noexcept { + return l.type_ == r.type_ && l.name_ == r.name_; + } +} diff --git a/headers/meta.hpp/meta_states.hpp b/headers/meta.hpp/meta_states.hpp index 578024f..5d6f667 100644 --- a/headers/meta.hpp/meta_states.hpp +++ b/headers/meta.hpp/meta_states.hpp @@ -7,56 +7,11 @@ #pragma once #include "meta_base.hpp" +#include "meta_indices.hpp" #include "meta_types.hpp" -#include "meta_utilities.hpp" +#include "meta_value.hpp" -namespace meta_hpp -{ - namespace detail - { - template < typename T > - concept state_family = - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v; - } - - template < detail::state_family T, detail::state_family U > - [[nodiscard]] bool operator<(const T& l, const U& r) noexcept { - if ( !static_cast(r) ) { - return false; - } - - if ( !static_cast(l) ) { - return true; - } - - return l.get_index() < r.get_index(); - } - - template < detail::state_family T, detail::state_family U > - [[nodiscard]] bool operator==(const T& l, const U& r) noexcept { - if ( static_cast(l) != static_cast(r) ) { - return false; - } - - if ( !static_cast(l) ) { - return true; - } - - return l.get_index() == r.get_index(); - } - - template < detail::state_family T, detail::state_family U > - [[nodiscard]] bool operator!=(const T& l, const U& r) noexcept { - return !(l == r); - } -} +#include "meta_detail/state_family.hpp" namespace meta_hpp { @@ -97,33 +52,33 @@ namespace meta_hpp template < typename Policy > concept ctor_policy_kind = - detail::stdex::same_as || - detail::stdex::same_as || - detail::stdex::same_as; + stdex::same_as || + stdex::same_as || + stdex::same_as; template < typename Policy > concept function_policy_kind = - detail::stdex::same_as || - detail::stdex::same_as || - detail::stdex::same_as; + stdex::same_as || + stdex::same_as || + stdex::same_as; template < typename Policy > concept member_policy_kind = - detail::stdex::same_as || - detail::stdex::same_as || - detail::stdex::same_as; + stdex::same_as || + stdex::same_as || + stdex::same_as; template < typename Policy > concept method_policy_kind = - detail::stdex::same_as || - detail::stdex::same_as || - detail::stdex::same_as; + stdex::same_as || + stdex::same_as || + stdex::same_as; template < typename Policy > concept variable_policy_kind = - detail::stdex::same_as || - detail::stdex::same_as || - detail::stdex::same_as; + stdex::same_as || + stdex::same_as || + stdex::same_as; } namespace meta_hpp @@ -152,6 +107,7 @@ namespace meta_hpp [[nodiscard]] bool is_invocable_with(Args&&... args) const noexcept; private: detail::ctor_state_ptr state_; + friend auto detail::state_access(const ctor&); }; class dtor final { @@ -178,6 +134,7 @@ namespace meta_hpp [[nodiscard]] bool is_invocable_with(Arg&& ptr) const noexcept; private: detail::dtor_state_ptr state_; + friend auto detail::state_access(const dtor&); }; class evalue final { @@ -196,6 +153,7 @@ namespace meta_hpp [[nodiscard]] const value& get_underlying_value() const noexcept; private: detail::evalue_state_ptr state_; + friend auto detail::state_access(const evalue&); }; class function final { @@ -223,6 +181,7 @@ namespace meta_hpp [[nodiscard]] bool is_invocable_with(Args&&... args) const noexcept; private: detail::function_state_ptr state_; + friend auto detail::state_access(const function&); }; class member final { @@ -262,6 +221,7 @@ namespace meta_hpp [[nodiscard]] bool is_settable_with(Instance&& instance, Value&& value) const noexcept; private: detail::member_state_ptr state_; + friend auto detail::state_access(const member&); }; class method final { @@ -289,6 +249,7 @@ namespace meta_hpp [[nodiscard]] bool is_invocable_with(Instance&& instance, Args&&... args) const noexcept; private: detail::method_state_ptr state_; + friend auto detail::state_access(const method&); }; class scope final { @@ -318,6 +279,7 @@ namespace meta_hpp [[nodiscard]] function get_function_with(std::string_view name, std::initializer_list args) const noexcept; private: detail::scope_state_ptr state_; + friend auto detail::state_access(const scope&); }; class variable final { @@ -349,9 +311,44 @@ namespace meta_hpp [[nodiscard]] bool is_settable_with(Value&& value) const noexcept; private: detail::variable_state_ptr state_; + friend auto detail::state_access(const variable&); }; } +namespace meta_hpp +{ + template < detail::state_family T, detail::state_family U > + [[nodiscard]] bool operator<(const T& l, const U& r) noexcept { + if ( !static_cast(r) ) { + return false; + } + + if ( !static_cast(l) ) { + return true; + } + + return l.get_index() < r.get_index(); + } + + template < detail::state_family T, detail::state_family U > + [[nodiscard]] bool operator==(const T& l, const U& r) noexcept { + if ( static_cast(l) != static_cast(r) ) { + return false; + } + + if ( !static_cast(l) ) { + return true; + } + + return l.get_index() == r.get_index(); + } + + template < detail::state_family T, detail::state_family U > + [[nodiscard]] bool operator!=(const T& l, const U& r) noexcept { + return !(l == r); + } +} + namespace meta_hpp::detail { struct ctor_state final { @@ -437,7 +434,6 @@ namespace meta_hpp::detail variable_map variables{}; [[nodiscard]] static scope_state_ptr make(std::string name); - [[nodiscard]] static scope_state_ptr get_static(std::string_view name); }; struct variable_state final { @@ -454,10 +450,3 @@ namespace meta_hpp::detail [[nodiscard]] static variable_state_ptr make(std::string name, Pointer pointer); }; } - -namespace meta_hpp -{ - [[nodiscard]] inline scope resolve_scope(std::string_view name) { - return scope{detail::scope_state::get_static(name)}; - } -} diff --git a/headers/meta.hpp/meta_states/ctor.hpp b/headers/meta.hpp/meta_states/ctor.hpp index 9726713..e278d09 100644 --- a/headers/meta.hpp/meta_states/ctor.hpp +++ b/headers/meta.hpp/meta_states/ctor.hpp @@ -10,6 +10,7 @@ #include "../meta_states.hpp" #include "../meta_types/ctor_type.hpp" +#include "../meta_detail/value_utilities/arg.hpp" namespace meta_hpp::detail { @@ -95,9 +96,8 @@ namespace meta_hpp::detail { template < ctor_policy_kind Policy, class_kind Class, typename... Args > ctor_state_ptr ctor_state::make() { - ctor_index index{ctor_type_data::get_static()}; return std::make_shared(ctor_state{ - .index{std::move(index)}, + .index{ctor_index::make()}, .invoke{make_ctor_invoke()}, .is_invocable_with{make_ctor_is_invocable_with()}, }); @@ -122,7 +122,7 @@ namespace meta_hpp } inline const ctor_type& ctor::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } template < typename... Args > diff --git a/headers/meta.hpp/meta_states/dtor.hpp b/headers/meta.hpp/meta_states/dtor.hpp index fdee5bd..06e6d22 100644 --- a/headers/meta.hpp/meta_states/dtor.hpp +++ b/headers/meta.hpp/meta_states/dtor.hpp @@ -10,6 +10,7 @@ #include "../meta_states.hpp" #include "../meta_types/dtor_type.hpp" +#include "../meta_detail/value_utilities/arg.hpp" namespace meta_hpp::detail { @@ -56,9 +57,8 @@ namespace meta_hpp::detail { template < class_kind Class > dtor_state_ptr dtor_state::make() { - dtor_index index{dtor_type_data::get_static()}; return std::make_shared(dtor_state{ - .index{std::move(index)}, + .index{dtor_index::make()}, .invoke{make_dtor_invoke()}, .is_invocable_with{make_dtor_is_invocable_with()}, }); @@ -83,7 +83,7 @@ namespace meta_hpp } inline const dtor_type& dtor::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } template < typename Arg > diff --git a/headers/meta.hpp/meta_states/evalue.hpp b/headers/meta.hpp/meta_states/evalue.hpp index 26e6f6e..a46da97 100644 --- a/headers/meta.hpp/meta_states/evalue.hpp +++ b/headers/meta.hpp/meta_states/evalue.hpp @@ -15,9 +15,8 @@ namespace meta_hpp::detail { template < enum_kind Enum > evalue_state_ptr evalue_state::make(std::string name, Enum evalue) { - evalue_index index{enum_type_data::get_static(), std::move(name)}; return std::make_shared(evalue_state{ - .index{std::move(index)}, + .index{evalue_index::make(std::move(name))}, .enum_value{value{evalue}}, .underlying_value{value{stdex::to_underlying(evalue)}}, }); @@ -42,11 +41,11 @@ namespace meta_hpp } inline const enum_type& evalue::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } inline const std::string& evalue::get_name() const noexcept { - return state_->index.name; + return state_->index.get_name(); } inline const value& evalue::get_value() const noexcept { diff --git a/headers/meta.hpp/meta_states/function.hpp b/headers/meta.hpp/meta_states/function.hpp index 3f7299f..d177062 100644 --- a/headers/meta.hpp/meta_states/function.hpp +++ b/headers/meta.hpp/meta_states/function.hpp @@ -10,6 +10,7 @@ #include "../meta_states.hpp" #include "../meta_types/function_type.hpp" +#include "../meta_detail/value_utilities/arg.hpp" namespace meta_hpp::detail { @@ -99,9 +100,8 @@ namespace meta_hpp::detail { template < function_policy_kind Policy, function_kind Function > function_state_ptr function_state::make(std::string name, Function function) { - function_index index{function_type_data::get_static(), std::move(name)}; return std::make_shared(function_state{ - .index{std::move(index)}, + .index{function_index::make(std::move(name))}, .invoke{make_function_invoke(std::move(function))}, .is_invocable_with{make_function_is_invocable_with()}, }); @@ -126,11 +126,11 @@ namespace meta_hpp } inline const function_type& function::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } inline const std::string& function::get_name() const noexcept { - return state_->index.name; + return state_->index.get_name(); } template < typename... Args > diff --git a/headers/meta.hpp/meta_states/member.hpp b/headers/meta.hpp/meta_states/member.hpp index 50287ab..c93eec8 100644 --- a/headers/meta.hpp/meta_states/member.hpp +++ b/headers/meta.hpp/meta_states/member.hpp @@ -10,6 +10,8 @@ #include "../meta_states.hpp" #include "../meta_types/member_type.hpp" +#include "../meta_detail/value_utilities/arg.hpp" +#include "../meta_detail/value_utilities/inst.hpp" namespace meta_hpp::detail { @@ -146,9 +148,8 @@ namespace meta_hpp::detail { template < member_policy_kind Policy, member_kind Member > member_state_ptr member_state::make(std::string name, Member member) { - member_index index{member_type_data::get_static(), std::move(name)}; return std::make_shared(member_state{ - .index{std::move(index)}, + .index{member_index::make(std::move(name))}, .getter{make_member_getter(std::move(member))}, .setter{make_member_setter(std::move(member))}, .is_gettable_with{make_member_is_gettable_with()}, @@ -175,11 +176,11 @@ namespace meta_hpp } inline const member_type& member::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } inline const std::string& member::get_name() const noexcept { - return state_->index.name; + return state_->index.get_name(); } template < typename Instance > diff --git a/headers/meta.hpp/meta_states/method.hpp b/headers/meta.hpp/meta_states/method.hpp index deb11a6..b59fbc2 100644 --- a/headers/meta.hpp/meta_states/method.hpp +++ b/headers/meta.hpp/meta_states/method.hpp @@ -10,6 +10,8 @@ #include "../meta_states.hpp" #include "../meta_types/method_type.hpp" +#include "../meta_detail/value_utilities/arg.hpp" +#include "../meta_detail/value_utilities/inst.hpp" namespace meta_hpp::detail { @@ -112,9 +114,8 @@ namespace meta_hpp::detail { template < method_policy_kind Policy, method_kind Method > method_state_ptr method_state::make(std::string name, Method method) { - method_index index{method_type_data::get_static(), std::move(name)}; return std::make_shared(method_state{ - .index{std::move(index)}, + .index{method_index::make(std::move(name))}, .invoke{make_method_invoke(std::move(method))}, .is_invocable_with{make_method_is_invocable_with()}, }); @@ -139,11 +140,11 @@ namespace meta_hpp } inline const method_type& method::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } inline const std::string& method::get_name() const noexcept { - return state_->index.name; + return state_->index.get_name(); } template < typename Instance, typename... Args > diff --git a/headers/meta.hpp/meta_states/scope.hpp b/headers/meta.hpp/meta_states/scope.hpp index 49b4016..81b56d9 100644 --- a/headers/meta.hpp/meta_states/scope.hpp +++ b/headers/meta.hpp/meta_states/scope.hpp @@ -8,25 +8,23 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_types.hpp" + +#include "../meta_types/class_type.hpp" +#include "../meta_types/enum_type.hpp" + +#include "../meta_states/function.hpp" +#include "../meta_states/variable.hpp" + +#include "../meta_detail/type_registry.hpp" namespace meta_hpp::detail { inline scope_state_ptr scope_state::make(std::string name) { - scope_index index{std::move(name)}; return std::make_shared(scope_state{ - .index{std::move(index)}, + .index{scope_index::make(std::move(name))}, }); } - - inline scope_state_ptr scope_state::get_static(std::string_view name) { - static std::map> states; - - if ( auto iter = states.find(name); iter != states.end() ) { - return iter->second; - } - - return states.emplace(std::string{name}, make(std::string{name})).first->second; - } } namespace meta_hpp @@ -47,7 +45,7 @@ namespace meta_hpp } inline const std::string& scope::get_name() const noexcept { - return state_->index.name; + return state_->index.get_name(); } inline const class_map& scope::get_classes() const noexcept { @@ -82,7 +80,7 @@ namespace meta_hpp inline function scope::get_function(std::string_view name) const noexcept { for ( auto&& [index, function] : state_->functions ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return function; } } @@ -91,7 +89,7 @@ namespace meta_hpp inline variable scope::get_variable(std::string_view name) const noexcept { for ( auto&& [index, variable] : state_->variables ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return variable; } } @@ -100,12 +98,12 @@ namespace meta_hpp template < typename... Args > function scope::get_function_with(std::string_view name) const noexcept { - return get_function_with(name, {resolve_type()...}); + return get_function_with(name, {detail::resolve_type()...}); } inline function scope::get_function_with(std::string_view name, const std::vector& args) const noexcept { for ( auto&& [index, function] : state_->functions ) { - if ( index.name != name ) { + if ( index.get_name() != name ) { continue; } @@ -123,7 +121,7 @@ namespace meta_hpp inline function scope::get_function_with(std::string_view name, std::initializer_list args) const noexcept { for ( auto&& [index, function] : state_->functions ) { - if ( index.name != name ) { + if ( index.get_name() != name ) { continue; } diff --git a/headers/meta.hpp/meta_states/variable.hpp b/headers/meta.hpp/meta_states/variable.hpp index 52e404f..fac956f 100644 --- a/headers/meta.hpp/meta_states/variable.hpp +++ b/headers/meta.hpp/meta_states/variable.hpp @@ -10,6 +10,7 @@ #include "../meta_states.hpp" #include "../meta_types/pointer_type.hpp" +#include "../meta_detail/value_utilities/arg.hpp" namespace meta_hpp::detail { @@ -95,9 +96,8 @@ namespace meta_hpp::detail { template < variable_policy_kind Policy, pointer_kind Pointer > variable_state_ptr variable_state::make(std::string name, Pointer pointer) { - variable_index index{pointer_type_data::get_static(), std::move(name)}; return std::make_shared(variable_state{ - .index{std::move(index)}, + .index{variable_index::make(std::move(name))}, .getter{make_variable_getter(std::move(pointer))}, .setter{make_variable_setter(std::move(pointer))}, .is_settable_with{make_variable_is_settable_with()}, @@ -123,11 +123,11 @@ namespace meta_hpp } inline const pointer_type& variable::get_type() const noexcept { - return state_->index.type; + return state_->index.get_type(); } inline const std::string& variable::get_name() const noexcept { - return state_->index.name; + return state_->index.get_name(); } inline value variable::get() const { diff --git a/headers/meta.hpp/meta_traits.hpp b/headers/meta.hpp/meta_traits.hpp deleted file mode 100644 index 5ce4006..0000000 --- a/headers/meta.hpp/meta_traits.hpp +++ /dev/null @@ -1,118 +0,0 @@ -/******************************************************************************* - * This file is part of the "https://github.com/blackmatov/meta.hpp" - * For conditions of distribution and use, see copyright notice in LICENSE.md - * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) - ******************************************************************************/ - -#pragma once - -#include "meta_base.hpp" -#include "meta_kinds.hpp" - -namespace meta_hpp::detail -{ - template < array_kind Array > - struct array_traits; - - template < class_kind Class > - struct class_traits; - - template < class_kind Class, typename... Args > - struct ctor_traits; - - template < class_kind Class > - struct dtor_traits; - - template < enum_kind Enum > - struct enum_traits; - - template < function_kind Function > - struct function_traits; - - template < member_kind Member > - struct member_traits; - - template < method_kind Method > - struct method_traits; - - template < number_kind Number > - struct number_traits; - - template < pointer_kind Pointer > - struct pointer_traits; - - template < reference_kind Reference > - struct reference_traits; -} - -namespace meta_hpp -{ - enum class array_flags : std::uint32_t { - is_bounded = 1 << 0, - is_unbounded = 1 << 1, - }; - - enum class class_flags : std::uint32_t { - is_empty = 1 << 0, - is_final = 1 << 1, - is_abstract = 1 << 2, - is_polymorphic = 1 << 3, - is_template_instantiation = 1 << 4, - }; - - enum class ctor_flags : std::uint32_t { - is_noexcept = 1 << 0, - }; - - enum class dtor_flags : std::uint32_t { - is_noexcept = 1 << 0, - }; - - enum class enum_flags : std::uint32_t { - is_scoped = 1 << 0, - }; - - enum class function_flags : std::uint32_t { - is_noexcept = 1 << 0, - }; - - enum class member_flags : std::uint32_t { - is_readonly = 1 << 0, - }; - - enum class method_flags : std::uint32_t { - is_const = 1 << 0, - is_noexcept = 1 << 1, - is_lvalue_qualified = 1 << 2, - is_rvalue_qualified = 1 << 3, - }; - - enum class number_flags : std::uint32_t { - is_signed = 1 << 0, - is_unsigned = 1 << 1, - is_integral = 1 << 2, - is_floating_point = 1 << 3, - }; - - enum class pointer_flags : std::uint32_t { - is_readonly = 1 << 0, - }; - - enum class reference_flags : std::uint32_t { - is_readonly = 1 << 0, - is_lvalue = 1 << 1, - is_rvalue = 1 << 2, - }; - - ENUM_HPP_OPERATORS_DECL(array_flags) - ENUM_HPP_OPERATORS_DECL(class_flags) - ENUM_HPP_OPERATORS_DECL(ctor_flags) - ENUM_HPP_OPERATORS_DECL(dtor_flags) - ENUM_HPP_OPERATORS_DECL(enum_flags) - ENUM_HPP_OPERATORS_DECL(function_flags) - ENUM_HPP_OPERATORS_DECL(member_flags) - ENUM_HPP_OPERATORS_DECL(method_flags) - ENUM_HPP_OPERATORS_DECL(number_flags) - ENUM_HPP_OPERATORS_DECL(pointer_flags) - ENUM_HPP_OPERATORS_DECL(reference_flags) -} diff --git a/headers/meta.hpp/meta_types.hpp b/headers/meta.hpp/meta_types.hpp index dd7b014..c1e38b0 100644 --- a/headers/meta.hpp/meta_types.hpp +++ b/headers/meta.hpp/meta_types.hpp @@ -7,114 +7,34 @@ #pragma once #include "meta_base.hpp" -#include "meta_traits.hpp" + +#include "meta_detail/type_family.hpp" + +#include "meta_detail/type_traits/array_traits.hpp" +#include "meta_detail/type_traits/class_traits.hpp" +#include "meta_detail/type_traits/ctor_traits.hpp" +#include "meta_detail/type_traits/dtor_traits.hpp" +#include "meta_detail/type_traits/enum_traits.hpp" +#include "meta_detail/type_traits/function_traits.hpp" +#include "meta_detail/type_traits/member_traits.hpp" +#include "meta_detail/type_traits/method_traits.hpp" +#include "meta_detail/type_traits/number_traits.hpp" +#include "meta_detail/type_traits/pointer_traits.hpp" +#include "meta_detail/type_traits/reference_traits.hpp" namespace meta_hpp { - class type_id final { - public: - template < typename T > - // NOLINTNEXTLINE(readability-named-parameter) - explicit type_id(detail::type_list) noexcept - : id_{type_to_id()} {} - - type_id(type_id&&) = default; - type_id(const type_id&) = default; - - type_id& operator=(type_id&&) = default; - type_id& operator=(const type_id&) = default; - - ~type_id() = default; - - [[nodiscard]] std::size_t get_hash() const noexcept { - return std::hash{}(id_); - } - - [[nodiscard]] friend bool operator<(type_id l, type_id r) noexcept { - return l.id_ < r.id_; - } - - [[nodiscard]] friend bool operator==(type_id l, type_id r) noexcept { - return l.id_ == r.id_; - } - - [[nodiscard]] friend bool operator!=(type_id l, type_id r) noexcept { - return l.id_ != r.id_; - } - private: - using underlying_type = std::uint32_t; - underlying_type id_{}; - private: - [[nodiscard]] static underlying_type next() noexcept { - static std::atomic id{}; - return ++id; - } - - template < typename T > - [[nodiscard]] static underlying_type type_to_id() noexcept { - static const underlying_type id{next()}; - return id; - } - }; -} - -namespace meta_hpp -{ - namespace detail - { - template < typename T > - concept type_family = - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v; - - template < type_family T > - [[nodiscard]] auto data_access(const T& type) { - return type.data_; - } - } - - template < detail::type_family T, detail::type_family U > - [[nodiscard]] bool operator<(const T& l, const U& r) noexcept { - if ( !static_cast(r) ) { - return false; - } - - if ( !static_cast(l) ) { - return true; - } - - return l.get_id() < r.get_id(); - } - - template < detail::type_family T, detail::type_family U > - [[nodiscard]] bool operator==(const T& l, const U& r) noexcept { - if ( static_cast(l) != static_cast(r) ) { - return false; - } - - if ( !static_cast(l) ) { - return true; - } - - return l.get_id() == r.get_id(); - } - - template < detail::type_family T, detail::type_family U > - [[nodiscard]] bool operator!=(const T& l, const U& r) noexcept { - return !(l == r); - } + using array_flags = detail::array_flags; + using class_flags = detail::class_flags; + using ctor_flags = detail::ctor_flags; + using dtor_flags = detail::dtor_flags; + using enum_flags = detail::enum_flags; + using function_flags = detail::function_flags; + using member_flags = detail::member_flags; + using method_flags = detail::method_flags; + using number_flags = detail::number_flags; + using pointer_flags = detail::pointer_flags; + using reference_flags = detail::reference_flags; } namespace meta_hpp @@ -122,7 +42,6 @@ namespace meta_hpp class any_type final { public: explicit any_type() = default; - explicit any_type(detail::type_data_base_ptr data); [[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] explicit operator bool() const noexcept; @@ -173,7 +92,7 @@ namespace meta_hpp [[nodiscard]] void_type as_void() const noexcept; private: detail::type_data_base_ptr data_; - friend auto detail::data_access(const any_type&); + friend auto detail::type_access(const any_type&); }; class array_type final { @@ -191,7 +110,7 @@ namespace meta_hpp [[nodiscard]] any_type get_data_type() const noexcept; private: detail::array_type_data_ptr data_; - friend auto detail::data_access(const array_type&); + friend auto detail::type_access(const array_type&); }; class class_type final { @@ -257,7 +176,7 @@ namespace meta_hpp [[nodiscard]] method get_method_with(std::string_view name, std::initializer_list args) const noexcept; private: detail::class_type_data_ptr data_; - friend auto detail::data_access(const class_type&); + friend auto detail::type_access(const class_type&); }; class ctor_type final { @@ -277,7 +196,7 @@ namespace meta_hpp [[nodiscard]] const std::vector& get_argument_types() const noexcept; private: detail::ctor_type_data_ptr data_; - friend auto detail::data_access(const ctor_type&); + friend auto detail::type_access(const ctor_type&); }; class dtor_type final { @@ -294,7 +213,7 @@ namespace meta_hpp [[nodiscard]] any_type get_class_type() const noexcept; private: detail::dtor_type_data_ptr data_; - friend auto detail::data_access(const dtor_type&); + friend auto detail::type_access(const dtor_type&); }; class enum_type final { @@ -319,7 +238,7 @@ namespace meta_hpp [[nodiscard]] value name_to_value(std::string_view name) const noexcept; private: detail::enum_type_data_ptr data_; - friend auto detail::data_access(const enum_type&); + friend auto detail::type_access(const enum_type&); }; class function_type final { @@ -339,7 +258,7 @@ namespace meta_hpp [[nodiscard]] const std::vector& get_argument_types() const noexcept; private: detail::function_type_data_ptr data_; - friend auto detail::data_access(const function_type&); + friend auto detail::type_access(const function_type&); }; class member_type final { @@ -357,7 +276,7 @@ namespace meta_hpp [[nodiscard]] any_type get_value_type() const noexcept; private: detail::member_type_data_ptr data_; - friend auto detail::data_access(const member_type&); + friend auto detail::type_access(const member_type&); }; class method_type final { @@ -378,7 +297,7 @@ namespace meta_hpp [[nodiscard]] const std::vector& get_argument_types() const noexcept; private: detail::method_type_data_ptr data_; - friend auto detail::data_access(const method_type&); + friend auto detail::type_access(const method_type&); }; class nullptr_type final { @@ -392,7 +311,7 @@ namespace meta_hpp [[nodiscard]] type_id get_id() const noexcept; private: detail::nullptr_type_data_ptr data_; - friend auto detail::data_access(const nullptr_type&); + friend auto detail::type_access(const nullptr_type&); }; class number_type final { @@ -409,7 +328,7 @@ namespace meta_hpp [[nodiscard]] std::size_t get_size() const noexcept; private: detail::number_type_data_ptr data_; - friend auto detail::data_access(const number_type&); + friend auto detail::type_access(const number_type&); }; class pointer_type final { @@ -426,7 +345,7 @@ namespace meta_hpp [[nodiscard]] any_type get_data_type() const noexcept; private: detail::pointer_type_data_ptr data_; - friend auto detail::data_access(const pointer_type&); + friend auto detail::type_access(const pointer_type&); }; class reference_type final { @@ -443,7 +362,7 @@ namespace meta_hpp [[nodiscard]] any_type get_data_type() const noexcept; private: detail::reference_type_data_ptr data_; - friend auto detail::data_access(const reference_type&); + friend auto detail::type_access(const reference_type&); }; class void_type final { @@ -457,10 +376,44 @@ namespace meta_hpp [[nodiscard]] type_id get_id() const noexcept; private: detail::void_type_data_ptr data_; - friend auto detail::data_access(const void_type&); + friend auto detail::type_access(const void_type&); }; } +namespace meta_hpp +{ + template < detail::type_family T, detail::type_family U > + [[nodiscard]] bool operator<(const T& l, const U& r) noexcept { + if ( !static_cast(r) ) { + return false; + } + + if ( !static_cast(l) ) { + return true; + } + + return l.get_id() < r.get_id(); + } + + template < detail::type_family T, detail::type_family U > + [[nodiscard]] bool operator==(const T& l, const U& r) noexcept { + if ( static_cast(l) != static_cast(r) ) { + return false; + } + + if ( !static_cast(l) ) { + return true; + } + + return l.get_id() == r.get_id(); + } + + template < detail::type_family T, detail::type_family U > + [[nodiscard]] bool operator!=(const T& l, const U& r) noexcept { + return !(l == r); + } +} + namespace meta_hpp::detail { struct type_data_base { @@ -479,9 +432,6 @@ namespace meta_hpp::detail template < array_kind Array > explicit array_type_data(type_list); - - template < array_kind Array > - [[nodiscard]] static array_type_data_ptr get_static(); }; struct class_type_data final : type_data_base { @@ -507,9 +457,6 @@ namespace meta_hpp::detail template < class_kind Class > explicit class_type_data(type_list); - - template < class_kind Class > - [[nodiscard]] static class_type_data_ptr get_static(); }; struct ctor_type_data final : type_data_base { @@ -519,9 +466,6 @@ namespace meta_hpp::detail template < class_kind Class, typename... Args > explicit ctor_type_data(type_list, type_list); - - template < class_kind Class, typename... Args > - [[nodiscard]] static ctor_type_data_ptr get_static(); }; struct dtor_type_data final : type_data_base { @@ -530,9 +474,6 @@ namespace meta_hpp::detail template < class_kind Class > explicit dtor_type_data(type_list); - - template < class_kind Class > - [[nodiscard]] static dtor_type_data_ptr get_static(); }; struct enum_type_data final : type_data_base { @@ -543,9 +484,6 @@ namespace meta_hpp::detail template < enum_kind Enum > explicit enum_type_data(type_list); - - template < enum_kind Enum > - [[nodiscard]] static enum_type_data_ptr get_static(); }; struct function_type_data final : type_data_base { @@ -555,9 +493,6 @@ namespace meta_hpp::detail template < function_kind Function > explicit function_type_data(type_list); - - template < function_kind Function > - [[nodiscard]] static function_type_data_ptr get_static(); }; struct member_type_data final : type_data_base { @@ -567,9 +502,6 @@ namespace meta_hpp::detail template < member_kind Member > explicit member_type_data(type_list); - - template < member_kind Member > - [[nodiscard]] static member_type_data_ptr get_static(); }; struct method_type_data final : type_data_base { @@ -580,17 +512,11 @@ namespace meta_hpp::detail template < method_kind Method > explicit method_type_data(type_list); - - template < method_kind Method > - [[nodiscard]] static method_type_data_ptr get_static(); }; struct nullptr_type_data final : type_data_base { template < nullptr_kind Nullptr > explicit nullptr_type_data(type_list); - - template < nullptr_kind Nullptr > - [[nodiscard]] static nullptr_type_data_ptr get_static(); }; struct number_type_data final : type_data_base { @@ -599,9 +525,6 @@ namespace meta_hpp::detail template < number_kind Number > explicit number_type_data(type_list); - - template < number_kind Number > - [[nodiscard]] static number_type_data_ptr get_static(); }; struct pointer_type_data final : type_data_base { @@ -610,9 +533,6 @@ namespace meta_hpp::detail template < pointer_kind Pointer > explicit pointer_type_data(type_list); - - template < pointer_kind Pointer > - [[nodiscard]] static pointer_type_data_ptr get_static(); }; struct reference_type_data final : type_data_base { @@ -621,209 +541,10 @@ namespace meta_hpp::detail template < reference_kind Reference > explicit reference_type_data(type_list); - - template < reference_kind Reference > - [[nodiscard]] static reference_type_data_ptr get_static(); }; struct void_type_data final : type_data_base { template < void_kind Void > explicit void_type_data(type_list); - - template < void_kind Void > - [[nodiscard]] static void_type_data_ptr get_static(); }; } - -namespace meta_hpp -{ - struct ctor_index final { - const ctor_type type; - - explicit ctor_index(ctor_type type) - : type{std::move(type)} {} - - [[nodiscard]] friend bool operator<(const ctor_index& l, const ctor_index& r) noexcept { - return l.type < r.type; - } - - [[nodiscard]] friend bool operator==(const ctor_index& l, const ctor_index& r) noexcept { - return l.type == r.type; - } - }; - - struct dtor_index final { - const dtor_type type; - - explicit dtor_index(dtor_type type) - : type{std::move(type)} {} - - [[nodiscard]] friend bool operator<(const dtor_index& l, const dtor_index& r) noexcept { - return l.type < r.type; - } - - [[nodiscard]] friend bool operator==(const dtor_index& l, const dtor_index& r) noexcept { - return l.type == r.type; - } - }; - - struct evalue_index final { - const enum_type type; - const std::string name; - - explicit evalue_index(enum_type type, std::string name) - : type{std::move(type)} - , name{std::move(name)} {} - - [[nodiscard]] friend bool operator<(const evalue_index& l, const evalue_index& r) noexcept { - return (l.type < r.type) || (l.type == r.type && l.name < r.name); - } - - [[nodiscard]] friend bool operator==(const evalue_index& l, const evalue_index& r) noexcept { - return l.type == r.type && l.name == r.name; - } - }; - - struct function_index final { - const function_type type; - const std::string name; - - explicit function_index(function_type type, std::string name) - : type{std::move(type)} - , name{std::move(name)} {} - - [[nodiscard]] friend bool operator<(const function_index& l, const function_index& r) noexcept { - return (l.type < r.type) || (l.type == r.type && l.name < r.name); - } - - [[nodiscard]] friend bool operator==(const function_index& l, const function_index& r) noexcept { - return l.type == r.type && l.name == r.name; - } - }; - - struct member_index final { - const member_type type; - const std::string name; - - explicit member_index(member_type type, std::string name) - : type{std::move(type)} - , name{std::move(name)} {} - - [[nodiscard]] friend bool operator<(const member_index& l, const member_index& r) noexcept { - return (l.type < r.type) || (l.type == r.type && l.name < r.name); - } - - [[nodiscard]] friend bool operator==(const member_index& l, const member_index& r) noexcept { - return l.type == r.type && l.name == r.name; - } - }; - - struct method_index final { - const method_type type; - const std::string name; - - explicit method_index(method_type type, std::string name) - : type{std::move(type)} - , name{std::move(name)} {} - - [[nodiscard]] friend bool operator<(const method_index& l, const method_index& r) noexcept { - return (l.type < r.type) || (l.type == r.type && l.name < r.name); - } - - [[nodiscard]] friend bool operator==(const method_index& l, const method_index& r) noexcept { - return l.type == r.type && l.name == r.name; - } - }; - - struct scope_index final { - const std::string name; - - explicit scope_index(std::string name) - : name{std::move(name)} {} - - [[nodiscard]] friend bool operator<(const scope_index& l, const scope_index& r) noexcept { - return l.name < r.name; - } - - [[nodiscard]] friend bool operator==(const scope_index& l, const scope_index& r) noexcept { - return l.name == r.name; - } - }; - - struct variable_index final { - const pointer_type type; - const std::string name; - - explicit variable_index(pointer_type type, std::string name) - : type{std::move(type)} - , name{std::move(name)} {} - - [[nodiscard]] friend bool operator<(const variable_index& l, const variable_index& r) noexcept { - return (l.type < r.type) || (l.type == r.type && l.name < r.name); - } - - [[nodiscard]] friend bool operator==(const variable_index& l, const variable_index& r) noexcept { - return l.type == r.type && l.name == r.name; - } - }; -} - -namespace meta_hpp -{ - template < typename T > - [[nodiscard]] auto resolve_type() { - using raw_type = std::remove_cv_t; - - using kind_type = detail::kind_type; - using kind_type_data = detail::kind_type_data; - - return kind_type{kind_type_data::template get_static()}; - } - - template < typename T > - // NOLINTNEXTLINE(readability-named-parameter) - [[nodiscard]] auto resolve_type(const T&) { - return resolve_type>(); - } -} - -namespace meta_hpp -{ - namespace detail - { - [[nodiscard]] inline void* pointer_upcast(void* ptr, const class_type& from, const class_type& to) { - if ( nullptr == ptr || !from || !to ) { - return nullptr; - } - - if ( from == to ) { - return ptr; - } - - for ( auto&& [base, base_info] : data_access(from)->bases_info ) { - if ( base == to ) { - return base_info.upcast(ptr); - } - - if ( base.is_derived_from(to) ) { - return pointer_upcast(base_info.upcast(ptr), base, to); - } - } - - return nullptr; - } - } - - template < detail::class_kind Base, detail::class_kind Derived > - [[nodiscard]] Base* pointer_upcast(Derived* ptr) { - const class_type& base = resolve_type(); - const class_type& derived = resolve_type(); - return static_cast(detail::pointer_upcast(ptr, derived, base)); - } - - template < detail::class_kind Base, detail::class_kind Derived > - [[nodiscard]] const Base* pointer_upcast(const Derived* ptr) { - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) - return pointer_upcast(const_cast(ptr)); - } -} diff --git a/headers/meta.hpp/meta_types/any_type.hpp b/headers/meta.hpp/meta_types/any_type.hpp index a545ee5..b94a4cf 100644 --- a/headers/meta.hpp/meta_types/any_type.hpp +++ b/headers/meta.hpp/meta_types/any_type.hpp @@ -11,9 +11,6 @@ namespace meta_hpp { - inline any_type::any_type(detail::type_data_base_ptr data) - : data_{std::move(data)} {} - inline bool any_type::is_valid() const noexcept { return !!data_; } @@ -31,43 +28,43 @@ namespace meta_hpp } inline any_type::any_type(const array_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const class_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const ctor_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const dtor_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const enum_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const function_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const member_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const method_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const nullptr_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const number_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const pointer_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const reference_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline any_type::any_type(const void_type& other) noexcept - : data_{detail::data_access(other)} {} + : data_{detail::type_access(other)} {} inline bool any_type::is_array() const noexcept { return data_ && data_->kind == type_kind::array_; diff --git a/headers/meta.hpp/meta_types/array_type.hpp b/headers/meta.hpp/meta_types/array_type.hpp index f9db315..0fa628c 100644 --- a/headers/meta.hpp/meta_types/array_type.hpp +++ b/headers/meta.hpp/meta_types/array_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/array_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/array_traits.hpp" namespace meta_hpp::detail { @@ -23,12 +24,6 @@ namespace meta_hpp::detail , flags{array_traits::make_flags()} , extent{array_traits::extent} , data_type{resolve_type::data_type>()} {} - - template < array_kind Array > - array_type_data_ptr array_type_data::get_static() { - static array_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/class_type.hpp b/headers/meta.hpp/meta_types/class_type.hpp index 09d2459..f9a0f12 100644 --- a/headers/meta.hpp/meta_types/class_type.hpp +++ b/headers/meta.hpp/meta_types/class_type.hpp @@ -15,7 +15,8 @@ #include "../meta_states/method.hpp" #include "../meta_states/variable.hpp" -#include "../meta_traits/class_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/class_traits.hpp" namespace meta_hpp::detail { @@ -28,13 +29,7 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::class_} , flags{class_traits::make_flags()} , size{class_traits::size} - , argument_types{class_traits::make_argument_types()} {} - - template < class_kind Class > - class_type_data_ptr class_type_data::get_static() { - static class_type_data_ptr data = std::make_shared(type_list{}); - return data; - } + , argument_types{resolve_types(typename class_traits::argument_types{})} {} } namespace meta_hpp @@ -130,7 +125,7 @@ namespace meta_hpp template < detail::class_kind Derived > bool class_type::is_base_of() const noexcept { - return is_base_of(resolve_type()); + return is_base_of(detail::resolve_type()); } inline bool class_type::is_base_of(const class_type& derived) const noexcept { @@ -153,7 +148,7 @@ namespace meta_hpp template < detail::class_kind Base > bool class_type::is_derived_from() const noexcept { - return is_derived_from(resolve_type()); + return is_derived_from(detail::resolve_type()); } inline bool class_type::is_derived_from(const class_type& base) const noexcept { @@ -176,7 +171,7 @@ namespace meta_hpp inline function class_type::get_function(std::string_view name) const noexcept { for ( auto&& [index, function] : data_->functions ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return function; } } @@ -192,7 +187,7 @@ namespace meta_hpp inline member class_type::get_member(std::string_view name) const noexcept { for ( auto&& [index, member] : data_->members ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return member; } } @@ -208,7 +203,7 @@ namespace meta_hpp inline method class_type::get_method(std::string_view name) const noexcept { for ( auto&& [index, method] : data_->methods ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return method; } } @@ -224,7 +219,7 @@ namespace meta_hpp inline variable class_type::get_variable(std::string_view name) const noexcept { for ( auto&& [index, variable] : data_->variables ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return variable; } } @@ -244,7 +239,7 @@ namespace meta_hpp template < typename... Args > ctor class_type::get_ctor_with() const noexcept { - return get_ctor_with({resolve_type()...}); + return get_ctor_with({detail::resolve_type()...}); } inline ctor class_type::get_ctor_with(const std::vector& args) const noexcept { @@ -283,12 +278,12 @@ namespace meta_hpp template < typename... Args > function class_type::get_function_with(std::string_view name) const noexcept { - return get_function_with(name, {resolve_type()...}); + return get_function_with(name, {detail::resolve_type()...}); } inline function class_type::get_function_with(std::string_view name, const std::vector& args) const noexcept { for ( auto&& [index, function] : data_->functions ) { - if ( index.name != name ) { + if ( index.get_name() != name ) { continue; } @@ -313,7 +308,7 @@ namespace meta_hpp inline function class_type::get_function_with(std::string_view name, std::initializer_list args) const noexcept { for ( auto&& [index, function] : data_->functions ) { - if ( index.name != name ) { + if ( index.get_name() != name ) { continue; } @@ -342,12 +337,12 @@ namespace meta_hpp template < typename... Args > method class_type::get_method_with(std::string_view name) const noexcept { - return get_method_with(name, {resolve_type()...}); + return get_method_with(name, {detail::resolve_type()...}); } inline method class_type::get_method_with(std::string_view name, const std::vector& args) const noexcept { for ( auto&& [index, method] : data_->methods ) { - if ( index.name != name ) { + if ( index.get_name() != name ) { continue; } @@ -372,7 +367,7 @@ namespace meta_hpp inline method class_type::get_method_with(std::string_view name, std::initializer_list args) const noexcept { for ( auto&& [index, method] : data_->methods ) { - if ( index.name != name ) { + if ( index.get_name() != name ) { continue; } diff --git a/headers/meta.hpp/meta_types/ctor_type.hpp b/headers/meta.hpp/meta_types/ctor_type.hpp index 893c2f3..b719b58 100644 --- a/headers/meta.hpp/meta_types/ctor_type.hpp +++ b/headers/meta.hpp/meta_types/ctor_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/ctor_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/ctor_traits.hpp" namespace meta_hpp::detail { @@ -22,13 +23,7 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::ctor_} , flags{ctor_traits::make_flags()} , class_type{resolve_type::class_type>()} - , argument_types{ctor_traits::make_argument_types()} {} - - template < class_kind Class, typename... Args > - ctor_type_data_ptr ctor_type_data::get_static() { - static ctor_type_data_ptr data = std::make_shared(type_list{}, type_list{}); - return data; - } + , argument_types{resolve_types(typename ctor_traits::argument_types{})} {} } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/dtor_type.hpp b/headers/meta.hpp/meta_types/dtor_type.hpp index 5e2c3da..f24413c 100644 --- a/headers/meta.hpp/meta_types/dtor_type.hpp +++ b/headers/meta.hpp/meta_types/dtor_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/dtor_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/dtor_traits.hpp" namespace meta_hpp::detail { @@ -22,12 +23,6 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::dtor_} , flags{dtor_traits::make_flags()} , class_type{resolve_type::class_type>()} {} - - template < class_kind Class > - dtor_type_data_ptr dtor_type_data::get_static() { - static dtor_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/enum_type.hpp b/headers/meta.hpp/meta_types/enum_type.hpp index 1b84bb1..db20134 100644 --- a/headers/meta.hpp/meta_types/enum_type.hpp +++ b/headers/meta.hpp/meta_types/enum_type.hpp @@ -11,7 +11,9 @@ #include "../meta_states/evalue.hpp" -#include "../meta_traits/enum_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/enum_traits.hpp" +#include "../meta_detail/value_utilities/arg.hpp" namespace meta_hpp::detail { @@ -24,12 +26,6 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::enum_} , flags{enum_traits::make_flags()} , underlying_type{resolve_type::underlying_type>()} {} - - template < enum_kind Enum > - enum_type_data_ptr enum_type_data::get_static() { - static enum_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp @@ -63,7 +59,7 @@ namespace meta_hpp inline evalue enum_type::get_evalue(std::string_view name) const noexcept { for ( auto&& [index, evalue] : data_->evalues ) { - if ( index.name == name ) { + if ( index.get_name() == name ) { return evalue; } } @@ -80,7 +76,7 @@ namespace meta_hpp for ( auto&& evalue : data_->evalues ) { if ( evalue.second.get_value() == value ) { - return evalue.second.get_index().name; + return evalue.second.get_index().get_name(); } } diff --git a/headers/meta.hpp/meta_types/function_type.hpp b/headers/meta.hpp/meta_types/function_type.hpp index 2580b9e..551c4a4 100644 --- a/headers/meta.hpp/meta_types/function_type.hpp +++ b/headers/meta.hpp/meta_types/function_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/function_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/function_traits.hpp" namespace meta_hpp::detail { @@ -22,13 +23,7 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::function_} , flags{function_traits::make_flags()} , return_type{resolve_type::return_type>()} - , argument_types{function_traits::make_argument_types()} {} - - template < function_kind Function > - function_type_data_ptr function_type_data::get_static() { - static function_type_data_ptr data = std::make_shared(type_list{}); - return data; - } + , argument_types{resolve_types(typename function_traits::argument_types{})} {} } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/member_type.hpp b/headers/meta.hpp/meta_types/member_type.hpp index 7935e22..60964fb 100644 --- a/headers/meta.hpp/meta_types/member_type.hpp +++ b/headers/meta.hpp/meta_types/member_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/member_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/member_traits.hpp" namespace meta_hpp::detail { @@ -23,12 +24,6 @@ namespace meta_hpp::detail , flags{member_traits::make_flags()} , owner_type{resolve_type::class_type>()} , value_type{resolve_type::value_type>()} {} - - template < member_kind Member > - member_type_data_ptr member_type_data::get_static() { - static member_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/method_type.hpp b/headers/meta.hpp/meta_types/method_type.hpp index 7fdaa1c..8e97769 100644 --- a/headers/meta.hpp/meta_types/method_type.hpp +++ b/headers/meta.hpp/meta_types/method_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/method_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/method_traits.hpp" namespace meta_hpp::detail { @@ -23,13 +24,7 @@ namespace meta_hpp::detail , flags{method_traits::make_flags()} , owner_type{resolve_type::class_type>()} , return_type{resolve_type::return_type>()} - , argument_types{method_traits::make_argument_types()} {} - - template < method_kind Method > - method_type_data_ptr method_type_data::get_static() { - static method_type_data_ptr data = std::make_shared(type_list{}); - return data; - } + , argument_types{resolve_types(typename method_traits::argument_types{})} {} } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/nullptr_type.hpp b/headers/meta.hpp/meta_types/nullptr_type.hpp index c566a9b..fe1b7bd 100644 --- a/headers/meta.hpp/meta_types/nullptr_type.hpp +++ b/headers/meta.hpp/meta_types/nullptr_type.hpp @@ -18,12 +18,6 @@ namespace meta_hpp::detail // NOLINTNEXTLINE(readability-named-parameter) nullptr_type_data::nullptr_type_data(type_list) : type_data_base{type_id{type_list>{}}, type_kind::nullptr_} {} - - template < nullptr_kind Nullptr > - nullptr_type_data_ptr nullptr_type_data::get_static() { - static nullptr_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/number_type.hpp b/headers/meta.hpp/meta_types/number_type.hpp index 066e78c..cbf65b2 100644 --- a/headers/meta.hpp/meta_types/number_type.hpp +++ b/headers/meta.hpp/meta_types/number_type.hpp @@ -9,7 +9,7 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/number_traits.hpp" +#include "../meta_detail/type_traits/number_traits.hpp" namespace meta_hpp::detail { @@ -22,12 +22,6 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::number_} , flags{number_traits::make_flags()} , size{number_traits::size} {} - - template < number_kind Number > - number_type_data_ptr number_type_data::get_static() { - static number_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/pointer_type.hpp b/headers/meta.hpp/meta_types/pointer_type.hpp index b9b763a..485f227 100644 --- a/headers/meta.hpp/meta_types/pointer_type.hpp +++ b/headers/meta.hpp/meta_types/pointer_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/pointer_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/pointer_traits.hpp" namespace meta_hpp::detail { @@ -22,12 +23,6 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::pointer_} , flags{pointer_traits::make_flags()} , data_type{resolve_type::data_type>()} {} - - template < pointer_kind Pointer > - pointer_type_data_ptr pointer_type_data::get_static() { - static pointer_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/reference_type.hpp b/headers/meta.hpp/meta_types/reference_type.hpp index e7c04b8..aed33d1 100644 --- a/headers/meta.hpp/meta_types/reference_type.hpp +++ b/headers/meta.hpp/meta_types/reference_type.hpp @@ -9,7 +9,8 @@ #include "../meta_base.hpp" #include "../meta_types.hpp" -#include "../meta_traits/reference_traits.hpp" +#include "../meta_detail/type_registry.hpp" +#include "../meta_detail/type_traits/reference_traits.hpp" namespace meta_hpp::detail { @@ -22,12 +23,6 @@ namespace meta_hpp::detail : type_data_base{type_id{type_list>{}}, type_kind::reference_} , flags{reference_traits::make_flags()} , data_type{resolve_type::data_type>()} {} - - template < reference_kind Reference > - reference_type_data_ptr reference_type_data::get_static() { - static reference_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_types/void_type.hpp b/headers/meta.hpp/meta_types/void_type.hpp index a314920..19dc923 100644 --- a/headers/meta.hpp/meta_types/void_type.hpp +++ b/headers/meta.hpp/meta_types/void_type.hpp @@ -18,12 +18,6 @@ namespace meta_hpp::detail // NOLINTNEXTLINE(readability-named-parameter) void_type_data::void_type_data(type_list) : type_data_base{type_id{type_list>{}}, type_kind::void_} {} - - template < void_kind Void > - void_type_data_ptr void_type_data::get_static() { - static void_type_data_ptr data = std::make_shared(type_list{}); - return data; - } } namespace meta_hpp diff --git a/headers/meta.hpp/meta_utilities.hpp b/headers/meta.hpp/meta_utilities.hpp deleted file mode 100644 index ee58de7..0000000 --- a/headers/meta.hpp/meta_utilities.hpp +++ /dev/null @@ -1,351 +0,0 @@ -/******************************************************************************* - * This file is part of the "https://github.com/blackmatov/meta.hpp" - * For conditions of distribution and use, see copyright notice in LICENSE.md - * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) - ******************************************************************************/ - -#pragma once - -#include "meta_base.hpp" -#include "meta_types.hpp" - -namespace meta_hpp::detail -{ - template < typename From > - struct cvref_traits { - static constexpr bool is_lvalue = std::is_lvalue_reference_v; - static constexpr bool is_rvalue = std::is_rvalue_reference_v; - static constexpr bool is_const = std::is_const_v>; - static constexpr bool is_volatile = std::is_volatile_v>; - - template < bool yesno, template < typename > typename Q, typename V > - using apply_t_if = std::conditional_t, V>; - - template < typename To > - using copy_to = - apply_t_if>>>>; - }; - - template < typename From, typename To > - struct copy_cvref { - using type = typename cvref_traits::template copy_to; - }; - - template < typename From, typename To > - using copy_cvref_t = typename copy_cvref::type; -} - -namespace meta_hpp::detail -{ - template < typename T > - concept value_kind = - std::is_same_v; - - template < typename T > - concept decay_value_kind = - value_kind>; - - template < typename T > - concept uvalue_kind = - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v || - std::is_same_v; - - template < typename T > - concept decay_uvalue_kind = - uvalue_kind>; - - template < typename T > - concept decay_non_uvalue_kind = - (!decay_uvalue_kind); - - template < typename T > - concept arg_lvalue_ref_kind = - (decay_non_uvalue_kind) && - (std::is_lvalue_reference_v); - - template < typename T > - concept arg_rvalue_ref_kind = - (decay_non_uvalue_kind) && - (!std::is_reference_v || std::is_rvalue_reference_v); - - template < typename T > - concept inst_class_ref_kind = - (std::is_class_v) || - (std::is_reference_v && std::is_class_v>); - - template < typename T > - concept inst_class_lvalue_ref_kind = - (decay_non_uvalue_kind) && - (std::is_lvalue_reference_v && std::is_class_v>); - - template < typename T > - concept inst_class_rvalue_ref_kind = - (decay_non_uvalue_kind) && - (std::is_class_v || (std::is_rvalue_reference_v && std::is_class_v>)); -} - -namespace meta_hpp::detail -{ - class noncopyable { - protected: - noncopyable() = default; - ~noncopyable() = default; - public: - noncopyable(noncopyable&&) = delete; - noncopyable(const noncopyable&) = delete; - noncopyable& operator=(noncopyable&&) = delete; - noncopyable& operator=(const noncopyable&) = delete; - }; -} - -namespace meta_hpp::detail -{ - template < typename... Ts > - struct overloaded : Ts... { - using Ts::operator()...; - }; - - template < typename... Ts > - overloaded(Ts...) -> overloaded; -} - -namespace meta_hpp -{ - class value final { - public: - value() = default; - ~value() noexcept; - - value(value&& other) noexcept; - value(const value& other); - - value& operator=(value&& other) noexcept; - value& operator=(const value& other); - - template < detail::decay_non_uvalue_kind T > - requires detail::stdex::copy_constructible> - explicit value(T&& val); - - template < detail::decay_non_uvalue_kind T > - requires detail::stdex::copy_constructible> - value& operator=(T&& val); - - [[nodiscard]] bool is_valid() const noexcept; - [[nodiscard]] explicit operator bool() const noexcept; - - void reset() noexcept; - void swap(value& other) noexcept; - - [[nodiscard]] any_type get_type() const noexcept; - - [[nodiscard]] void* data() noexcept; - [[nodiscard]] const void* data() const noexcept; - [[nodiscard]] const void* cdata() const noexcept; - - [[nodiscard]] value operator*() const; - [[nodiscard]] value operator[](std::size_t index) const; - - template < typename T > - [[nodiscard]] std::decay_t& cast() &; - - template < typename T > - [[nodiscard]] std::decay_t&& cast() &&; - - template < typename T > - [[nodiscard]] const std::decay_t& cast() const &; - - template < typename T > - [[nodiscard]] const std::decay_t&& cast() const &&; - - template < typename T > - [[nodiscard]] std::decay_t* try_cast() noexcept; - - template < typename T > - [[nodiscard]] const std::decay_t* try_cast() const noexcept; - - friend bool operator<(const value& l, const value& r); - friend bool operator==(const value& l, const value& r); - friend std::istream& operator>>(std::istream& is, value& v); - friend std::ostream& operator<<(std::ostream& os, const value& v); - private: - struct vtable_t; - vtable_t* vtable_{}; - private: - using buffer_t = std::aligned_storage_t; - using storage_u = std::variant; - storage_u storage_{}; - }; - - inline void swap(value& l, value& r) noexcept { - l.swap(r); - } -} - -namespace meta_hpp::detail -{ - class arg_base { - public: - enum class ref_types { - lvalue, - const_lvalue, - rvalue, - const_rvalue, - }; - public: - arg_base() = delete; - - arg_base(arg_base&&) = default; - arg_base(const arg_base&) = default; - - arg_base& operator=(arg_base&&) = delete; - arg_base& operator=(const arg_base&) = delete; - - virtual ~arg_base() = default; - - template < decay_value_kind T > - explicit arg_base(T&& v); - - template < decay_non_uvalue_kind T > - explicit arg_base(T&& v); - - template < arg_lvalue_ref_kind T > - explicit arg_base(type_list); - - template < arg_rvalue_ref_kind T > - explicit arg_base(type_list); - - explicit arg_base(value& v); - explicit arg_base(const value& v); - - explicit arg_base(value&& v); - explicit arg_base(const value&& v); - - [[nodiscard]] bool is_const() const noexcept; - [[nodiscard]] bool is_lvalue() const noexcept; - [[nodiscard]] bool is_rvalue() const noexcept; - - [[nodiscard]] ref_types get_ref_type() const noexcept; - [[nodiscard]] const any_type& get_raw_type() const noexcept; - - template < typename To > - [[nodiscard]] bool can_cast_to() const noexcept; - private: - ref_types ref_type_{}; - any_type raw_type_{}; - }; -} - -namespace meta_hpp::detail -{ - class arg final : public arg_base { - public: - arg() = delete; - - arg(arg&&) = default; - arg(const arg&) = default; - - arg& operator=(arg&&) = delete; - arg& operator=(const arg&) = delete; - - ~arg() override = default; - - template < decay_value_kind T > - explicit arg(T&& v); - - template < decay_non_uvalue_kind T > - explicit arg(T&& v); - - template < typename To > - [[nodiscard]] To cast() const; - private: - void* data_{}; - }; -} - -namespace meta_hpp::detail -{ - class inst_base { - public: - enum class ref_types { - lvalue, - const_lvalue, - rvalue, - const_rvalue, - }; - public: - inst_base() = delete; - - inst_base(inst_base&&) = default; - inst_base(const inst_base&) = default; - - inst_base& operator=(inst_base&&) = delete; - inst_base& operator=(const inst_base&) = delete; - - virtual ~inst_base() = default; - - template < decay_value_kind T > - explicit inst_base(T&& v); - - template < decay_non_uvalue_kind T > - explicit inst_base(T&& v); - - template < inst_class_lvalue_ref_kind T > - explicit inst_base(type_list); - - template < inst_class_rvalue_ref_kind T > - explicit inst_base(type_list); - - explicit inst_base(value& v); - explicit inst_base(const value& v); - - explicit inst_base(value&& v); - explicit inst_base(const value&& v); - - [[nodiscard]] bool is_const() const noexcept; - [[nodiscard]] bool is_lvalue() const noexcept; - [[nodiscard]] bool is_rvalue() const noexcept; - - [[nodiscard]] ref_types get_ref_type() const noexcept; - [[nodiscard]] const any_type& get_raw_type() const noexcept; - - template < inst_class_ref_kind Q > - [[nodiscard]] bool can_cast_to() const noexcept; - private: - ref_types ref_type_{}; - any_type raw_type_{}; - }; -} - -namespace meta_hpp::detail -{ - class inst final : public inst_base { - public: - inst() = delete; - - inst(inst&&) = default; - inst(const inst&) = default; - - inst& operator=(inst&&) = delete; - inst& operator=(const inst&) = delete; - - ~inst() override = default; - - template < decay_value_kind T > - explicit inst(T&& v); - - template < decay_non_uvalue_kind T > - explicit inst(T&& v); - - template < inst_class_ref_kind Q > - [[nodiscard]] decltype(auto) cast() const; - private: - void* data_{}; - }; -} diff --git a/headers/meta.hpp/meta_utilities/inst.hpp b/headers/meta.hpp/meta_utilities/inst.hpp deleted file mode 100644 index b49c9f5..0000000 --- a/headers/meta.hpp/meta_utilities/inst.hpp +++ /dev/null @@ -1,209 +0,0 @@ -/******************************************************************************* - * This file is part of the "https://github.com/blackmatov/meta.hpp" - * For conditions of distribution and use, see copyright notice in LICENSE.md - * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) - ******************************************************************************/ - -#pragma once - -#include "../meta_base.hpp" -#include "../meta_utilities.hpp" - -namespace meta_hpp::detail -{ - namespace impl - { - template < inst_class_ref_kind Q, bool is_const, bool is_lvalue, bool is_rvalue > - struct inst_traits_impl; - - template < inst_class_ref_kind Q > - struct inst_traits_impl { - using class_type = std::remove_cvref_t; - using method_type = void(class_type::*)(); - }; - - template < inst_class_ref_kind Q > - struct inst_traits_impl { - using class_type = std::remove_cvref_t; - using method_type = void(class_type::*)() &; - }; - - template < inst_class_ref_kind Q > - struct inst_traits_impl { - using class_type = std::remove_cvref_t; - using method_type = void(class_type::*)() &&; - }; - - template < inst_class_ref_kind Q > - struct inst_traits_impl { - using class_type = std::remove_cvref_t; - using method_type = void(class_type::*)() const; - }; - - template < inst_class_ref_kind Q > - struct inst_traits_impl { - using class_type = std::remove_cvref_t; - using method_type = void(class_type::*)() const &; - }; - - template < inst_class_ref_kind Q > - struct inst_traits_impl { - using class_type = std::remove_cvref_t; - using method_type = void(class_type::*)() const &&; - }; - } - - template < inst_class_ref_kind Q > - struct inst_traits final : impl::inst_traits_impl::is_const, - cvref_traits::is_lvalue, - cvref_traits::is_rvalue> {}; -} - -namespace meta_hpp::detail -{ - template < decay_value_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - inst_base::inst_base(T&&) - : inst_base{type_list{}} {} - - template < decay_non_uvalue_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - inst_base::inst_base(T&&) - : inst_base{type_list{}} {} - - template < inst_class_lvalue_ref_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - inst_base::inst_base(type_list) - : ref_type_{std::is_const_v> - ? ref_types::const_lvalue - : ref_types::lvalue} - , raw_type_{resolve_type>()} {} - - template < inst_class_rvalue_ref_kind T > - // NOLINTNEXTLINE(readability-named-parameter) - inst_base::inst_base(type_list) - : ref_type_{std::is_const_v> - ? ref_types::const_rvalue - : ref_types::rvalue} - , raw_type_{resolve_type>()} {} - - inline inst_base::inst_base(value& v) - : ref_type_{ref_types::lvalue} - , raw_type_{v.get_type()} {} - - inline inst_base::inst_base(const value& v) - : ref_type_{ref_types::const_lvalue} - , raw_type_{v.get_type()} {} - - inline inst_base::inst_base(value&& v) - : ref_type_{ref_types::rvalue} - , raw_type_{v.get_type()} {} - - inline inst_base::inst_base(const value&& v) - : ref_type_{ref_types::const_rvalue} - , raw_type_{v.get_type()} {} - - inline bool inst_base::is_const() const noexcept { - return ref_type_ == ref_types::const_lvalue - || ref_type_ == ref_types::const_rvalue; - } - - inline bool inst_base::is_lvalue() const noexcept { - return ref_type_ == ref_types::lvalue - || ref_type_ == ref_types::const_lvalue; - } - - inline bool inst_base::is_rvalue() const noexcept { - return ref_type_ == ref_types::rvalue - || ref_type_ == ref_types::const_rvalue; - } - - inline inst_base::ref_types inst_base::get_ref_type() const noexcept { - return ref_type_; - } - - inline const any_type& inst_base::get_raw_type() const noexcept { - return raw_type_; - } - - template < inst_class_ref_kind Q > - bool inst_base::can_cast_to() const noexcept { - using inst_class = typename inst_traits::class_type; - using inst_method = typename inst_traits::method_type; - - const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); - - const auto is_a = [](const any_type& base, const any_type& derived){ - return (base == derived) - || (base.is_class() && derived.is_class() && base.as_class().is_base_of(derived.as_class())); - }; - - const auto is_invocable = [this](){ - switch ( get_ref_type() ) { - case ref_types::lvalue: - return std::is_invocable_v; - case ref_types::const_lvalue: - return std::is_invocable_v; - case ref_types::rvalue: - return std::is_invocable_v; - case ref_types::const_rvalue: - return std::is_invocable_v; - default: - return false; - } - }; - - return is_a(to_type, from_type) && is_invocable(); - } -} - -namespace meta_hpp::detail -{ - template < decay_value_kind T > - inst::inst(T&& v) - : inst_base{std::forward(v)} - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) - , data_{const_cast(v.data())} {} - - template < decay_non_uvalue_kind T > - inst::inst(T&& v) - : inst_base{std::forward(v)} - // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast) - , data_{const_cast*>(std::addressof(v))} {} - - template < inst_class_ref_kind Q > - decltype(auto) inst::cast() const { - if ( !can_cast_to() ) { - throw std::logic_error("bad instance cast"); - } - - using inst_class_cv = std::remove_reference_t; - using inst_class = std::remove_cv_t; - - const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); - - if ( from_type.is_class() && to_type.is_class() ) { - const class_type& from_class = from_type.as_class(); - const class_type& to_class = to_type.as_class(); - - void* to_ptr = detail::pointer_upcast(data_, from_class, to_class); - - if constexpr ( !std::is_reference_v ) { - return *static_cast(to_ptr); - } - - if constexpr ( std::is_lvalue_reference_v ) { - return *static_cast(to_ptr); - } - - if constexpr ( std::is_rvalue_reference_v ) { - return std::move(*static_cast(to_ptr)); - } - } - - throw std::logic_error("bad instance cast"); - } -} diff --git a/headers/meta.hpp/meta_value.hpp b/headers/meta.hpp/meta_value.hpp new file mode 100644 index 0000000..91d5c4b --- /dev/null +++ b/headers/meta.hpp/meta_value.hpp @@ -0,0 +1,94 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#pragma once + +#include "meta_base.hpp" +#include "meta_types.hpp" + +namespace meta_hpp::detail +{ + template < typename T > + concept value_kind = stdex::same_as; + + template < typename T > + concept decay_value_kind = value_kind>; + + template < typename T > + concept decay_non_value_kind = !decay_value_kind; +} + +namespace meta_hpp +{ + class value final { + public: + value() = default; + ~value() noexcept; + + value(value&& other) noexcept; + value(const value& other); + + value& operator=(value&& other) noexcept; + value& operator=(const value& other); + + template < detail::decay_non_value_kind T > + requires stdex::copy_constructible> + explicit value(T&& val); + + template < detail::decay_non_value_kind T > + requires stdex::copy_constructible> + value& operator=(T&& val); + + [[nodiscard]] bool is_valid() const noexcept; + [[nodiscard]] explicit operator bool() const noexcept; + + void reset() noexcept; + void swap(value& other) noexcept; + + [[nodiscard]] const any_type& get_type() const noexcept; + + [[nodiscard]] void* data() noexcept; + [[nodiscard]] const void* data() const noexcept; + [[nodiscard]] const void* cdata() const noexcept; + + [[nodiscard]] value operator*() const; + [[nodiscard]] value operator[](std::size_t index) const; + + template < typename T > + [[nodiscard]] std::decay_t& cast() &; + + template < typename T > + [[nodiscard]] std::decay_t&& cast() &&; + + template < typename T > + [[nodiscard]] const std::decay_t& cast() const &; + + template < typename T > + [[nodiscard]] const std::decay_t&& cast() const &&; + + template < typename T > + [[nodiscard]] std::decay_t* try_cast() noexcept; + + template < typename T > + [[nodiscard]] const std::decay_t* try_cast() const noexcept; + + friend bool operator<(const value& l, const value& r); + friend bool operator==(const value& l, const value& r); + friend std::istream& operator>>(std::istream& is, value& v); + friend std::ostream& operator<<(std::ostream& os, const value& v); + private: + struct vtable_t; + vtable_t* vtable_{}; + private: + using buffer_t = std::aligned_storage_t; + using storage_u = std::variant; + storage_u storage_{}; + }; + + inline void swap(value& l, value& r) noexcept { + l.swap(r); + } +} diff --git a/headers/meta.hpp/meta_utilities/value.hpp b/headers/meta.hpp/meta_value/value.hpp similarity index 81% rename from headers/meta.hpp/meta_utilities/value.hpp rename to headers/meta.hpp/meta_value/value.hpp index e673d72..d301396 100644 --- a/headers/meta.hpp/meta_utilities/value.hpp +++ b/headers/meta.hpp/meta_value/value.hpp @@ -7,14 +7,16 @@ #pragma once #include "../meta_base.hpp" -#include "../meta_utilities.hpp" +#include "../meta_value.hpp" -#include "value_traits/deref_traits.hpp" -#include "value_traits/equals_traits.hpp" -#include "value_traits/index_traits.hpp" -#include "value_traits/istream_traits.hpp" -#include "value_traits/less_traits.hpp" -#include "value_traits/ostream_traits.hpp" +#include "../meta_detail/value_traits/deref_traits.hpp" +#include "../meta_detail/value_traits/equals_traits.hpp" +#include "../meta_detail/value_traits/index_traits.hpp" +#include "../meta_detail/value_traits/istream_traits.hpp" +#include "../meta_detail/value_traits/less_traits.hpp" +#include "../meta_detail/value_traits/ostream_traits.hpp" + +#include "../meta_detail/type_registry.hpp" namespace meta_hpp { @@ -115,7 +117,7 @@ namespace meta_hpp template < typename Tp > static vtable_t* get() { static vtable_t table{ - .type = resolve_type(), + .type = detail::resolve_type(), .data = [](storage_u& from) noexcept -> void* { return storage_cast(from); @@ -175,48 +177,48 @@ namespace meta_hpp }, .deref = +[]([[maybe_unused]] const value& v) -> value { - if constexpr ( detail::has_value_deref_traits ) { - return detail::value_deref_traits{}(v.cast()); + if constexpr ( detail::has_deref_traits ) { + return detail::deref_traits{}(v.cast()); } else { throw std::logic_error("value type doesn't have value deref traits"); } }, - .index = +[]([[maybe_unused]] const value& v, [[maybe_unused]] std::size_t index) -> value { - if constexpr ( detail::has_value_index_traits ) { - return detail::value_index_traits{}(v.cast(), index); + .index = +[]([[maybe_unused]] const value& v, [[maybe_unused]] std::size_t i) -> value { + if constexpr ( detail::has_index_traits ) { + return detail::index_traits{}(v.cast(), i); } else { throw std::logic_error("value type doesn't have value index traits"); } }, .less = +[]([[maybe_unused]] const value& l, [[maybe_unused]] const value& r) -> bool { - if constexpr ( detail::has_value_less_traits ) { - return detail::value_less_traits{}(l.cast(), r.cast()); + if constexpr ( detail::has_less_traits ) { + return detail::less_traits{}(l.cast(), r.cast()); } else { throw std::logic_error("value type doesn't have value less traits"); } }, .equals = +[]([[maybe_unused]] const value& l, [[maybe_unused]] const value& r) -> bool { - if constexpr ( detail::has_value_equals_traits ) { - return detail::value_equals_traits{}(l.cast(), r.cast()); + if constexpr ( detail::has_equals_traits ) { + return detail::equals_traits{}(l.cast(), r.cast()); } else { throw std::logic_error("value type doesn't have value equals traits"); } }, .istream = +[]([[maybe_unused]] std::istream& is, [[maybe_unused]] value& v) -> std::istream& { - if constexpr ( detail::has_value_istream_traits ) { - return detail::value_istream_traits{}(is, v.cast()); + if constexpr ( detail::has_istream_traits ) { + return detail::istream_traits{}(is, v.cast()); } else { throw std::logic_error("value type doesn't have value istream traits"); } }, .ostream = +[]([[maybe_unused]] std::ostream& os, [[maybe_unused]] const value& v) -> std::ostream& { - if constexpr ( detail::has_value_ostream_traits ) { - return detail::value_ostream_traits{}(os, v.cast()); + if constexpr ( detail::has_ostream_traits ) { + return detail::ostream_traits{}(os, v.cast()); } else { throw std::logic_error("value type doesn't have value ostream traits"); } @@ -260,14 +262,14 @@ namespace meta_hpp return *this; } - template < detail::decay_non_uvalue_kind T > - requires detail::stdex::copy_constructible> + template < detail::decay_non_value_kind T > + requires stdex::copy_constructible> value::value(T&& val) { vtable_t::construct(*this, std::forward(val)); } - template < detail::decay_non_uvalue_kind T > - requires detail::stdex::copy_constructible> + template < detail::decay_non_value_kind T > + requires stdex::copy_constructible> value& value::operator=(T&& val) { value{std::forward(val)}.swap(*this); return *this; @@ -292,8 +294,9 @@ namespace meta_hpp vtable_t::swap(*this, other); } - inline any_type value::get_type() const noexcept { - return vtable_ != nullptr ? vtable_->type : resolve_type(); + inline const any_type& value::get_type() const noexcept { + static any_type void_type = detail::resolve_type(); + return vtable_ != nullptr ? vtable_->type : void_type; } inline void* value::data() noexcept { @@ -355,7 +358,7 @@ namespace meta_hpp template < typename T > std::decay_t* value::try_cast() noexcept { using Tp = std::decay_t; - return get_type() == resolve_type() + return get_type() == detail::resolve_type() ? vtable_t::storage_cast(storage_) : nullptr; } @@ -363,7 +366,7 @@ namespace meta_hpp template < typename T > const std::decay_t* value::try_cast() const noexcept { using Tp = std::decay_t; - return get_type() == resolve_type() + return get_type() == detail::resolve_type() ? vtable_t::storage_cast(storage_) : nullptr; } @@ -377,9 +380,10 @@ namespace meta_hpp return true; } - const any_type& r_type = resolve_type(); - return (l.get_type() < r_type) - || (l.get_type() == r_type && std::less<>{}(l.cast(), r)); + const any_type& l_type = l.get_type(); + const any_type& r_type = detail::resolve_type(); + + return (l_type < r_type) || (l_type == r_type && l.cast() < r); } template < typename T > @@ -388,9 +392,10 @@ namespace meta_hpp return false; } - const any_type& l_type = resolve_type(); - return (l_type < r.get_type()) - || (l_type == r.get_type() && std::less<>{}(l, r.cast())); + const any_type& l_type = detail::resolve_type(); + const any_type& r_type = r.get_type(); + + return (l_type < r_type) || (l_type == r_type && l < r.cast()); } [[nodiscard]] inline bool operator<(const value& l, const value& r) { @@ -402,8 +407,10 @@ namespace meta_hpp return true; } - return (l.get_type() < r.get_type()) - || (l.get_type() == r.get_type() && l.vtable_->less(l, r)); + const any_type& l_type = l.get_type(); + const any_type& r_type = r.get_type(); + + return (l_type < r_type) || (l_type == r_type && l.vtable_->less(l, r)); } } @@ -415,8 +422,10 @@ namespace meta_hpp return false; } - return l.get_type() == resolve_type() - && std::equal_to<>{}(l.cast(), r); + const any_type& l_type = l.get_type(); + const any_type& r_type = detail::resolve_type(); + + return l_type == r_type && l.cast() == r; } template < typename T > @@ -425,8 +434,10 @@ namespace meta_hpp return false; } - return resolve_type() == r.get_type() - && std::equal_to<>{}(l, r.cast()); + const any_type& l_type = detail::resolve_type(); + const any_type& r_type = r.get_type(); + + return l_type == r_type && l == r.cast(); } [[nodiscard]] inline bool operator==(const value& l, const value& r) { @@ -438,8 +449,10 @@ namespace meta_hpp return true; } - return l.get_type() == r.get_type() - && l.vtable_->equals(l, r); + const any_type& l_type = l.get_type(); + const any_type& r_type = r.get_type(); + + return l_type == r_type && l.vtable_->equals(l, r); } } diff --git a/headers/meta.hpp/meta_utilities/vinvoke.hpp b/headers/meta.hpp/meta_value/vinvoke.hpp similarity index 97% rename from headers/meta.hpp/meta_utilities/vinvoke.hpp rename to headers/meta.hpp/meta_value/vinvoke.hpp index 5c786e8..6b96b04 100644 --- a/headers/meta.hpp/meta_utilities/vinvoke.hpp +++ b/headers/meta.hpp/meta_value/vinvoke.hpp @@ -8,7 +8,10 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" -#include "../meta_utilities.hpp" +#include "../meta_value.hpp" + +#include "../meta_detail/value_utilities/arg.hpp" +#include "../meta_detail/value_utilities/inst.hpp" namespace meta_hpp { diff --git a/manuals/meta_examples/classes_example.cpp b/manuals/meta_examples/classes_example.cpp index ad71d88..0306c2a 100644 --- a/manuals/meta_examples/classes_example.cpp +++ b/manuals/meta_examples/classes_example.cpp @@ -57,7 +57,7 @@ TEST_CASE("meta/meta_examples/classes/type") { // prints all class methods fmt::print("* rectangle:\n"); for ( auto&& [index, method] : rectangle_type.get_methods() ) { - fmt::print(" + {}/{}\n", index.name, index.type.get_arity()); + fmt::print(" + {}/{}\n", index.get_name(), index.get_type().get_arity()); } } diff --git a/manuals/meta_examples/enums_examples.cpp b/manuals/meta_examples/enums_examples.cpp index 123444e..9ebfe00 100644 --- a/manuals/meta_examples/enums_examples.cpp +++ b/manuals/meta_examples/enums_examples.cpp @@ -36,7 +36,7 @@ TEST_CASE("meta/meta_examples/enums/type") { // prints all enumerators fmt::print("* align:\n"); for ( auto&& [index, evalue] : align_type.get_evalues() ) { - fmt::print(" - {}:{}\n", index.name, evalue.get_underlying_value()); + fmt::print(" - {}:{}\n", index.get_name(), evalue.get_underlying_value()); } } diff --git a/manuals/meta_examples/functions_example.cpp b/manuals/meta_examples/functions_example.cpp index a5f5873..294a625 100644 --- a/manuals/meta_examples/functions_example.cpp +++ b/manuals/meta_examples/functions_example.cpp @@ -73,6 +73,6 @@ TEST_CASE("meta/meta_examples/functions/usage") { // prints all functions in the scope fmt::print("* {}:\n", math_scope.get_name()); for ( auto&& [index, function] : math_scope.get_functions() ) { - fmt::print(" + {}/{}\n", index.name, function.get_type().get_arity()); + fmt::print(" + {}/{}\n", index.get_name(), function.get_type().get_arity()); } } diff --git a/manuals/meta_examples/variables_example.cpp b/manuals/meta_examples/variables_example.cpp index 87578cf..c3de612 100644 --- a/manuals/meta_examples/variables_example.cpp +++ b/manuals/meta_examples/variables_example.cpp @@ -42,6 +42,6 @@ TEST_CASE("meta/meta_examples/variables/usage") { // prints all variables in the scope fmt::print("* {}:\n", constants_scope.get_name()); for ( auto&& [index, variable] : constants_scope.get_variables() ) { - fmt::print(" - {}:{}\n", index.name, variable.get()); + fmt::print(" - {}:{}\n", index.get_name(), variable.get()); } } diff --git a/untests/meta_features/diamond_tests.cpp b/untests/meta_features/diamond_tests.cpp index 8cc2da8..6a7db53 100644 --- a/untests/meta_features/diamond_tests.cpp +++ b/untests/meta_features/diamond_tests.cpp @@ -116,45 +116,46 @@ TEST_CASE("meta/meta_features/diamond") { } SUBCASE("pointer_upcast") { + using meta::detail::pointer_upcast; { A a; - CHECK(meta::pointer_upcast(&a) == &a); - CHECK_FALSE(meta::pointer_upcast(&a)); - CHECK_FALSE(meta::pointer_upcast(&a)); - CHECK_FALSE(meta::pointer_upcast(&a)); - CHECK_FALSE(meta::pointer_upcast(&a)); + CHECK(pointer_upcast(&a) == &a); + CHECK_FALSE(pointer_upcast(&a)); + CHECK_FALSE(pointer_upcast(&a)); + CHECK_FALSE(pointer_upcast(&a)); + CHECK_FALSE(pointer_upcast(&a)); } { - B b; - CHECK(meta::pointer_upcast(&b) == &b); - CHECK(meta::pointer_upcast(&b) == &b); - CHECK_FALSE(meta::pointer_upcast(&b)); - CHECK_FALSE(meta::pointer_upcast(&b)); - CHECK_FALSE(meta::pointer_upcast(&b)); + const B b; + CHECK(pointer_upcast(&b) == &b); + CHECK(pointer_upcast(&b) == &b); + CHECK_FALSE(pointer_upcast(&b)); + CHECK_FALSE(pointer_upcast(&b)); + CHECK_FALSE(pointer_upcast(&b)); } { C c; - CHECK(meta::pointer_upcast(&c) == &c); - CHECK_FALSE(meta::pointer_upcast(&c)); - CHECK(meta::pointer_upcast(&c) == &c); - CHECK_FALSE(meta::pointer_upcast(&c)); - CHECK_FALSE(meta::pointer_upcast(&c)); + CHECK(pointer_upcast(&c) == &c); + CHECK_FALSE(pointer_upcast(&c)); + CHECK(pointer_upcast(&c) == &c); + CHECK_FALSE(pointer_upcast(&c)); + CHECK_FALSE(pointer_upcast(&c)); } { - D d; - CHECK(meta::pointer_upcast(&d) == &d); - CHECK(meta::pointer_upcast(&d) == &d); - CHECK(meta::pointer_upcast(&d) == &d); - CHECK(meta::pointer_upcast(&d) == &d); - CHECK_FALSE(meta::pointer_upcast(&d)); + const D d; + CHECK(pointer_upcast(&d) == &d); + CHECK(pointer_upcast(&d) == &d); + CHECK(pointer_upcast(&d) == &d); + CHECK(pointer_upcast(&d) == &d); + CHECK_FALSE(pointer_upcast(&d)); } { E e; - CHECK_FALSE(meta::pointer_upcast(&e)); - CHECK_FALSE(meta::pointer_upcast(&e)); - CHECK_FALSE(meta::pointer_upcast(&e)); - CHECK_FALSE(meta::pointer_upcast(&e)); - CHECK(meta::pointer_upcast(&e) == &e); + CHECK_FALSE(pointer_upcast(&e)); + CHECK_FALSE(pointer_upcast(&e)); + CHECK_FALSE(pointer_upcast(&e)); + CHECK_FALSE(pointer_upcast(&e)); + CHECK(pointer_upcast(&e) == &e); } } @@ -315,4 +316,23 @@ TEST_CASE("meta/meta_features/diamond") { CHECK(&e_inst.cast() == e_val.try_cast()); } } + + SUBCASE("resolve_polymorphic_type") { + const D d; + + const A& ad = d; + const B& bd = d; + const C& cd = d; + const D& dd = d; + + CHECK(meta::resolve_type(ad) == meta::resolve_type()); + CHECK(meta::resolve_type(bd) == meta::resolve_type()); + CHECK(meta::resolve_type(cd) == meta::resolve_type()); + CHECK(meta::resolve_type(dd) == meta::resolve_type()); + + CHECK(meta::resolve_polymorphic_type(ad) == meta::resolve_type()); + CHECK(meta::resolve_polymorphic_type(bd) == meta::resolve_type()); + CHECK(meta::resolve_polymorphic_type(cd) == meta::resolve_type()); + CHECK(meta::resolve_polymorphic_type(dd) == meta::resolve_type()); + } } diff --git a/untests/meta_states/evalue_tests.cpp b/untests/meta_states/evalue_tests.cpp index ea3e1c6..247bd1d 100644 --- a/untests/meta_states/evalue_tests.cpp +++ b/untests/meta_states/evalue_tests.cpp @@ -47,8 +47,8 @@ TEST_CASE("meta/meta_states/evalue") { const meta::evalue evalue = color_type.get_evalue("green"); REQUIRE(evalue); - CHECK(evalue.get_index().type == evalue.get_type()); - CHECK(evalue.get_index().name == "green"); + CHECK(evalue.get_index().get_type() == evalue.get_type()); + CHECK(evalue.get_index().get_name() == "green"); CHECK(evalue.get_type() == meta::resolve_type()); CHECK(evalue.get_name() == "green"); @@ -56,7 +56,7 @@ TEST_CASE("meta/meta_states/evalue") { CHECK(evalue.get_value() == color::green); CHECK(evalue.get_value().get_type() == color_type); - CHECK(evalue.get_underlying_value() == meta::detail::stdex::to_underlying(color::green)); + CHECK(evalue.get_underlying_value() == meta::stdex::to_underlying(color::green)); CHECK(evalue.get_underlying_value().get_type() == color_type.get_underlying_type()); } } diff --git a/untests/meta_states/function_tests.cpp b/untests/meta_states/function_tests.cpp index c7bdd78..880eadf 100644 --- a/untests/meta_states/function_tests.cpp +++ b/untests/meta_states/function_tests.cpp @@ -66,8 +66,8 @@ TEST_CASE("meta/meta_states/function") { const meta::function func = ivec2_type.get_function("iadd"); REQUIRE(func); - CHECK(func.get_index().type == func.get_type()); - CHECK(func.get_index().name == "iadd"); + CHECK(func.get_index().get_type() == func.get_type()); + CHECK(func.get_index().get_name() == "iadd"); CHECK(func.get_type() == meta::resolve_type(&ivec2::iadd)); CHECK(func.get_name() == "iadd"); @@ -95,8 +95,8 @@ TEST_CASE("meta/meta_states/function") { const meta::function func = ivec2_type.get_function("ilength2"); REQUIRE(func); - CHECK(func.get_index().type == func.get_type()); - CHECK(func.get_index().name == "ilength2"); + CHECK(func.get_index().get_type() == func.get_type()); + CHECK(func.get_index().get_name() == "ilength2"); CHECK(func.get_type() == meta::resolve_type(&ivec2::ilength2)); CHECK(func.get_name() == "ilength2"); diff --git a/untests/meta_types/class_type_tests.cpp b/untests/meta_types/class_type_tests.cpp index a200cbb..f09cf03 100644 --- a/untests/meta_types/class_type_tests.cpp +++ b/untests/meta_types/class_type_tests.cpp @@ -66,10 +66,10 @@ TEST_CASE("meta/meta_types/class_type") { .member_("base_member_1", &base_clazz_1::base_member_1) .method_("base_method_1", &base_clazz_1::base_method_1) .function_("base_function_1", &base_clazz_1::base_function_1) - .method_("base_method_1_overloaded", meta::select(&base_clazz_1::base_method_1_overloaded)) - .method_("base_method_1_overloaded", meta::select(&base_clazz_1::base_method_1_overloaded)) - .function_("base_function_1_overloaded", meta::select(&base_clazz_1::base_function_1_overloaded)) - .function_("base_function_1_overloaded", meta::select(&base_clazz_1::base_function_1_overloaded)) + .method_("base_method_1_overloaded", meta::select_overload(&base_clazz_1::base_method_1_overloaded)) + .method_("base_method_1_overloaded", meta::select_overload(&base_clazz_1::base_method_1_overloaded)) + .function_("base_function_1_overloaded", meta::select_overload(&base_clazz_1::base_function_1_overloaded)) + .function_("base_function_1_overloaded", meta::select_overload(&base_clazz_1::base_function_1_overloaded)) .variable_("base_variable_1", &base_clazz_1::base_variable_1); meta::class_() diff --git a/untests/meta_types/enum_type_tests.cpp b/untests/meta_types/enum_type_tests.cpp index c50d603..d1505e5 100644 --- a/untests/meta_types/enum_type_tests.cpp +++ b/untests/meta_types/enum_type_tests.cpp @@ -90,7 +90,7 @@ TEST_CASE("meta/meta_types/enum_type") { const meta::evalue green_value = color_type.get_evalue("green"); REQUIRE(green_value); CHECK(green_value.get_value() == color::green); - CHECK(green_value.get_underlying_value() == meta::detail::stdex::to_underlying(color::green)); + CHECK(green_value.get_underlying_value() == meta::stdex::to_underlying(color::green)); } { @@ -107,7 +107,7 @@ TEST_CASE("meta/meta_types/enum_type") { const meta::evalue green_value = ecolor_type.get_evalue("green"); REQUIRE(green_value); CHECK(green_value.get_value() == ecolor_green); - CHECK(green_value.get_underlying_value() == meta::detail::stdex::to_underlying(ecolor_green)); + CHECK(green_value.get_underlying_value() == meta::stdex::to_underlying(ecolor_green)); } { diff --git a/untests/meta_untests.cpp b/untests/meta_untests.cpp new file mode 100644 index 0000000..f9c6c27 --- /dev/null +++ b/untests/meta_untests.cpp @@ -0,0 +1,11 @@ +/******************************************************************************* + * This file is part of the "https://github.com/blackmatov/meta.hpp" + * For conditions of distribution and use, see copyright notice in LICENSE.md + * Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com) + ******************************************************************************/ + +#include "meta_untests.hpp" + +TEST_CASE("meta_hpp") { + namespace meta = meta_hpp; +} diff --git a/untests/meta_utilities/arg_tests.cpp b/untests/meta_utilities/arg_tests.cpp index ed1e59a..efa1d40 100644 --- a/untests/meta_utilities/arg_tests.cpp +++ b/untests/meta_utilities/arg_tests.cpp @@ -69,7 +69,7 @@ namespace #define META_HPP_CHECK_INVOCABLE(FromValue, FName, ToType)\ {\ using namespace meta::detail;\ - auto function_ptr = meta::select(&FName);\ + auto function_ptr = meta::select_overload(&FName);\ meta::function f_state{function_state::make("", function_ptr)};\ \ if ( std::is_invocable_v ) {\ @@ -93,7 +93,7 @@ namespace #define META_HPP_CHECK_INVOCABLE_2(FromValue, FName, FromType, ToType)\ {\ using namespace meta::detail;\ - auto function_ptr = meta::select(&FName);\ + auto function_ptr = meta::select_overload(&FName);\ meta::function f_state{function_state::make("", function_ptr)};\ \ if ( std::is_invocable_v ) {\ diff --git a/untests/meta_utilities/inst_tests.cpp b/untests/meta_utilities/inst_tests.cpp index 90b73d9..bf2936f 100644 --- a/untests/meta_utilities/inst_tests.cpp +++ b/untests/meta_utilities/inst_tests.cpp @@ -29,7 +29,7 @@ namespace #define META_HPP_CHECK_INVOCABLE(Inst, FName, Qualifiers)\ {\ using namespace meta::detail;\ - auto method_ptr = meta::select(&clazz::FName);\ + auto method_ptr = meta::select_overload(&clazz::FName);\ meta::method m_state{method_state::make("", method_ptr)};\ \ if ( std::is_invocable_v ) {\ @@ -53,7 +53,7 @@ namespace #define META_HPP_CHECK_INVOCABLE_2(FromValue, FName, FromType, ToQualifiers)\ {\ using namespace meta::detail;\ - auto method_ptr = meta::select(&clazz::FName);\ + auto method_ptr = meta::select_overload(&clazz::FName);\ meta::method m_state{method_state::make("", method_ptr)};\ \ if ( std::is_invocable_v ) {\