From 7a56ba97ad6fb583cdf17c65b09dbb2b8125bb36 Mon Sep 17 00:00:00 2001 From: BlackMATov Date: Mon, 13 Feb 2023 23:55:55 +0700 Subject: [PATCH] reduce the number of ::instance() calls --- develop/singles/headers/meta.hpp/meta_all.hpp | 595 ++++++++++-------- .../untests/meta_features/diamond_tests.cpp | 224 +++---- develop/untests/meta_utilities/arg2_tests.cpp | 306 ++++----- develop/untests/meta_utilities/arg3_tests.cpp | 50 +- develop/untests/meta_utilities/arg4_tests.cpp | 162 ++--- develop/untests/meta_utilities/arg5_tests.cpp | 162 ++--- develop/untests/meta_utilities/arg7_tests.cpp | 116 ++-- develop/untests/meta_utilities/arg_tests.cpp | 160 ++--- develop/untests/meta_utilities/inst_tests.cpp | 68 +- headers/meta.hpp/meta_base/fixed_function.hpp | 2 +- .../meta_detail/value_utilities/uarg.hpp | 84 +-- .../meta_detail/value_utilities/uinst.hpp | 46 +- .../meta_detail/value_utilities/utraits.hpp | 26 +- headers/meta.hpp/meta_invoke/invoke.hpp | 51 +- headers/meta.hpp/meta_registry.hpp | 8 +- headers/meta.hpp/meta_states/argument.hpp | 5 +- headers/meta.hpp/meta_states/constructor.hpp | 60 +- headers/meta.hpp/meta_states/destructor.hpp | 21 +- headers/meta.hpp/meta_states/evalue.hpp | 4 +- headers/meta.hpp/meta_states/function.hpp | 41 +- headers/meta.hpp/meta_states/member.hpp | 111 ++-- headers/meta.hpp/meta_states/method.hpp | 59 +- headers/meta.hpp/meta_states/scope.hpp | 10 +- headers/meta.hpp/meta_states/variable.hpp | 56 +- headers/meta.hpp/meta_types/class_type.hpp | 9 +- headers/meta.hpp/meta_uvalue/uvalue.hpp | 18 +- 26 files changed, 1340 insertions(+), 1114 deletions(-) diff --git a/develop/singles/headers/meta.hpp/meta_all.hpp b/develop/singles/headers/meta.hpp/meta_all.hpp index 4850124..70413d5 100644 --- a/develop/singles/headers/meta.hpp/meta_all.hpp +++ b/develop/singles/headers/meta.hpp/meta_all.hpp @@ -400,7 +400,7 @@ namespace meta_hpp::detail private: struct buffer_t final { // NOLINTNEXTLINE(*-avoid-c-arrays) - alignas(std::max_align_t) std::byte data[sizeof(void*) * 2]; + alignas(std::max_align_t) std::byte data[sizeof(void*) * 3]; } buffer_{}; }; @@ -3954,12 +3954,16 @@ namespace meta_hpp template < typename... Ts > [[nodiscard]] any_type_list resolve_types() { - return {resolve_type()...}; + using namespace detail; + type_registry& registry = type_registry::instance(); + return {registry.resolve_type>()...}; } template < typename... Ts > [[nodiscard]] any_type_list resolve_types(type_list) { - return {resolve_type()...}; + using namespace detail; + type_registry& registry = type_registry::instance(); + return {registry.resolve_type>()...}; } } @@ -5203,7 +5207,12 @@ namespace meta_hpp::detail namespace meta_hpp::detail { - [[nodiscard]] inline void* pointer_upcast(void* ptr, const class_type& from, const class_type& to) { + [[nodiscard]] inline void* pointer_upcast( // + type_registry& registry, + void* ptr, + const class_type& from, + const class_type& to + ) { if ( nullptr == ptr || !from || !to ) { return nullptr; } @@ -5218,26 +5227,31 @@ namespace meta_hpp::detail } if ( base_type.is_derived_from(to) ) { - return pointer_upcast(base_info.upcast(ptr), base_type, to); + return pointer_upcast(registry, base_info.upcast(ptr), base_type, to); } } return nullptr; } - [[nodiscard]] inline const void* pointer_upcast(const void* ptr, const class_type& from, const class_type& to) { + [[nodiscard]] inline const void* pointer_upcast( // + type_registry& registry, + const void* ptr, + const class_type& from, + const class_type& to + ) { // NOLINTNEXTLINE(*-const-cast) - return pointer_upcast(const_cast(ptr), from, to); + return pointer_upcast(registry, const_cast(ptr), from, to); } template < class_kind To, class_kind From > - [[nodiscard]] To* pointer_upcast(From* ptr) { - return static_cast(pointer_upcast(ptr, resolve_type(), resolve_type())); + [[nodiscard]] To* pointer_upcast(type_registry& registry, From* ptr) { + return static_cast(pointer_upcast(registry, ptr, registry.resolve_type(), registry.resolve_type())); } template < class_kind To, class_kind From > - [[nodiscard]] const To* pointer_upcast(const From* ptr) { - return static_cast(pointer_upcast(ptr, resolve_type(), resolve_type())); + [[nodiscard]] const To* pointer_upcast(type_registry& registry, const From* ptr) { + return static_cast(pointer_upcast(registry, ptr, registry.resolve_type(), registry.resolve_type())); } } @@ -5268,32 +5282,32 @@ namespace meta_hpp::detail template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uarg_base(T&&) - : uarg_base{type_list{}} {} + explicit uarg_base(type_registry& registry, T&&) + : uarg_base{registry, type_list{}} {} template < arg_lvalue_ref_kind T > - explicit uarg_base(type_list) + explicit uarg_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_lvalue : ref_types::lvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} template < arg_rvalue_ref_kind T > - explicit uarg_base(type_list) + explicit uarg_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_rvalue : ref_types::rvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} - explicit uarg_base(uvalue& v) + explicit uarg_base(type_registry&, uvalue& v) : ref_type_{ref_types::lvalue} , raw_type_{v.get_type()} {} - explicit uarg_base(const uvalue& v) + explicit uarg_base(type_registry&, const uvalue& v) : ref_type_{ref_types::const_lvalue} , raw_type_{v.get_type()} {} - explicit uarg_base(uvalue&& v) + explicit uarg_base(type_registry&, uvalue&& v) : ref_type_{ref_types::rvalue} , raw_type_{v.get_type()} {} - explicit uarg_base(const uvalue&& v) + explicit uarg_base(type_registry&, const uvalue&& v) : ref_type_{ref_types::const_rvalue} , raw_type_{v.get_type()} {} @@ -5312,11 +5326,11 @@ namespace meta_hpp::detail template < typename To > requires(std::is_pointer_v) - [[nodiscard]] bool can_cast_to() const noexcept; + [[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept; template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] bool can_cast_to() const noexcept; + [[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept; private: ref_types ref_type_{}; @@ -5339,24 +5353,24 @@ namespace meta_hpp::detail template < typename T, uvalue_kind Tp = std::decay_t > // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uarg(T&& v) - : uarg_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) - , data_{const_cast(v.get_data())} {} + explicit uarg(type_registry& registry, T&& v) + : uarg_base{registry, std::forward(v)} + , data_{const_cast(v.get_data())} {} // NOLINT(*-const-cast) template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uarg(T&& v) - : uarg_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) - , data_{const_cast*>(std::addressof(v))} {} + explicit uarg(type_registry& registry, T&& v) + : uarg_base{registry, std::forward(v)} + , data_{const_cast*>(std::addressof(v))} {} // NOLINT(*-const-cast) template < typename To > requires(std::is_pointer_v) - [[nodiscard]] To cast() const; + [[nodiscard]] To cast(type_registry& registry) const; template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] To cast() const; + [[nodiscard]] To cast(type_registry& registry) const; private: void* data_{}; @@ -5367,12 +5381,12 @@ namespace meta_hpp::detail { template < typename To > requires(std::is_pointer_v) - [[nodiscard]] bool uarg_base::can_cast_to() const noexcept { + [[nodiscard]] bool uarg_base::can_cast_to(type_registry& registry) const noexcept { using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -5422,7 +5436,7 @@ namespace meta_hpp::detail template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] bool uarg_base::can_cast_to() const noexcept { + [[nodiscard]] bool uarg_base::can_cast_to(type_registry& registry) const noexcept { using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; @@ -5432,7 +5446,7 @@ namespace meta_hpp::detail ); const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -5487,14 +5501,14 @@ namespace meta_hpp::detail { template < typename To > requires(std::is_pointer_v) - [[nodiscard]] To uarg::cast() const { - META_HPP_ASSERT(can_cast_to() && "bad argument cast"); + [[nodiscard]] To uarg::cast(type_registry& registry) const { + META_HPP_ASSERT(can_cast_to(registry) && "bad argument cast"); using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); if ( to_type.is_pointer() && from_type.is_nullptr() ) { return static_cast(nullptr); @@ -5515,7 +5529,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 = pointer_upcast(data_, from_data_class, to_data_class); + void* to_ptr = pointer_upcast(registry, data_, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -5537,7 +5551,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 = pointer_upcast(*from_data_ptr, from_data_class, to_data_class); + void* to_ptr = pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -5547,8 +5561,8 @@ namespace meta_hpp::detail template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] To uarg::cast() const { - META_HPP_ASSERT(can_cast_to() && "bad argument cast"); + [[nodiscard]] To uarg::cast(type_registry& registry) const { + META_HPP_ASSERT(can_cast_to(registry) && "bad argument cast"); using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; @@ -5559,11 +5573,11 @@ namespace meta_hpp::detail ); const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); void* to_ptr = to_type == from_type // ? data_ - : pointer_upcast(data_, from_type.as_class(), to_type.as_class()); + : pointer_upcast(registry, data_, from_type.as_class(), to_type.as_class()); if constexpr ( std::is_lvalue_reference_v ) { return *static_cast(to_ptr); @@ -5605,28 +5619,28 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < typename ArgTypeList, typename F > - auto call_with_uargs(std::span args, F&& f) { + auto call_with_uargs(type_registry& registry, std::span args, F&& f) { META_HPP_ASSERT(args.size() == type_list_arity_v); - return [ args, &f ](std::index_sequence) { - return f(args[Is].cast>()...); + return [ args, ®istry, &f ](std::index_sequence) { + return f(args[Is].cast>(registry)...); } (std::make_index_sequence>()); } template < typename ArgTypeList > - bool can_cast_all_uargs(std::span args) { + bool can_cast_all_uargs(type_registry& registry, std::span args) { META_HPP_ASSERT(args.size() == type_list_arity_v); - return [args](std::index_sequence) { - return (... && args[Is].can_cast_to>()); + return [ args, ®istry ](std::index_sequence) { + return (... && args[Is].can_cast_to>(registry)); } (std::make_index_sequence>()); } template < typename ArgTypeList > - bool can_cast_all_uargs(std::span args) { + bool can_cast_all_uargs(type_registry& registry, std::span args) { META_HPP_ASSERT(args.size() == type_list_arity_v); - return [args](std::index_sequence) { - return (... && args[Is].can_cast_to>()); + return [ args, ®istry ](std::index_sequence) { + return (... && args[Is].can_cast_to>(registry)); } (std::make_index_sequence>()); } @@ -5671,7 +5685,7 @@ namespace meta_hpp namespace meta_hpp::detail { template < function_policy_kind Policy, function_pointer_kind Function > - uvalue raw_function_invoke(Function function_ptr, std::span args) { + uvalue raw_function_invoke(type_registry& registry, Function function_ptr, std::span args) { using ft = function_traits; using return_type = typename ft::return_type; using argument_types = typename ft::argument_types; @@ -5695,12 +5709,12 @@ namespace meta_hpp::detail && "an attempt to call a function with an incorrect arity" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a function with incorrect argument types" ); - return call_with_uargs(args, [function_ptr](auto&&... all_args) { + return call_with_uargs(registry, args, [function_ptr](auto&&... all_args) { if constexpr ( std::is_void_v ) { function_ptr(META_HPP_FWD(all_args)...); return uvalue{}; @@ -5719,27 +5733,29 @@ namespace meta_hpp::detail } template < function_pointer_kind Function > - bool raw_function_is_invocable_with(std::span args) { + bool raw_function_is_invocable_with(type_registry& registry, std::span args) { using ft = function_traits; using argument_types = typename ft::argument_types; return args.size() == ft::arity // - && can_cast_all_uargs(args); + && can_cast_all_uargs(registry, args); } } namespace meta_hpp::detail { template < function_policy_kind Policy, function_pointer_kind Function > - function_state::invoke_impl make_function_invoke(Function function_ptr) { - return [function_ptr](std::span args) { // - return raw_function_invoke(function_ptr, args); + function_state::invoke_impl make_function_invoke(type_registry& registry, Function function_ptr) { + return [®istry, function_ptr](std::span args) { // + return raw_function_invoke(registry, function_ptr, args); }; } template < function_pointer_kind Function > - function_state::is_invocable_with_impl make_function_is_invocable_with() { - return &raw_function_is_invocable_with; + function_state::is_invocable_with_impl make_function_is_invocable_with(type_registry& registry) { + return [®istry](std::span args) { // + return raw_function_is_invocable_with(registry, args); + }; } template < function_pointer_kind Function > @@ -5766,9 +5782,10 @@ namespace meta_hpp::detail template < function_policy_kind Policy, function_pointer_kind Function > function_state_ptr function_state::make(std::string name, Function function_ptr, metadata_map metadata) { - function_state state{function_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.invoke = make_function_invoke(function_ptr); - state.is_invocable_with = make_function_is_invocable_with(); + type_registry& registry{type_registry::instance()}; + function_state state{function_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.invoke = make_function_invoke(registry, function_ptr); + state.is_invocable_with = make_function_is_invocable_with(registry); state.arguments = make_function_arguments(); return make_intrusive(std::move(state)); } @@ -5787,7 +5804,8 @@ namespace meta_hpp template < typename... Args > uvalue function::invoke(Args&&... args) const { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->invoke(vargs); } @@ -5807,14 +5825,16 @@ namespace meta_hpp template < typename... Args > bool function::is_invocable_with() const noexcept { using namespace detail; - const std::array vargs{uarg_base{type_list{}}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, type_list{}}...}; return state_->is_invocable_with(vargs); } template < typename... Args > bool function::is_invocable_with(Args&&... args) const noexcept { using namespace detail; - const std::array vargs{uarg_base{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; return state_->is_invocable_with(vargs); } @@ -5854,32 +5874,32 @@ namespace meta_hpp::detail template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uinst_base(T&&) - : uinst_base{type_list{}} {} + explicit uinst_base(type_registry& registry, T&&) + : uinst_base{registry, type_list{}} {} template < inst_class_lvalue_ref_kind T > - explicit uinst_base(type_list) + explicit uinst_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_lvalue : ref_types::lvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} template < inst_class_rvalue_ref_kind T > - explicit uinst_base(type_list) + explicit uinst_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_rvalue : ref_types::rvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} - explicit uinst_base(uvalue& v) + explicit uinst_base(type_registry&, uvalue& v) : ref_type_{ref_types::lvalue} , raw_type_{v.get_type()} {} - explicit uinst_base(const uvalue& v) + explicit uinst_base(type_registry&, const uvalue& v) : ref_type_{ref_types::const_lvalue} , raw_type_{v.get_type()} {} - explicit uinst_base(uvalue&& v) + explicit uinst_base(type_registry&, uvalue&& v) : ref_type_{ref_types::rvalue} , raw_type_{v.get_type()} {} - explicit uinst_base(const uvalue&& v) + explicit uinst_base(type_registry&, const uvalue&& v) : ref_type_{ref_types::const_rvalue} , raw_type_{v.get_type()} {} @@ -5902,7 +5922,7 @@ namespace meta_hpp::detail } template < inst_class_ref_kind Q > - [[nodiscard]] bool can_cast_to() const noexcept; + [[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept; private: ref_types ref_type_{}; @@ -5925,19 +5945,19 @@ namespace meta_hpp::detail template < typename T, uvalue_kind Tp = std::decay_t > // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uinst(T&& v) - : uinst_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) + explicit uinst(type_registry& registry, T&& v) + : uinst_base{registry, std::forward(v)} // NOLINTNEXTLINE(*-const-cast) , data_{const_cast(v.get_data())} {} template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uinst(T&& v) - : uinst_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) + explicit uinst(type_registry& registry, T&& v) + : uinst_base{registry, std::forward(v)} // NOLINTNEXTLINE(*-const-cast) , data_{const_cast*>(std::addressof(v))} {} template < inst_class_ref_kind Q > - [[nodiscard]] decltype(auto) cast() const; + [[nodiscard]] decltype(auto) cast(type_registry& registry) const; private: void* data_{}; @@ -5947,12 +5967,12 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < inst_class_ref_kind Q > - bool uinst_base::can_cast_to() const noexcept { + bool uinst_base::can_cast_to(type_registry& registry) 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 any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -5997,20 +6017,20 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < inst_class_ref_kind Q > - decltype(auto) uinst::cast() const { - META_HPP_ASSERT(can_cast_to() && "bad instance cast"); + decltype(auto) uinst::cast(type_registry& registry) const { + META_HPP_ASSERT(can_cast_to(registry) && "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(); + const any_type& to_type = registry.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); + void* to_ptr = pointer_upcast(registry, data_, from_class, to_class); if constexpr ( !std::is_reference_v ) { return *static_cast(to_ptr); @@ -6034,7 +6054,7 @@ namespace meta_hpp::detail const class_type& to_class = to_type.as_class(); void** from_data_ptr = static_cast(data_); - void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_class); + void* to_ptr = pointer_upcast(registry, *from_data_ptr, from_data_class, to_class); if constexpr ( !std::is_reference_v ) { return *static_cast(to_ptr); @@ -6081,7 +6101,7 @@ namespace meta_hpp namespace meta_hpp::detail { template < member_policy_kind Policy, member_pointer_kind Member > - uvalue raw_member_getter(Member member_ptr, const uinst& inst) { + uvalue raw_member_getter(type_registry& registry, Member member_ptr, const uinst& inst) { using mt = member_traits; using class_type = typename mt::class_type; using value_type = typename mt::value_type; @@ -6099,12 +6119,12 @@ namespace meta_hpp::detail static_assert(as_copy || as_ptr || as_ref_wrap); if ( inst.is_inst_const() ) { - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to get a member with an incorrect instance type" ); - auto&& return_value = inst.cast().*member_ptr; + auto&& return_value = inst.cast(registry).*member_ptr; if constexpr ( as_copy ) { return uvalue{META_HPP_FWD(return_value)}; @@ -6118,12 +6138,12 @@ namespace meta_hpp::detail return uvalue{std::ref(return_value)}; } } else { - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to get a member with an incorrect instance type" ); - auto&& return_value = inst.cast().*member_ptr; + auto&& return_value = inst.cast(registry).*member_ptr; if constexpr ( as_copy ) { return uvalue{META_HPP_FWD(return_value)}; @@ -6140,23 +6160,27 @@ namespace meta_hpp::detail } template < member_pointer_kind Member > - bool raw_member_is_gettable_with(const uinst_base& inst) { + bool raw_member_is_gettable_with(type_registry& registry, const uinst_base& inst) { using mt = member_traits; using class_type = typename mt::class_type; - return inst.can_cast_to(); + return inst.can_cast_to(registry); } } namespace meta_hpp::detail { template < member_pointer_kind Member > - void raw_member_setter([[maybe_unused]] Member member_ptr, const uinst& inst, const uarg& arg) { + void raw_member_setter(type_registry& registry, Member member_ptr, const uinst& inst, const uarg& arg) { using mt = member_traits; using class_type = typename mt::class_type; using value_type = typename mt::value_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)member_ptr; + (void)inst; + (void)arg; META_HPP_ASSERT(false && "an attempt to set a constant member"); } else { META_HPP_ASSERT( // @@ -6164,32 +6188,35 @@ namespace meta_hpp::detail && "an attempt to set a member with an const instance type" ); - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to set a member with an incorrect instance type" ); - META_HPP_ASSERT( // - arg.can_cast_to() // + META_HPP_ASSERT( // + arg.can_cast_to(registry) // && "an attempt to set a member with an incorrect argument type" ); - inst.cast().*member_ptr = arg.cast(); + inst.cast(registry).*member_ptr = arg.cast(registry); } } template < member_pointer_kind Member > - bool raw_member_is_settable_with(const uinst_base& inst, const uarg_base& arg) { + bool raw_member_is_settable_with(type_registry& registry, const uinst_base& inst, const uarg_base& arg) { using mt = member_traits; using class_type = typename mt::class_type; using value_type = typename mt::value_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)inst; + (void)arg; return false; } else { - return !inst.is_inst_const() // - && inst.can_cast_to() // - && arg.can_cast_to(); // + return !inst.is_inst_const() // + && inst.can_cast_to(registry) // + && arg.can_cast_to(registry); // } } } @@ -6197,27 +6224,31 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < member_policy_kind Policy, member_pointer_kind Member > - member_state::getter_impl make_member_getter(Member member_ptr) { - return [member_ptr](const uinst& inst) { // - return raw_member_getter(member_ptr, inst); + member_state::getter_impl make_member_getter(type_registry& registry, Member member_ptr) { + return [®istry, member_ptr](const uinst& inst) { // + return raw_member_getter(registry, member_ptr, inst); }; } template < member_pointer_kind Member > - member_state::is_gettable_with_impl make_member_is_gettable_with() { - return &raw_member_is_gettable_with; - } - - template < member_pointer_kind Member > - member_state::setter_impl make_member_setter(Member member_ptr) { - return [member_ptr](const uinst& inst, const uarg& arg) { // - return raw_member_setter(member_ptr, inst, arg); + member_state::is_gettable_with_impl make_member_is_gettable_with(type_registry& registry) { + return [®istry](const uinst_base& inst) { // + return raw_member_is_gettable_with(registry, inst); }; } template < member_pointer_kind Member > - member_state::is_settable_with_impl make_member_is_settable_with() { - return &raw_member_is_settable_with; + member_state::setter_impl make_member_setter(type_registry& registry, Member member_ptr) { + return [®istry, member_ptr](const uinst& inst, const uarg& arg) { // + return raw_member_setter(registry, member_ptr, inst, arg); + }; + } + + template < member_pointer_kind Member > + member_state::is_settable_with_impl make_member_is_settable_with(type_registry& registry) { + return [®istry](const uinst_base& inst, const uarg_base& arg) { // + return raw_member_is_settable_with(registry, inst, arg); + }; } } @@ -6229,11 +6260,12 @@ namespace meta_hpp::detail template < member_policy_kind Policy, member_pointer_kind Member > member_state_ptr member_state::make(std::string name, Member member_ptr, metadata_map metadata) { - member_state state{member_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.getter = make_member_getter(member_ptr); - state.setter = make_member_setter(member_ptr); - state.is_gettable_with = make_member_is_gettable_with(); - state.is_settable_with = make_member_is_settable_with(); + type_registry& registry{type_registry::instance()}; + member_state state{member_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.getter = make_member_getter(registry, member_ptr); + state.setter = make_member_setter(registry, member_ptr); + state.is_gettable_with = make_member_is_gettable_with(registry); + state.is_settable_with = make_member_is_settable_with(registry); return make_intrusive(std::move(state)); } } @@ -6251,7 +6283,8 @@ namespace meta_hpp template < typename Instance > uvalue member::get(Instance&& instance) const { using namespace detail; - const uinst vinst{std::forward(instance)}; + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; return state_->getter(vinst); } @@ -6276,8 +6309,9 @@ namespace meta_hpp template < typename Instance, typename Value > void member::set(Instance&& instance, Value&& value) const { using namespace detail; - const uinst vinst{std::forward(instance)}; - const uarg vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + const uarg vvalue{registry, std::forward(value)}; state_->setter(vinst, vvalue); } @@ -6303,30 +6337,34 @@ namespace meta_hpp template < typename Instance > [[nodiscard]] bool member::is_gettable_with() const noexcept { using namespace detail; - const uinst_base vinst{type_list{}}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; return state_->is_gettable_with(vinst); } template < typename Instance > [[nodiscard]] bool member::is_gettable_with(Instance&& instance) const noexcept { using namespace detail; - const uinst_base vinst{std::forward(instance)}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; return state_->is_gettable_with(vinst); } template < typename Instance, typename Value > [[nodiscard]] bool member::is_settable_with() const noexcept { using namespace detail; - const uinst_base vinst{type_list{}}; - const uarg_base vvalue{type_list{}}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + const uarg_base vvalue{registry, type_list{}}; return state_->is_settable_with(vinst, vvalue); } template < typename Instance, typename Value > [[nodiscard]] bool member::is_settable_with(Instance&& instance, Value&& value) const noexcept { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - const uarg_base vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + const uarg_base vvalue{registry, std::forward(value)}; return state_->is_settable_with(vinst, vvalue); } } @@ -6375,7 +6413,7 @@ namespace meta_hpp namespace meta_hpp::detail { template < method_policy_kind Policy, method_pointer_kind Method > - uvalue raw_method_invoke(Method method_ptr, const uinst& inst, std::span args) { + uvalue raw_method_invoke(type_registry& registry, Method method_ptr, const uinst& inst, std::span args) { using mt = method_traits; using return_type = typename mt::return_type; using qualified_type = typename mt::qualified_type; @@ -6400,19 +6438,19 @@ namespace meta_hpp::detail && "an attempt to call a method with an incorrect arity" ); - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to call a method with an incorrect instance type" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a method with incorrect argument types" ); - return call_with_uargs(args, [method_ptr, &inst](auto&&... all_args) { + return call_with_uargs(registry, args, [method_ptr, &inst, ®istry](auto&&... all_args) { if constexpr ( std::is_void_v ) { - (inst.cast().*method_ptr)(META_HPP_FWD(all_args)...); + (inst.cast(registry).*method_ptr)(META_HPP_FWD(all_args)...); return uvalue{}; } @@ -6422,36 +6460,38 @@ namespace meta_hpp::detail } if constexpr ( !std::is_void_v ) { - return_type&& result = (inst.cast().*method_ptr)(META_HPP_FWD(all_args)...); + return_type&& result = (inst.cast(registry).*method_ptr)(META_HPP_FWD(all_args)...); return ref_as_ptr ? uvalue{std::addressof(result)} : uvalue{META_HPP_FWD(result)}; } }); } template < method_pointer_kind Method > - bool raw_method_is_invocable_with(const uinst_base& inst, std::span args) { + bool raw_method_is_invocable_with(type_registry& registry, const uinst_base& inst, std::span args) { using mt = method_traits; using qualified_type = typename mt::qualified_type; using argument_types = typename mt::argument_types; - return args.size() == mt::arity // - && inst.can_cast_to() // - && can_cast_all_uargs(args); + return args.size() == mt::arity // + && inst.can_cast_to(registry) // + && can_cast_all_uargs(registry, args); } } namespace meta_hpp::detail { template < method_policy_kind Policy, method_pointer_kind Method > - method_state::invoke_impl make_method_invoke(Method method_ptr) { - return [method_ptr](const uinst& inst, std::span args) { - return raw_method_invoke(method_ptr, inst, args); + method_state::invoke_impl make_method_invoke(type_registry& registry, Method method_ptr) { + return [®istry, method_ptr](const uinst& inst, std::span args) { + return raw_method_invoke(registry, method_ptr, inst, args); }; } template < method_pointer_kind Method > - method_state::is_invocable_with_impl make_method_is_invocable_with() { - return &raw_method_is_invocable_with; + method_state::is_invocable_with_impl make_method_is_invocable_with(type_registry& registry) { + return [®istry](const uinst_base& inst, std::span args) { + return raw_method_is_invocable_with(registry, inst, args); + }; } template < method_pointer_kind Method > @@ -6478,9 +6518,10 @@ namespace meta_hpp::detail template < method_policy_kind Policy, method_pointer_kind Method > method_state_ptr method_state::make(std::string name, Method method_ptr, metadata_map metadata) { - method_state state{method_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.invoke = make_method_invoke(method_ptr); - state.is_invocable_with = make_method_is_invocable_with(); + type_registry& registry{type_registry::instance()}; + method_state state{method_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.invoke = make_method_invoke(registry, method_ptr); + state.is_invocable_with = make_method_is_invocable_with(registry); state.arguments = make_method_arguments(); return make_intrusive(std::move(state)); } @@ -6499,8 +6540,9 @@ namespace meta_hpp template < typename Instance, typename... Args > uvalue method::invoke(Instance&& instance, Args&&... args) const { using namespace detail; - const uinst vinst{std::forward(instance)}; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->invoke(vinst, vargs); } @@ -6520,16 +6562,18 @@ namespace meta_hpp template < typename Instance, typename... Args > bool method::is_invocable_with() const noexcept { using namespace detail; - const uinst_base vinst{type_list{}}; - const std::array vargs{uarg_base{type_list{}}...}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + const std::array vargs{uarg_base{registry, type_list{}}...}; return state_->is_invocable_with(vinst, vargs); } template < typename Instance, typename... Args > bool method::is_invocable_with(Instance&& instance, Args&&... args) const noexcept { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - const std::array vargs{uarg_base{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; return state_->is_invocable_with(vinst, vargs); } @@ -6552,8 +6596,9 @@ namespace meta_hpp template < detail::function_pointer_kind Function, typename... Args > uvalue invoke(Function function_ptr, Args&&... args) { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; - return raw_function_invoke(function_ptr, vargs); + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; + return raw_function_invoke(registry, function_ptr, vargs); } } @@ -6567,8 +6612,9 @@ namespace meta_hpp template < detail::member_pointer_kind Member, typename Instance > uvalue invoke(Member member_ptr, Instance&& instance) { using namespace detail; - const uinst vinst{std::forward(instance)}; - return raw_member_getter(member_ptr, vinst); + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + return raw_member_getter(registry, member_ptr, vinst); } } @@ -6582,9 +6628,10 @@ namespace meta_hpp template < detail::method_pointer_kind Method, typename Instance, typename... Args > uvalue invoke(Method method_ptr, Instance&& instance, Args&&... args) { using namespace detail; - const uinst vinst{std::forward(instance)}; - const std::array vargs{uarg{std::forward(args)}...}; - return raw_method_invoke(method_ptr, vinst, vargs); + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + const std::array vargs{uarg{registry, std::forward(args)}...}; + return raw_method_invoke(registry, method_ptr, vinst, vargs); } } @@ -6603,15 +6650,17 @@ namespace meta_hpp template < detail::function_pointer_kind Function, typename... Args > bool is_invocable_with() { using namespace detail; - const std::array vargs{uarg_base{type_list{}}...}; - return raw_function_is_invocable_with(vargs); + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, type_list{}}...}; + return raw_function_is_invocable_with(registry, vargs); } template < detail::function_pointer_kind Function, typename... Args > bool is_invocable_with(Args&&... args) { using namespace detail; - const std::array vargs{uarg_base{std::forward(args)}...}; - return raw_function_is_invocable_with(vargs); + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; + return raw_function_is_invocable_with(registry, vargs); } } @@ -6630,15 +6679,17 @@ namespace meta_hpp template < detail::member_pointer_kind Member, typename Instance > bool is_invocable_with() { using namespace detail; - const uinst_base vinst{type_list{}}; - return raw_member_is_gettable_with(vinst); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + return raw_member_is_gettable_with(registry, vinst); } template < detail::member_pointer_kind Member, typename Instance > bool is_invocable_with(Instance&& instance) { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - return raw_member_is_gettable_with(vinst); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + return raw_member_is_gettable_with(registry, vinst); } } @@ -6657,17 +6708,19 @@ namespace meta_hpp template < detail::method_pointer_kind Method, typename Instance, typename... Args > bool is_invocable_with() { using namespace detail; - const uinst_base vinst{type_list{}}; - const std::array vargs{uarg_base{type_list{}}...}; - return raw_method_is_invocable_with(vinst, vargs); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + const std::array vargs{uarg_base{registry, type_list{}}...}; + return raw_method_is_invocable_with(registry, vinst, vargs); } template < detail::method_pointer_kind Method, typename Instance, typename... Args > bool is_invocable_with(Instance&& instance, Args&&... args) { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - const std::array vargs{uarg_base{std::forward(args)}...}; - return raw_method_is_invocable_with(vinst, vargs); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; + return raw_method_is_invocable_with(registry, vinst, vargs); } } @@ -6679,7 +6732,8 @@ namespace meta_hpp::detail template < typename Argument > inline argument_state_ptr argument_state::make(std::size_t position, metadata_map metadata) { - argument_state state{argument_index{resolve_type(), position}, std::move(metadata)}; + type_registry& registry{type_registry::instance()}; + argument_state state{argument_index{registry.resolve_type(), position}, std::move(metadata)}; return make_intrusive(std::move(state)); } } @@ -6738,7 +6792,7 @@ namespace meta_hpp namespace meta_hpp::detail { template < constructor_policy_kind Policy, class_kind Class, typename... Args > - uvalue raw_constructor_create(std::span args) { + uvalue raw_constructor_create(type_registry& registry, std::span args) { using ct = constructor_traits; using class_type = typename ct::class_type; using argument_types = typename ct::argument_types; @@ -6760,12 +6814,12 @@ namespace meta_hpp::detail && "an attempt to call a constructor with an incorrect arity" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a constructor with incorrect argument types" ); - return call_with_uargs(args, [](auto&&... all_args) -> uvalue { + return call_with_uargs(registry, args, [](auto&&... all_args) -> uvalue { if constexpr ( as_object ) { return make_uvalue(META_HPP_FWD(all_args)...); } @@ -6781,7 +6835,7 @@ namespace meta_hpp::detail } template < class_kind Class, typename... Args > - uvalue raw_constructor_create_at(void* mem, std::span args) { + uvalue raw_constructor_create_at(type_registry& registry, void* mem, std::span args) { using ct = constructor_traits; using class_type = typename ct::class_type; using argument_types = typename ct::argument_types; @@ -6791,41 +6845,47 @@ namespace meta_hpp::detail && "an attempt to call a constructor with an incorrect arity" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a constructor with incorrect argument types" ); - return call_with_uargs(args, [mem](auto&&... all_args) { + return call_with_uargs(registry, args, [mem](auto&&... all_args) { return std::construct_at(static_cast(mem), META_HPP_FWD(all_args)...); }); } template < class_kind Class, typename... Args > - bool raw_constructor_is_invocable_with(std::span args) { + bool raw_constructor_is_invocable_with(type_registry& registry, std::span args) { using ct = constructor_traits; using argument_types = typename ct::argument_types; return args.size() == ct::arity // - && can_cast_all_uargs(args); + && can_cast_all_uargs(registry, args); } } namespace meta_hpp::detail { template < constructor_policy_kind Policy, class_kind Class, typename... Args > - constructor_state::create_impl make_constructor_create() { - return &raw_constructor_create; + constructor_state::create_impl make_constructor_create(type_registry& registry) { + return [®istry](std::span args) { // + return raw_constructor_create(registry, args); + }; } template < class_kind Class, typename... Args > - constructor_state::create_at_impl make_constructor_create_at() { - return &raw_constructor_create_at; + constructor_state::create_at_impl make_constructor_create_at(type_registry& registry) { + return [®istry](void* mem, std::span args) { // + return raw_constructor_create_at(registry, mem, args); + }; } template < class_kind Class, typename... Args > - constructor_state::is_invocable_with_impl make_constructor_is_invocable_with() { - return &raw_constructor_is_invocable_with; + constructor_state::is_invocable_with_impl make_constructor_is_invocable_with(type_registry& registry) { + return [®istry](std::span args) { // + return raw_constructor_is_invocable_with(registry, args); + }; } template < class_kind Class, typename... Args > @@ -6852,10 +6912,11 @@ namespace meta_hpp::detail template < constructor_policy_kind Policy, class_kind Class, typename... Args > constructor_state_ptr constructor_state::make(metadata_map metadata) { - constructor_state state{constructor_index{resolve_constructor_type()}, std::move(metadata)}; - state.create = make_constructor_create(); - state.create_at = make_constructor_create_at(); - state.is_invocable_with = make_constructor_is_invocable_with(); + type_registry& registry{type_registry::instance()}; + constructor_state state{constructor_index{registry.resolve_constructor_type()}, std::move(metadata)}; + state.create = make_constructor_create(registry); + state.create_at = make_constructor_create_at(registry); + state.is_invocable_with = make_constructor_is_invocable_with(registry); state.arguments = make_constructor_arguments(); return make_intrusive(std::move(state)); } @@ -6870,7 +6931,8 @@ namespace meta_hpp template < typename... Args > uvalue constructor::create(Args&&... args) const { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->create(vargs); } @@ -6885,7 +6947,8 @@ namespace meta_hpp template < typename... Args > uvalue constructor::create_at(void* mem, Args&&... args) const { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->create_at(mem, vargs); } @@ -6900,14 +6963,16 @@ namespace meta_hpp template < typename... Args > bool constructor::is_invocable_with() const noexcept { using namespace detail; - const std::array vargs{uarg_base{type_list{}}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, type_list{}}...}; return state_->is_invocable_with(vargs); } template < typename... Args > bool constructor::is_invocable_with(Args&&... args) const noexcept { using namespace detail; - const std::array vargs{uarg_base{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; return state_->is_invocable_with(vargs); } @@ -6946,15 +7011,15 @@ namespace meta_hpp namespace meta_hpp::detail { template < class_kind Class > - bool raw_destructor_destroy(const uarg& arg) { + bool raw_destructor_destroy(type_registry& registry, const uarg& arg) { using dt = destructor_traits; using class_type = typename dt::class_type; - if ( !arg.can_cast_to() ) { + if ( !arg.can_cast_to(registry) ) { return false; } - std::unique_ptr{arg.cast()}.reset(); + std::unique_ptr{arg.cast(registry)}.reset(); return true; } @@ -6970,8 +7035,10 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < class_kind Class > - destructor_state::destroy_impl make_destructor_destroy() { - return &raw_destructor_destroy; + destructor_state::destroy_impl make_destructor_destroy(type_registry& registry) { + return [®istry](const uarg& arg) { // + return raw_destructor_destroy(registry, arg); + }; } template < class_kind Class > @@ -6988,8 +7055,9 @@ namespace meta_hpp::detail template < class_kind Class > destructor_state_ptr destructor_state::make(metadata_map metadata) { - destructor_state state{destructor_index{resolve_destructor_type()}, std::move(metadata)}; - state.destroy = make_destructor_destroy(); + type_registry& registry{type_registry::instance()}; + destructor_state state{destructor_index{registry.resolve_destructor_type()}, std::move(metadata)}; + state.destroy = make_destructor_destroy(registry); state.destroy_at = make_destructor_destroy_at(); return make_intrusive(std::move(state)); } @@ -7004,7 +7072,8 @@ namespace meta_hpp template < typename Arg > bool destructor::destroy(Arg&& arg) const { using namespace detail; - const uarg varg{std::forward(arg)}; + type_registry& registry{type_registry::instance()}; + const uarg varg{registry, std::forward(arg)}; return state_->destroy(varg); } @@ -7090,7 +7159,8 @@ namespace meta_hpp::detail template < enum_kind Enum > evalue_state_ptr evalue_state::make(std::string name, Enum evalue, metadata_map metadata) { - evalue_state state{evalue_index{resolve_type(), std::move(name)}, std::move(metadata)}; + type_registry& registry{type_registry::instance()}; + evalue_state state{evalue_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; state.enum_value = uvalue{evalue}; state.underlying_value = uvalue{to_underlying(evalue)}; return make_intrusive(std::move(state)); @@ -7162,7 +7232,7 @@ namespace meta_hpp namespace meta_hpp::detail { template < variable_policy_kind Policy, pointer_kind Pointer > - uvalue raw_variable_getter(Pointer variable_ptr) { + uvalue raw_variable_getter(type_registry&, Pointer variable_ptr) { using pt = pointer_traits; using data_type = typename pt::data_type; @@ -7194,31 +7264,36 @@ namespace meta_hpp::detail } template < pointer_kind Pointer > - void raw_variable_setter([[maybe_unused]] Pointer variable_ptr, const uarg& arg) { + void raw_variable_setter(type_registry& registry, Pointer variable_ptr, const uarg& arg) { using pt = pointer_traits; using data_type = typename pt::data_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)variable_ptr; + (void)arg; META_HPP_ASSERT(false && "an attempt to set a constant variable"); } else { - META_HPP_ASSERT( // - arg.can_cast_to() // + META_HPP_ASSERT( // + arg.can_cast_to(registry) // && "an attempt to set a variable with an incorrect argument type" ); - *variable_ptr = arg.cast(); + *variable_ptr = arg.cast(registry); } } template < pointer_kind Pointer > - bool raw_variable_is_settable_with(const uarg_base& arg) { + bool raw_variable_is_settable_with(type_registry& registry, const uarg_base& arg) { using pt = pointer_traits; using data_type = typename pt::data_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)arg; return false; } else { - return arg.can_cast_to(); + return arg.can_cast_to(registry); } } } @@ -7226,22 +7301,24 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < variable_policy_kind Policy, pointer_kind Pointer > - variable_state::getter_impl make_variable_getter(Pointer variable_ptr) { - return [variable_ptr]() { // - return raw_variable_getter(variable_ptr); + variable_state::getter_impl make_variable_getter(type_registry& registry, Pointer variable_ptr) { + return [®istry, variable_ptr]() { // + return raw_variable_getter(registry, variable_ptr); }; } template < pointer_kind Pointer > - variable_state::setter_impl make_variable_setter(Pointer variable_ptr) { - return [variable_ptr](const uarg& arg) { // - return raw_variable_setter(variable_ptr, arg); + variable_state::setter_impl make_variable_setter(type_registry& registry, Pointer variable_ptr) { + return [®istry, variable_ptr](const uarg& arg) { // + return raw_variable_setter(registry, variable_ptr, arg); }; } template < pointer_kind Pointer > - variable_state::is_settable_with_impl make_variable_is_settable_with() { - return &raw_variable_is_settable_with; + variable_state::is_settable_with_impl make_variable_is_settable_with(type_registry& registry) { + return [®istry](const uarg_base& arg) { // + return raw_variable_is_settable_with(registry, arg); + }; } } @@ -7253,10 +7330,11 @@ namespace meta_hpp::detail template < variable_policy_kind Policy, pointer_kind Pointer > variable_state_ptr variable_state::make(std::string name, Pointer variable_ptr, metadata_map metadata) { - variable_state state{variable_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.getter = make_variable_getter(variable_ptr); - state.setter = make_variable_setter(variable_ptr); - state.is_settable_with = make_variable_is_settable_with(); + type_registry& registry{type_registry::instance()}; + variable_state state{variable_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.getter = make_variable_getter(registry, variable_ptr); + state.setter = make_variable_setter(registry, variable_ptr); + state.is_settable_with = make_variable_is_settable_with(registry); return make_intrusive(std::move(state)); } } @@ -7292,7 +7370,8 @@ namespace meta_hpp template < typename Value > void variable::set(Value&& value) const { using namespace detail; - const uarg vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uarg vvalue{registry, std::forward(value)}; state_->setter(vvalue); } @@ -7317,14 +7396,16 @@ namespace meta_hpp template < typename Value > bool variable::is_settable_with() const noexcept { using namespace detail; - const uarg_base vvalue{type_list{}}; + type_registry& registry{type_registry::instance()}; + const uarg_base vvalue{registry, type_list{}}; return state_->is_settable_with(vvalue); } template < typename Value > bool variable::is_settable_with(Value&& value) const noexcept { using namespace detail; - const uarg_base vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uarg_base vvalue{registry, std::forward(value)}; return state_->is_settable_with(vvalue); } } @@ -7569,7 +7650,8 @@ namespace meta_hpp template < typename... Args > constructor class_type::get_constructor_with() const noexcept { - return get_constructor_with({resolve_type()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_constructor_with({registry.resolve_type()...}); } template < typename Iter > @@ -7608,7 +7690,8 @@ 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()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_function_with(name, {registry.resolve_type()...}); } template < typename Iter > @@ -7647,7 +7730,8 @@ 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()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_method_with(name, {registry.resolve_type()...}); } template < typename Iter > @@ -7738,7 +7822,8 @@ namespace meta_hpp template < typename... Args > function scope::get_function_with(std::string_view name) const noexcept { - return get_function_with(name, {resolve_type()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_function_with(name, {registry.resolve_type()...}); } template < typename Iter > @@ -8630,8 +8715,11 @@ namespace meta_hpp auto uvalue::try_get_as() noexcept -> std::conditional_t, T, T*> { static_assert(std::is_same_v>); + using detail::type_registry; + type_registry& registry{type_registry::instance()}; + const any_type& from_type = get_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -8665,7 +8753,7 @@ namespace meta_hpp 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 = detail::pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -8682,7 +8770,7 @@ namespace meta_hpp const class_type& to_class = to_type.as_class(); const class_type& from_class = from_type.as_class(); - T* to_ptr = static_cast(detail::pointer_upcast(get_data(), from_class, to_class)); + T* to_ptr = static_cast(detail::pointer_upcast(registry, get_data(), from_class, to_class)); return to_ptr; } } @@ -8695,8 +8783,11 @@ namespace meta_hpp auto uvalue::try_get_as() const noexcept -> std::conditional_t, T, const T*> { static_assert(std::is_same_v>); + using detail::type_registry; + type_registry& registry{type_registry::instance()}; + const any_type& from_type = get_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -8730,7 +8821,7 @@ namespace meta_hpp 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 = detail::pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -8747,7 +8838,7 @@ namespace meta_hpp const class_type& to_class = to_type.as_class(); const class_type& from_class = from_type.as_class(); - const T* to_ptr = static_cast(detail::pointer_upcast(get_data(), from_class, to_class)); + const T* to_ptr = static_cast(detail::pointer_upcast(registry, get_data(), from_class, to_class)); return to_ptr; } } diff --git a/develop/untests/meta_features/diamond_tests.cpp b/develop/untests/meta_features/diamond_tests.cpp index f077e0d..51d1312 100644 --- a/develop/untests/meta_features/diamond_tests.cpp +++ b/develop/untests/meta_features/diamond_tests.cpp @@ -29,6 +29,10 @@ namespace TEST_CASE("meta/meta_features/diamond") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::uinst; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; meta::class_(); meta::class_().base_(); @@ -120,43 +124,43 @@ TEST_CASE("meta/meta_features/diamond") { using meta::detail::pointer_upcast; { A 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)); + CHECK(pointer_upcast(r, &a) == &a); + CHECK_FALSE(pointer_upcast(r, &a)); + CHECK_FALSE(pointer_upcast(r, &a)); + CHECK_FALSE(pointer_upcast(r, &a)); + CHECK_FALSE(pointer_upcast(r, &a)); } { 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)); + CHECK(pointer_upcast(r, &b) == &b); + CHECK(pointer_upcast(r, &b) == &b); + CHECK_FALSE(pointer_upcast(r, &b)); + CHECK_FALSE(pointer_upcast(r, &b)); + CHECK_FALSE(pointer_upcast(r, &b)); } { C 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)); + CHECK(pointer_upcast(r, &c) == &c); + CHECK_FALSE(pointer_upcast(r, &c)); + CHECK(pointer_upcast(r, &c) == &c); + CHECK_FALSE(pointer_upcast(r, &c)); + CHECK_FALSE(pointer_upcast(r, &c)); } { 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)); + CHECK(pointer_upcast(r, &d) == &d); + CHECK(pointer_upcast(r, &d) == &d); + CHECK(pointer_upcast(r, &d) == &d); + CHECK(pointer_upcast(r, &d) == &d); + CHECK_FALSE(pointer_upcast(r, &d)); } { 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); + CHECK_FALSE(pointer_upcast(r, &e)); + CHECK_FALSE(pointer_upcast(r, &e)); + CHECK_FALSE(pointer_upcast(r, &e)); + CHECK_FALSE(pointer_upcast(r, &e)); + CHECK(pointer_upcast(r, &e) == &e); } } @@ -166,155 +170,155 @@ TEST_CASE("meta/meta_features/diamond") { meta::uvalue a_val{&a}; CHECK(*static_cast(a_val.get_data()) == &a); - meta::detail::uarg a_arg{a_val}; + uarg a_arg{r, a_val}; - CHECK(a_arg.can_cast_to()); - CHECK(!a_arg.can_cast_to()); - CHECK(!a_arg.can_cast_to()); - CHECK(!a_arg.can_cast_to()); - CHECK(!a_arg.can_cast_to()); + CHECK(a_arg.can_cast_to(r)); + CHECK(!a_arg.can_cast_to(r)); + CHECK(!a_arg.can_cast_to(r)); + CHECK(!a_arg.can_cast_to(r)); + CHECK(!a_arg.can_cast_to(r)); - CHECK(a_arg.cast() == static_cast(&a)); + CHECK(a_arg.cast(r) == static_cast(&a)); } { B b; meta::uvalue b_val{&b}; CHECK(*static_cast(b_val.get_data()) == &b); - meta::detail::uarg b_arg{b_val}; + uarg b_arg{r, b_val}; - CHECK(b_arg.can_cast_to()); - CHECK(b_arg.can_cast_to()); - CHECK(!b_arg.can_cast_to()); - CHECK(!b_arg.can_cast_to()); - CHECK(!b_arg.can_cast_to()); + CHECK(b_arg.can_cast_to(r)); + CHECK(b_arg.can_cast_to(r)); + CHECK(!b_arg.can_cast_to(r)); + CHECK(!b_arg.can_cast_to(r)); + CHECK(!b_arg.can_cast_to(r)); - CHECK(b_arg.cast() == static_cast(&b)); - CHECK(b_arg.cast() == static_cast(&b)); + CHECK(b_arg.cast(r) == static_cast(&b)); + CHECK(b_arg.cast(r) == static_cast(&b)); } { C c; meta::uvalue c_val{&c}; CHECK(*static_cast(c_val.get_data()) == &c); - meta::detail::uarg c_arg{c_val}; + uarg c_arg{r, c_val}; - CHECK(c_arg.can_cast_to()); - CHECK(!c_arg.can_cast_to()); - CHECK(c_arg.can_cast_to()); - CHECK(!c_arg.can_cast_to()); - CHECK(!c_arg.can_cast_to()); + CHECK(c_arg.can_cast_to(r)); + CHECK(!c_arg.can_cast_to(r)); + CHECK(c_arg.can_cast_to(r)); + CHECK(!c_arg.can_cast_to(r)); + CHECK(!c_arg.can_cast_to(r)); - CHECK(c_arg.cast() == static_cast(&c)); - CHECK(c_arg.cast() == static_cast(&c)); + CHECK(c_arg.cast(r) == static_cast(&c)); + CHECK(c_arg.cast(r) == static_cast(&c)); } { D d; meta::uvalue d_val{&d}; CHECK(*static_cast(d_val.get_data()) == &d); - meta::detail::uarg d_arg{d_val}; + uarg d_arg{r, d_val}; - CHECK(d_arg.can_cast_to()); - CHECK(d_arg.can_cast_to()); - CHECK(d_arg.can_cast_to()); - CHECK(d_arg.can_cast_to()); - CHECK(!d_arg.can_cast_to()); + CHECK(d_arg.can_cast_to(r)); + CHECK(d_arg.can_cast_to(r)); + CHECK(d_arg.can_cast_to(r)); + CHECK(d_arg.can_cast_to(r)); + CHECK(!d_arg.can_cast_to(r)); - CHECK(d_arg.cast() == static_cast(&d)); - CHECK(d_arg.cast() == static_cast(&d)); - CHECK(d_arg.cast() == static_cast(&d)); - CHECK(d_arg.cast() == static_cast(&d)); + CHECK(d_arg.cast(r) == static_cast(&d)); + CHECK(d_arg.cast(r) == static_cast(&d)); + CHECK(d_arg.cast(r) == static_cast(&d)); + CHECK(d_arg.cast(r) == static_cast(&d)); } { E e; meta::uvalue e_val{&e}; CHECK(*static_cast(e_val.get_data()) == &e); - meta::detail::uarg e_arg{e_val}; + uarg e_arg{r, e_val}; - CHECK(!e_arg.can_cast_to()); - CHECK(!e_arg.can_cast_to()); - CHECK(!e_arg.can_cast_to()); - CHECK(!e_arg.can_cast_to()); - CHECK(e_arg.can_cast_to()); + CHECK(!e_arg.can_cast_to(r)); + CHECK(!e_arg.can_cast_to(r)); + CHECK(!e_arg.can_cast_to(r)); + CHECK(!e_arg.can_cast_to(r)); + CHECK(e_arg.can_cast_to(r)); - CHECK(e_arg.cast() == static_cast(&e)); + CHECK(e_arg.cast(r) == static_cast(&e)); } } SUBCASE("inst/cast") { { meta::uvalue a_val{A{}}; - meta::detail::uinst a_inst{a_val}; + uinst a_inst{r, a_val}; - CHECK(a_inst.can_cast_to()); - CHECK_FALSE(a_inst.can_cast_to()); - CHECK_FALSE(a_inst.can_cast_to()); - CHECK_FALSE(a_inst.can_cast_to()); - CHECK_FALSE(a_inst.can_cast_to()); + CHECK(a_inst.can_cast_to(r)); + CHECK_FALSE(a_inst.can_cast_to(r)); + CHECK_FALSE(a_inst.can_cast_to(r)); + CHECK_FALSE(a_inst.can_cast_to(r)); + CHECK_FALSE(a_inst.can_cast_to(r)); - CHECK(&a_inst.cast() == &a_val.get_as()); + CHECK(&a_inst.cast(r) == &a_val.get_as()); } { meta::uvalue b_val{B{}}; - meta::detail::uinst b_inst{b_val}; + uinst b_inst{r, b_val}; - CHECK(b_inst.can_cast_to()); - CHECK(b_inst.can_cast_to()); - CHECK_FALSE(b_inst.can_cast_to()); - CHECK_FALSE(b_inst.can_cast_to()); - CHECK_FALSE(b_inst.can_cast_to()); + CHECK(b_inst.can_cast_to(r)); + CHECK(b_inst.can_cast_to(r)); + CHECK_FALSE(b_inst.can_cast_to(r)); + CHECK_FALSE(b_inst.can_cast_to(r)); + CHECK_FALSE(b_inst.can_cast_to(r)); - CHECK(&b_inst.cast() == &b_val.get_as()); - CHECK(&b_inst.cast() == &b_val.get_as()); + CHECK(&b_inst.cast(r) == &b_val.get_as()); + CHECK(&b_inst.cast(r) == &b_val.get_as()); - CHECK(&b_inst.cast() == &b_val.get_as()); + CHECK(&b_inst.cast(r) == &b_val.get_as()); } { meta::uvalue c_val{C{}}; - meta::detail::uinst c_inst{c_val}; + uinst c_inst{r, c_val}; - CHECK(c_inst.can_cast_to()); - CHECK_FALSE(c_inst.can_cast_to()); - CHECK(c_inst.can_cast_to()); - CHECK_FALSE(c_inst.can_cast_to()); - CHECK_FALSE(c_inst.can_cast_to()); + CHECK(c_inst.can_cast_to(r)); + CHECK_FALSE(c_inst.can_cast_to(r)); + CHECK(c_inst.can_cast_to(r)); + CHECK_FALSE(c_inst.can_cast_to(r)); + CHECK_FALSE(c_inst.can_cast_to(r)); - CHECK(&c_inst.cast() == &c_val.get_as()); - CHECK(&c_inst.cast() == &c_val.get_as()); + CHECK(&c_inst.cast(r) == &c_val.get_as()); + CHECK(&c_inst.cast(r) == &c_val.get_as()); } { meta::uvalue d_val{D{}}; - meta::detail::uinst d_inst{d_val}; + uinst d_inst{r, d_val}; - CHECK(d_inst.can_cast_to()); - CHECK(d_inst.can_cast_to()); - CHECK(d_inst.can_cast_to()); - CHECK(d_inst.can_cast_to()); - CHECK_FALSE(d_inst.can_cast_to()); + CHECK(d_inst.can_cast_to(r)); + CHECK(d_inst.can_cast_to(r)); + CHECK(d_inst.can_cast_to(r)); + CHECK(d_inst.can_cast_to(r)); + CHECK_FALSE(d_inst.can_cast_to(r)); - CHECK(&d_inst.cast() == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); - CHECK(&d_inst.cast() == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); + CHECK(&d_inst.cast(r) == &d_val.get_as()); } { meta::uvalue e_val{E{}}; - meta::detail::uinst e_inst{e_val}; + uinst e_inst{r, e_val}; - CHECK_FALSE(e_inst.can_cast_to()); - CHECK_FALSE(e_inst.can_cast_to()); - CHECK_FALSE(e_inst.can_cast_to()); - CHECK_FALSE(e_inst.can_cast_to()); - CHECK(e_inst.can_cast_to()); + CHECK_FALSE(e_inst.can_cast_to(r)); + CHECK_FALSE(e_inst.can_cast_to(r)); + CHECK_FALSE(e_inst.can_cast_to(r)); + CHECK_FALSE(e_inst.can_cast_to(r)); + CHECK(e_inst.can_cast_to(r)); - CHECK(&e_inst.cast() == &e_val.get_as()); + CHECK(&e_inst.cast(r) == &e_val.get_as()); } } diff --git a/develop/untests/meta_utilities/arg2_tests.cpp b/develop/untests/meta_utilities/arg2_tests.cpp index 2bf9c26..ea2b513 100644 --- a/develop/untests/meta_utilities/arg2_tests.cpp +++ b/develop/untests/meta_utilities/arg2_tests.cpp @@ -61,6 +61,8 @@ TEST_CASE("meta/meta_utilities/arg2") { TEST_CASE("meta/meta_utilities/arg2/cast") { namespace meta = meta_hpp; using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; auto LV = []() -> D& { static D v; return v; }; auto CLV = []() -> const D& { static D v; return v; }; @@ -100,254 +102,254 @@ TEST_CASE("meta/meta_utilities/arg2/cast") { A::move_ctors_ = 0; SUBCASE("LV") { - CHECK(uarg{LV()}.can_cast_to()); - CHECK(uarg{LV()}.can_cast_to()); - CHECK(uarg{LV()}.can_cast_to()); - CHECK(uarg{LV()}.can_cast_to()); - CHECK_FALSE(uarg{LV()}.can_cast_to()); - CHECK_FALSE(uarg{LV()}.can_cast_to()); + CHECK(uarg{r, LV()}.can_cast_to(r)); + CHECK(uarg{r, LV()}.can_cast_to(r)); + CHECK(uarg{r, LV()}.can_cast_to(r)); + CHECK(uarg{r, LV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, LV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, LV()}.can_cast_to(r)); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 0); - CHECK(uarg{LV()}.cast().f() == 1); - CHECK(uarg{LV()}.cast().f() == 1); - CHECK(uarg{LV()}.cast().f() == 1); - CHECK(uarg{LV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{LV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{LV()}.cast()); + CHECK(uarg{r, LV()}.cast(r).f() == 1); + CHECK(uarg{r, LV()}.cast(r).f() == 1); + CHECK(uarg{r, LV()}.cast(r).f() == 1); + CHECK(uarg{r, LV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, LV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, LV()}.cast(r)); CHECK(A::copy_ctors_ == 2); CHECK(A::move_ctors_ == 0); } SUBCASE("CLV") { - CHECK(uarg{CLV()}.can_cast_to()); - CHECK(uarg{CLV()}.can_cast_to()); - CHECK_FALSE(uarg{CLV()}.can_cast_to()); - CHECK(uarg{CLV()}.can_cast_to()); - CHECK_FALSE(uarg{CLV()}.can_cast_to()); - CHECK_FALSE(uarg{CLV()}.can_cast_to()); + CHECK(uarg{r, CLV()}.can_cast_to(r)); + CHECK(uarg{r, CLV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CLV()}.can_cast_to(r)); + CHECK(uarg{r, CLV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CLV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CLV()}.can_cast_to(r)); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 0); - CHECK(uarg{CLV()}.cast().f() == 1); - CHECK(uarg{CLV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{CLV()}.cast()); - CHECK(uarg{CLV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{CLV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CLV()}.cast()); + CHECK(uarg{r, CLV()}.cast(r).f() == 1); + CHECK(uarg{r, CLV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast(r)); + CHECK(uarg{r, CLV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast(r)); CHECK(A::copy_ctors_ == 2); CHECK(A::move_ctors_ == 0); } SUBCASE("XV") { - CHECK(uarg{XV()}.can_cast_to()); - CHECK(uarg{XV()}.can_cast_to()); - CHECK_FALSE(uarg{XV()}.can_cast_to()); - CHECK(uarg{XV()}.can_cast_to()); - CHECK(uarg{XV()}.can_cast_to()); - CHECK(uarg{XV()}.can_cast_to()); + CHECK(uarg{r, XV()}.can_cast_to(r)); + CHECK(uarg{r, XV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, XV()}.can_cast_to(r)); + CHECK(uarg{r, XV()}.can_cast_to(r)); + CHECK(uarg{r, XV()}.can_cast_to(r)); + CHECK(uarg{r, XV()}.can_cast_to(r)); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 0); - CHECK(uarg{XV()}.cast().f() == 1); - CHECK(uarg{XV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{XV()}.cast()); - CHECK(uarg{XV()}.cast().f() == 1); - CHECK(uarg{XV()}.cast().f() == 1); - CHECK(uarg{XV()}.cast().f() == 1); + CHECK(uarg{r, XV()}.cast(r).f() == 1); + CHECK(uarg{r, XV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, XV()}.cast(r)); + CHECK(uarg{r, XV()}.cast(r).f() == 1); + CHECK(uarg{r, XV()}.cast(r).f() == 1); + CHECK(uarg{r, XV()}.cast(r).f() == 1); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 2); } SUBCASE("CXV") { - CHECK(uarg{CXV()}.can_cast_to()); - CHECK(uarg{CXV()}.can_cast_to()); - CHECK_FALSE(uarg{CXV()}.can_cast_to()); - CHECK(uarg{CXV()}.can_cast_to()); - CHECK_FALSE(uarg{CXV()}.can_cast_to()); - CHECK(uarg{CXV()}.can_cast_to()); + CHECK(uarg{r, CXV()}.can_cast_to(r)); + CHECK(uarg{r, CXV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CXV()}.can_cast_to(r)); + CHECK(uarg{r, CXV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CXV()}.can_cast_to(r)); + CHECK(uarg{r, CXV()}.can_cast_to(r)); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 0); - CHECK(uarg{CXV()}.cast().f() == 1); - CHECK(uarg{CXV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{CXV()}.cast()); - CHECK(uarg{CXV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{CXV()}.cast()); - CHECK(uarg{CXV()}.cast().f() == 1); + CHECK(uarg{r, CXV()}.cast(r).f() == 1); + CHECK(uarg{r, CXV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast(r)); + CHECK(uarg{r, CXV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast(r)); + CHECK(uarg{r, CXV()}.cast(r).f() == 1); CHECK(A::copy_ctors_ == 2); CHECK(A::move_ctors_ == 0); } SUBCASE("PRV") { - CHECK(uarg{PRV()}.can_cast_to()); - CHECK(uarg{PRV()}.can_cast_to()); - CHECK_FALSE(uarg{PRV()}.can_cast_to()); - CHECK(uarg{PRV()}.can_cast_to()); - CHECK(uarg{PRV()}.can_cast_to()); - CHECK(uarg{PRV()}.can_cast_to()); + CHECK(uarg{r, PRV()}.can_cast_to(r)); + CHECK(uarg{r, PRV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, PRV()}.can_cast_to(r)); + CHECK(uarg{r, PRV()}.can_cast_to(r)); + CHECK(uarg{r, PRV()}.can_cast_to(r)); + CHECK(uarg{r, PRV()}.can_cast_to(r)); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 0); - CHECK(uarg{PRV()}.cast().f() == 1); - CHECK(uarg{PRV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{PRV()}.cast()); - CHECK(uarg{PRV()}.cast().f() == 1); - CHECK(uarg{PRV()}.cast().f() == 1); - CHECK(uarg{PRV()}.cast().f() == 1); + CHECK(uarg{r, PRV()}.cast(r).f() == 1); + CHECK(uarg{r, PRV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, PRV()}.cast(r)); + CHECK(uarg{r, PRV()}.cast(r).f() == 1); + CHECK(uarg{r, PRV()}.cast(r).f() == 1); + CHECK(uarg{r, PRV()}.cast(r).f() == 1); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 2); } SUBCASE("CPRV") { - CHECK(uarg{CPRV()}.can_cast_to()); - CHECK(uarg{CPRV()}.can_cast_to()); - CHECK_FALSE(uarg{CPRV()}.can_cast_to()); - CHECK(uarg{CPRV()}.can_cast_to()); - CHECK_FALSE(uarg{CPRV()}.can_cast_to()); - CHECK(uarg{CPRV()}.can_cast_to()); + CHECK(uarg{r, CPRV()}.can_cast_to(r)); + CHECK(uarg{r, CPRV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CPRV()}.can_cast_to(r)); + CHECK(uarg{r, CPRV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CPRV()}.can_cast_to(r)); + CHECK(uarg{r, CPRV()}.can_cast_to(r)); CHECK(A::copy_ctors_ == 0); CHECK(A::move_ctors_ == 0); - CHECK(uarg{CPRV()}.cast().f() == 1); - CHECK(uarg{CPRV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{CPRV()}.cast()); - CHECK(uarg{CPRV()}.cast().f() == 1); - // CHECK_THROWS(std::ignore = uarg{CPRV()}.cast()); - CHECK(uarg{CPRV()}.cast().f() == 1); + CHECK(uarg{r, CPRV()}.cast(r).f() == 1); + CHECK(uarg{r, CPRV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast(r)); + CHECK(uarg{r, CPRV()}.cast(r).f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast(r)); + CHECK(uarg{r, CPRV()}.cast(r).f() == 1); CHECK(A::copy_ctors_ == 2); CHECK(A::move_ctors_ == 0); } SUBCASE("LV_PTR") { - CHECK(uarg{LV_PTR()}.can_cast_to()); - CHECK(uarg{LV_PTR()}.can_cast_to()); - CHECK(uarg{LV_PTR()}.can_cast_to()); - CHECK(uarg{LV_PTR()}.can_cast_to()); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); - CHECK(uarg{LV_PTR()}.cast()->f() == 1); - CHECK(uarg{LV_PTR()}.cast()->f() == 1); - CHECK(uarg{LV_PTR()}.cast()->f() == 1); - CHECK(uarg{LV_PTR()}.cast()->f() == 1); + CHECK(uarg{r, LV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, LV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, LV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, LV_PTR()}.cast(r)->f() == 1); } SUBCASE("LV_CPTR") { - CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to()); - CHECK(uarg{LV_CPTR()}.can_cast_to()); - CHECK(uarg{LV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast()); - CHECK(uarg{LV_CPTR()}.cast()->f() == 1); - CHECK(uarg{LV_CPTR()}.cast()->f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast(r)); + CHECK(uarg{r, LV_CPTR()}.cast(r)->f() == 1); + CHECK(uarg{r, LV_CPTR()}.cast(r)->f() == 1); } SUBCASE("CLV_PTR") { - CHECK(uarg{CLV_PTR()}.can_cast_to()); - CHECK(uarg{CLV_PTR()}.can_cast_to()); - CHECK(uarg{CLV_PTR()}.can_cast_to()); - CHECK(uarg{CLV_PTR()}.can_cast_to()); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); - CHECK(uarg{CLV_PTR()}.cast()->f() == 1); - CHECK(uarg{CLV_PTR()}.cast()->f() == 1); - CHECK(uarg{CLV_PTR()}.cast()->f() == 1); - CHECK(uarg{CLV_PTR()}.cast()->f() == 1); + CHECK(uarg{r, CLV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CLV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CLV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CLV_PTR()}.cast(r)->f() == 1); } SUBCASE("CLV_CPTR") { - CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to()); - CHECK(uarg{CLV_CPTR()}.can_cast_to()); - CHECK(uarg{CLV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast()); - CHECK(uarg{CLV_CPTR()}.cast()->f() == 1); - CHECK(uarg{CLV_CPTR()}.cast()->f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast(r)); + CHECK(uarg{r, CLV_CPTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CLV_CPTR()}.cast(r)->f() == 1); } SUBCASE("XV_PTR") { - CHECK(uarg{XV_PTR()}.can_cast_to()); - CHECK(uarg{XV_PTR()}.can_cast_to()); - CHECK(uarg{XV_PTR()}.can_cast_to()); - CHECK(uarg{XV_PTR()}.can_cast_to()); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); - CHECK(uarg{XV_PTR()}.cast()->f() == 1); - CHECK(uarg{XV_PTR()}.cast()->f() == 1); - CHECK(uarg{XV_PTR()}.cast()->f() == 1); - CHECK(uarg{XV_PTR()}.cast()->f() == 1); + CHECK(uarg{r, XV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, XV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, XV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, XV_PTR()}.cast(r)->f() == 1); } SUBCASE("XV_CPTR") { - CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to()); - CHECK(uarg{XV_CPTR()}.can_cast_to()); - CHECK(uarg{XV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast()); - CHECK(uarg{XV_CPTR()}.cast()->f() == 1); - CHECK(uarg{XV_CPTR()}.cast()->f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast(r)); + CHECK(uarg{r, XV_CPTR()}.cast(r)->f() == 1); + CHECK(uarg{r, XV_CPTR()}.cast(r)->f() == 1); } SUBCASE("CXV_PTR") { - CHECK(uarg{CXV_PTR()}.can_cast_to()); - CHECK(uarg{CXV_PTR()}.can_cast_to()); - CHECK(uarg{CXV_PTR()}.can_cast_to()); - CHECK(uarg{CXV_PTR()}.can_cast_to()); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); - CHECK(uarg{CXV_PTR()}.cast()->f() == 1); - CHECK(uarg{CXV_PTR()}.cast()->f() == 1); - CHECK(uarg{CXV_PTR()}.cast()->f() == 1); - CHECK(uarg{CXV_PTR()}.cast()->f() == 1); + CHECK(uarg{r, CXV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CXV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CXV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CXV_PTR()}.cast(r)->f() == 1); } SUBCASE("CXV_CPTR") { - CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to()); - CHECK(uarg{CXV_CPTR()}.can_cast_to()); - CHECK(uarg{CXV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast()); - CHECK(uarg{CXV_CPTR()}.cast()->f() == 1); - CHECK(uarg{CXV_CPTR()}.cast()->f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast(r)); + CHECK(uarg{r, CXV_CPTR()}.cast(r)->f() == 1); + CHECK(uarg{r, CXV_CPTR()}.cast(r)->f() == 1); } SUBCASE("PRV_PTR") { - CHECK(uarg{PRV_PTR()}.can_cast_to()); - CHECK(uarg{PRV_PTR()}.can_cast_to()); - CHECK(uarg{PRV_PTR()}.can_cast_to()); - CHECK(uarg{PRV_PTR()}.can_cast_to()); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); - CHECK(uarg{PRV_PTR()}.cast()->f() == 1); - CHECK(uarg{PRV_PTR()}.cast()->f() == 1); - CHECK(uarg{PRV_PTR()}.cast()->f() == 1); - CHECK(uarg{PRV_PTR()}.cast()->f() == 1); + CHECK(uarg{r, PRV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, PRV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, PRV_PTR()}.cast(r)->f() == 1); + CHECK(uarg{r, PRV_PTR()}.cast(r)->f() == 1); } SUBCASE("PRV_CPTR") { - CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to()); - CHECK(uarg{PRV_CPTR()}.can_cast_to()); - CHECK(uarg{PRV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast()); - CHECK(uarg{PRV_CPTR()}.cast()->f() == 1); - CHECK(uarg{PRV_CPTR()}.cast()->f() == 1); + // CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast(r)); + CHECK(uarg{r, PRV_CPTR()}.cast(r)->f() == 1); + CHECK(uarg{r, PRV_CPTR()}.cast(r)->f() == 1); } } diff --git a/develop/untests/meta_utilities/arg3_tests.cpp b/develop/untests/meta_utilities/arg3_tests.cpp index a228cd2..a96d670 100644 --- a/develop/untests/meta_utilities/arg3_tests.cpp +++ b/develop/untests/meta_utilities/arg3_tests.cpp @@ -54,6 +54,8 @@ TEST_CASE("meta/meta_utilities/arg3") { TEST_CASE("meta/meta_utilities/arg3/cast") { namespace meta = meta_hpp; using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; auto LV = []() -> D& { static D v; return v; }; auto CLV = []() -> const D& { static D v; return v; }; @@ -79,50 +81,50 @@ TEST_CASE("meta/meta_utilities/arg3/cast") { // *------------------------------------------------------------* SUBCASE("LV") { - CHECK_FALSE(uarg{LV()}.can_cast_to()); - CHECK_FALSE(uarg{LV()}.can_cast_to()); + CHECK_FALSE(uarg{r, LV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, LV()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{LV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{LV()}.cast()); + // CHECK_THROWS(std::ignore = uarg{r, LV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, LV()}.cast(r)); } SUBCASE("CLV") { - CHECK_FALSE(uarg{CLV()}.can_cast_to()); - CHECK_FALSE(uarg{CLV()}.can_cast_to()); + CHECK_FALSE(uarg{r, CLV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CLV()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CLV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CLV()}.cast()); + // CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CLV()}.cast(r)); } SUBCASE("XV") { - CHECK_FALSE(uarg{XV()}.can_cast_to()); - CHECK_FALSE(uarg{XV()}.can_cast_to()); + CHECK_FALSE(uarg{r, XV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, XV()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{XV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{XV()}.cast()); + // CHECK_THROWS(std::ignore = uarg{r, XV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, XV()}.cast(r)); } SUBCASE("CXV") { - CHECK_FALSE(uarg{CXV()}.can_cast_to()); - CHECK_FALSE(uarg{CXV()}.can_cast_to()); + CHECK_FALSE(uarg{r, CXV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CXV()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CXV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CXV()}.cast()); + // CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CXV()}.cast(r)); } SUBCASE("PRV") { - CHECK_FALSE(uarg{PRV()}.can_cast_to()); - CHECK_FALSE(uarg{PRV()}.can_cast_to()); + CHECK_FALSE(uarg{r, PRV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, PRV()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{PRV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{PRV()}.cast()); + // CHECK_THROWS(std::ignore = uarg{r, PRV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, PRV()}.cast(r)); } SUBCASE("CPRV") { - CHECK_FALSE(uarg{CPRV()}.can_cast_to()); - CHECK_FALSE(uarg{CPRV()}.can_cast_to()); + CHECK_FALSE(uarg{r, CPRV()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CPRV()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CPRV()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CPRV()}.cast()); + // CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CPRV()}.cast(r)); } } diff --git a/develop/untests/meta_utilities/arg4_tests.cpp b/develop/untests/meta_utilities/arg4_tests.cpp index 921c0f0..8858352 100644 --- a/develop/untests/meta_utilities/arg4_tests.cpp +++ b/develop/untests/meta_utilities/arg4_tests.cpp @@ -10,6 +10,8 @@ TEST_CASE("meta/meta_utilities/arg4/cast") { namespace meta = meta_hpp; using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; auto LV_PTR = []() -> int*& { static int v{42}; static int* p{&v}; return p; }; auto CLV_PTR = []() -> int* const& { static int v{42}; static int* p{&v}; return p; }; @@ -24,122 +26,122 @@ TEST_CASE("meta/meta_utilities/arg4/cast") { auto PRV_CPTR = []() -> const int* { static int v{42}; static const int* p{&v}; return p; }; SUBCASE("LV_PTR") { - CHECK(uarg{LV_PTR()}.can_cast_to()); - CHECK(uarg{LV_PTR()}.can_cast_to()); - CHECK(uarg{LV_PTR()}.can_cast_to()); - CHECK(uarg{LV_PTR()}.can_cast_to()); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_PTR()}.can_cast_to(r)); - CHECK(*uarg{LV_PTR()}.cast() == 42); - CHECK(*uarg{LV_PTR()}.cast() == 42); - CHECK(*uarg{LV_PTR()}.cast() == 42); - CHECK(*uarg{LV_PTR()}.cast() == 42); + CHECK(*uarg{r, LV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, LV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, LV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, LV_PTR()}.cast(r) == 42); } SUBCASE("CLV_PTR") { - CHECK(uarg{CLV_PTR()}.can_cast_to()); - CHECK(uarg{CLV_PTR()}.can_cast_to()); - CHECK(uarg{CLV_PTR()}.can_cast_to()); - CHECK(uarg{CLV_PTR()}.can_cast_to()); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_PTR()}.can_cast_to(r)); - CHECK(*uarg{CLV_PTR()}.cast() == 42); - CHECK(*uarg{CLV_PTR()}.cast() == 42); - CHECK(*uarg{CLV_PTR()}.cast() == 42); - CHECK(*uarg{CLV_PTR()}.cast() == 42); + CHECK(*uarg{r, CLV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, CLV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, CLV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, CLV_PTR()}.cast(r) == 42); } SUBCASE("XV_PTR") { - CHECK(uarg{XV_PTR()}.can_cast_to()); - CHECK(uarg{XV_PTR()}.can_cast_to()); - CHECK(uarg{XV_PTR()}.can_cast_to()); - CHECK(uarg{XV_PTR()}.can_cast_to()); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_PTR()}.can_cast_to(r)); - CHECK(*uarg{XV_PTR()}.cast() == 42); - CHECK(*uarg{XV_PTR()}.cast() == 42); - CHECK(*uarg{XV_PTR()}.cast() == 42); - CHECK(*uarg{XV_PTR()}.cast() == 42); + CHECK(*uarg{r, XV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, XV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, XV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, XV_PTR()}.cast(r) == 42); } SUBCASE("CXV_PTR") { - CHECK(uarg{CXV_PTR()}.can_cast_to()); - CHECK(uarg{CXV_PTR()}.can_cast_to()); - CHECK(uarg{CXV_PTR()}.can_cast_to()); - CHECK(uarg{CXV_PTR()}.can_cast_to()); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_PTR()}.can_cast_to(r)); - CHECK(*uarg{CXV_PTR()}.cast() == 42); - CHECK(*uarg{CXV_PTR()}.cast() == 42); - CHECK(*uarg{CXV_PTR()}.cast() == 42); - CHECK(*uarg{CXV_PTR()}.cast() == 42); + CHECK(*uarg{r, CXV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, CXV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, CXV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, CXV_PTR()}.cast(r) == 42); } SUBCASE("PRV_PTR") { - CHECK(uarg{PRV_PTR()}.can_cast_to()); - CHECK(uarg{PRV_PTR()}.can_cast_to()); - CHECK(uarg{PRV_PTR()}.can_cast_to()); - CHECK(uarg{PRV_PTR()}.can_cast_to()); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_PTR()}.can_cast_to(r)); - CHECK(*uarg{PRV_PTR()}.cast() == 42); - CHECK(*uarg{PRV_PTR()}.cast() == 42); - CHECK(*uarg{PRV_PTR()}.cast() == 42); - CHECK(*uarg{PRV_PTR()}.cast() == 42); + CHECK(*uarg{r, PRV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, PRV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, PRV_PTR()}.cast(r) == 42); + CHECK(*uarg{r, PRV_PTR()}.cast(r) == 42); } SUBCASE("LV_CPTR") { - CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{LV_CPTR()}.can_cast_to()); - CHECK(uarg{LV_CPTR()}.can_cast_to()); - CHECK(uarg{LV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, LV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, LV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{LV_CPTR()}.cast()); - CHECK(*uarg{LV_CPTR()}.cast() == 42); - CHECK(*uarg{LV_CPTR()}.cast() == 42); + // CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, LV_CPTR()}.cast(r)); + CHECK(*uarg{r, LV_CPTR()}.cast(r) == 42); + CHECK(*uarg{r, LV_CPTR()}.cast(r) == 42); } SUBCASE("CLV_CPTR") { - CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{CLV_CPTR()}.can_cast_to()); - CHECK(uarg{CLV_CPTR()}.can_cast_to()); - CHECK(uarg{CLV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CLV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CLV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CLV_CPTR()}.cast()); - CHECK(*uarg{CLV_CPTR()}.cast() == 42); - CHECK(*uarg{CLV_CPTR()}.cast() == 42); + // CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CLV_CPTR()}.cast(r)); + CHECK(*uarg{r, CLV_CPTR()}.cast(r) == 42); + CHECK(*uarg{r, CLV_CPTR()}.cast(r) == 42); } SUBCASE("XV_CPTR") { - CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{XV_CPTR()}.can_cast_to()); - CHECK(uarg{XV_CPTR()}.can_cast_to()); - CHECK(uarg{XV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, XV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, XV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{XV_CPTR()}.cast()); - CHECK(*uarg{XV_CPTR()}.cast() == 42); - CHECK(*uarg{XV_CPTR()}.cast() == 42); + // CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, XV_CPTR()}.cast(r)); + CHECK(*uarg{r, XV_CPTR()}.cast(r) == 42); + CHECK(*uarg{r, XV_CPTR()}.cast(r) == 42); } SUBCASE("CXV_CPTR") { - CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{CXV_CPTR()}.can_cast_to()); - CHECK(uarg{CXV_CPTR()}.can_cast_to()); - CHECK(uarg{CXV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, CXV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, CXV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{CXV_CPTR()}.cast()); - CHECK(*uarg{CXV_CPTR()}.cast() == 42); - CHECK(*uarg{CXV_CPTR()}.cast() == 42); + // CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, CXV_CPTR()}.cast(r)); + CHECK(*uarg{r, CXV_CPTR()}.cast(r) == 42); + CHECK(*uarg{r, CXV_CPTR()}.cast(r) == 42); } SUBCASE("PRV_CPTR") { - CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to()); - CHECK_FALSE(uarg{PRV_CPTR()}.can_cast_to()); - CHECK(uarg{PRV_CPTR()}.can_cast_to()); - CHECK(uarg{PRV_CPTR()}.can_cast_to()); + CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to(r)); + CHECK_FALSE(uarg{r, PRV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_CPTR()}.can_cast_to(r)); + CHECK(uarg{r, PRV_CPTR()}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast()); - // CHECK_THROWS(std::ignore = uarg{PRV_CPTR()}.cast()); - CHECK(*uarg{PRV_CPTR()}.cast() == 42); - CHECK(*uarg{PRV_CPTR()}.cast() == 42); + // CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast(r)); + // CHECK_THROWS(std::ignore = uarg{r, PRV_CPTR()}.cast(r)); + CHECK(*uarg{r, PRV_CPTR()}.cast(r) == 42); + CHECK(*uarg{r, PRV_CPTR()}.cast(r) == 42); } } diff --git a/develop/untests/meta_utilities/arg5_tests.cpp b/develop/untests/meta_utilities/arg5_tests.cpp index 1c27dd5..00c3d1d 100644 --- a/develop/untests/meta_utilities/arg5_tests.cpp +++ b/develop/untests/meta_utilities/arg5_tests.cpp @@ -50,85 +50,87 @@ TEST_CASE("meta/meta_utilities/arg5") { TEST_CASE("meta/meta_utilities/arg5/cast") { namespace meta = meta_hpp; using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; SUBCASE("int[2]") { int arr[2]{1,2}; - CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr)); + CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr)); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); - CHECK(uarg(arr).cast() == static_cast(arr)); - CHECK(uarg(arr).cast() == static_cast(arr)); - CHECK(uarg(arr).cast() == static_cast(arr)); - CHECK(uarg(arr).cast() == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); } SUBCASE("const int[2]") { const int arr[2]{1,2}; - CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr)); + CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr)); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK_FALSE(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); - CHECK_FALSE(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); + CHECK_FALSE(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK_FALSE(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg(arr).cast()); - CHECK(uarg(arr).cast() == static_cast(arr)); - // CHECK_THROWS(std::ignore = uarg(arr).cast()); - CHECK(uarg(arr).cast() == static_cast(arr)); + // CHECK_THROWS(std::ignore = uarg(r, arr).cast(r)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + // CHECK_THROWS(std::ignore = uarg(r, arr).cast(r)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); } SUBCASE("D[2]") { D arr[2]; - CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr)); + CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr)); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); - CHECK(uarg(arr).cast() == static_cast(arr)); - CHECK(uarg(arr).cast() == static_cast(arr)); - CHECK(uarg(arr).cast() == static_cast(arr)); - CHECK(uarg(arr).cast() == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); } SUBCASE("const D[2]") { const D arr[2]; - CHECK(uarg(arr).get_raw_type() == meta::resolve_type(arr)); + CHECK(uarg(r, arr).get_raw_type() == meta::resolve_type(arr)); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK_FALSE(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); - CHECK_FALSE(uarg(arr).can_cast_to()); - CHECK(uarg(arr).can_cast_to()); + CHECK_FALSE(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); + CHECK_FALSE(uarg(r, arr).can_cast_to(r)); + CHECK(uarg(r, arr).can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg(arr).cast()); - CHECK(uarg(arr).cast() == static_cast(arr)); - // CHECK_THROWS(std::ignore = uarg(arr).cast()); - CHECK(uarg(arr).cast() == static_cast(arr)); + // CHECK_THROWS(std::ignore = uarg(r, arr).cast(r)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); + // CHECK_THROWS(std::ignore = uarg(r, arr).cast(r)); + CHECK(uarg(r, arr).cast(r) == static_cast(arr)); } SUBCASE("&") { @@ -137,7 +139,7 @@ TEST_CASE("meta/meta_utilities/arg5/cast") { { auto LV = []() -> T& { return src; }; - CHECK(uarg{LV()}.get_raw_type() == meta::resolve_type()); + CHECK(uarg{r, LV()}.get_raw_type() == meta::resolve_type()); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); @@ -149,55 +151,55 @@ TEST_CASE("meta/meta_utilities/arg5/cast") { [](A* const){}(LV()); [](const A* const){}(LV()); - CHECK(uarg(LV()).cast() == static_cast(src)); - CHECK(uarg(LV()).cast() == static_cast(src)); - CHECK(uarg(LV()).cast() == static_cast(src)); - CHECK(uarg(LV()).cast() == static_cast(src)); + CHECK(uarg(r, LV()).cast(r) == static_cast(src)); + CHECK(uarg(r, LV()).cast(r) == static_cast(src)); + CHECK(uarg(r, LV()).cast(r) == static_cast(src)); + CHECK(uarg(r, LV()).cast(r) == static_cast(src)); } { auto CLV = []() -> const T& { return src; }; - CHECK(uarg{CLV()}.get_raw_type() == meta::resolve_type()); + CHECK(uarg{r, CLV()}.get_raw_type() == meta::resolve_type()); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - // CHECK_THROWS(std::ignore = uarg(CLV()).cast()); - CHECK(uarg(CLV()).cast() == static_cast(src)); - // CHECK_THROWS(std::ignore = uarg(CLV()).cast()); - CHECK(uarg(CLV()).cast() == static_cast(src)); + // CHECK_THROWS(std::ignore = uarg(r, CLV()).cast(r)); + CHECK(uarg(r, CLV()).cast(r) == static_cast(src)); + // CHECK_THROWS(std::ignore = uarg(r, CLV()).cast(r)); + CHECK(uarg(r, CLV()).cast(r) == static_cast(src)); } { auto XV = []() -> T&& { return std::move(src); }; - CHECK(uarg{XV()}.get_raw_type() == meta::resolve_type()); + CHECK(uarg{r, XV()}.get_raw_type() == meta::resolve_type()); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg(XV()).cast() == static_cast(src)); - CHECK(uarg(XV()).cast() == static_cast(src)); - CHECK(uarg(XV()).cast() == static_cast(src)); - CHECK(uarg(XV()).cast() == static_cast(src)); + CHECK(uarg(r, XV()).cast(r) == static_cast(src)); + CHECK(uarg(r, XV()).cast(r) == static_cast(src)); + CHECK(uarg(r, XV()).cast(r) == static_cast(src)); + CHECK(uarg(r, XV()).cast(r) == static_cast(src)); } { auto CXV = []() -> const T&& { return std::move(src); }; - CHECK(uarg{CXV()}.get_raw_type() == meta::resolve_type()); + CHECK(uarg{r, CXV()}.get_raw_type() == meta::resolve_type()); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - // CHECK_THROWS(std::ignore = uarg(CXV()).cast()); - CHECK(uarg(CXV()).cast() == static_cast(src)); - // CHECK_THROWS(std::ignore = uarg(CXV()).cast()); - CHECK(uarg(CXV()).cast() == static_cast(src)); + // CHECK_THROWS(std::ignore = uarg(r, CXV()).cast(r)); + CHECK(uarg(r, CXV()).cast(r) == static_cast(src)); + // CHECK_THROWS(std::ignore = uarg(r, CXV()).cast(r)); + CHECK(uarg(r, CXV()).cast(r) == static_cast(src)); } } @@ -212,19 +214,19 @@ TEST_CASE("meta/meta_utilities/arg5/cast") { static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg{arr}.can_cast_to()); - CHECK(uarg{arr}.can_cast_to()); - CHECK(uarg{&arr}.can_cast_to()); - CHECK(uarg{&arr}.can_cast_to()); - CHECK(uarg{&arr}.can_cast_to()); - CHECK(uarg{&arr}.can_cast_to()); + CHECK(uarg{r, arr}.can_cast_to(r)); + CHECK(uarg{r, arr}.can_cast_to(r)); + CHECK(uarg{r, &arr}.can_cast_to(r)); + CHECK(uarg{r, &arr}.can_cast_to(r)); + CHECK(uarg{r, &arr}.can_cast_to(r)); + CHECK(uarg{r, &arr}.can_cast_to(r)); - CHECK(&uarg{arr}.cast() == &arr); - CHECK(&uarg{arr}.cast() == &arr); - CHECK(uarg{&arr}.cast() == &arr); - CHECK(uarg{&arr}.cast() == &arr); - CHECK(uarg{&arr}.cast() == &arr); - CHECK(uarg{&arr}.cast() == &arr); + CHECK(&uarg{r, arr}.cast(r) == &arr); + CHECK(&uarg{r, arr}.cast(r) == &arr); + CHECK(uarg{r, &arr}.cast(r) == &arr); + CHECK(uarg{r, &arr}.cast(r) == &arr); + CHECK(uarg{r, &arr}.cast(r) == &arr); + CHECK(uarg{r, &arr}.cast(r) == &arr); } { @@ -237,19 +239,19 @@ TEST_CASE("meta/meta_utilities/arg5/cast") { static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK_FALSE(uarg{arr}.can_cast_to()); - CHECK(uarg{arr}.can_cast_to()); - CHECK_FALSE(uarg{&arr}.can_cast_to()); - CHECK(uarg{&arr}.can_cast_to()); - CHECK_FALSE(uarg{&arr}.can_cast_to()); - CHECK(uarg{&arr}.can_cast_to()); + CHECK_FALSE(uarg{r, arr}.can_cast_to(r)); + CHECK(uarg{r, arr}.can_cast_to(r)); + CHECK_FALSE(uarg{r, &arr}.can_cast_to(r)); + CHECK(uarg{r, &arr}.can_cast_to(r)); + CHECK_FALSE(uarg{r, &arr}.can_cast_to(r)); + CHECK(uarg{r, &arr}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = &uarg{arr}.cast()); - CHECK(&uarg{arr}.cast() == &arr); - // CHECK_THROWS(std::ignore = uarg{&arr}.cast()); - CHECK(uarg{&arr}.cast() == &arr); - // CHECK_THROWS(std::ignore = uarg{&arr}.cast()); - CHECK(uarg{&arr}.cast() == &arr); + // CHECK_THROWS(std::ignore = &uarg{r, arr}.cast(r)); + CHECK(&uarg{r, arr}.cast(r) == &arr); + // CHECK_THROWS(std::ignore = uarg{r, &arr}.cast(r)); + CHECK(uarg{r, &arr}.cast(r) == &arr); + // CHECK_THROWS(std::ignore = uarg{r, &arr}.cast(r)); + CHECK(uarg{r, &arr}.cast(r) == &arr); } } } diff --git a/develop/untests/meta_utilities/arg7_tests.cpp b/develop/untests/meta_utilities/arg7_tests.cpp index 2e43ed0..0cc7745 100644 --- a/develop/untests/meta_utilities/arg7_tests.cpp +++ b/develop/untests/meta_utilities/arg7_tests.cpp @@ -50,6 +50,8 @@ TEST_CASE("meta/meta_utilities/arg7") { TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { namespace meta = meta_hpp; using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; SUBCASE("int* -> void*") { int i{42}; @@ -57,11 +59,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg{&i}.can_cast_to()); - CHECK(uarg{&i}.can_cast_to()); + CHECK(uarg{r, &i}.can_cast_to(r)); + CHECK(uarg{r, &i}.can_cast_to(r)); - CHECK(uarg{&i}.cast() == &i); - CHECK(uarg{&i}.cast() == &i); + CHECK(uarg{r, &i}.cast(r) == &i); + CHECK(uarg{r, &i}.cast(r) == &i); } SUBCASE("const int* -> void*") { @@ -70,11 +72,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK_FALSE(uarg{&i}.can_cast_to()); - CHECK(uarg{&i}.can_cast_to()); + CHECK_FALSE(uarg{r, &i}.can_cast_to(r)); + CHECK(uarg{r, &i}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{&i}.cast()); - CHECK(uarg{&i}.cast() == &i); + // CHECK_THROWS(std::ignore = uarg{r, &i}.cast(r)); + CHECK(uarg{r, &i}.cast(r) == &i); } SUBCASE("D* -> void*") { @@ -83,11 +85,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg{&d}.can_cast_to()); - CHECK(uarg{&d}.can_cast_to()); + CHECK(uarg{r, &d}.can_cast_to(r)); + CHECK(uarg{r, &d}.can_cast_to(r)); - CHECK(uarg{&d}.cast() == &d); - CHECK(uarg{&d}.cast() == &d); + CHECK(uarg{r, &d}.cast(r) == &d); + CHECK(uarg{r, &d}.cast(r) == &d); } SUBCASE("const D* -> void*") { @@ -96,11 +98,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK_FALSE(uarg{&d}.can_cast_to()); - CHECK(uarg{&d}.can_cast_to()); + CHECK_FALSE(uarg{r, &d}.can_cast_to(r)); + CHECK(uarg{r, &d}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{&d}.cast()); - CHECK(uarg{&d}.cast() == &d); + // CHECK_THROWS(std::ignore = uarg{r, &d}.cast(r)); + CHECK(uarg{r, &d}.cast(r) == &d); } SUBCASE("D[2] -> void*") { @@ -109,11 +111,11 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { static_assert(std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK(uarg{arr}.can_cast_to()); - CHECK(uarg{arr}.can_cast_to()); + CHECK(uarg{r, arr}.can_cast_to(r)); + CHECK(uarg{r, arr}.can_cast_to(r)); - CHECK(uarg{arr}.cast() == &arr); - CHECK(uarg{arr}.cast() == &arr); + CHECK(uarg{r, arr}.cast(r) == &arr); + CHECK(uarg{r, arr}.cast(r) == &arr); } SUBCASE("const D[2] -> void*") { @@ -122,17 +124,19 @@ TEST_CASE("meta/meta_utilities/arg7/cast/to_void") { static_assert(!std::is_invocable_v); static_assert(std::is_invocable_v); - CHECK_FALSE(uarg{arr}.can_cast_to()); - CHECK(uarg{arr}.can_cast_to()); + CHECK_FALSE(uarg{r, arr}.can_cast_to(r)); + CHECK(uarg{r, arr}.can_cast_to(r)); - // CHECK_THROWS(std::ignore = uarg{arr}.cast()); - CHECK(uarg{arr}.cast() == &arr); + // CHECK_THROWS(std::ignore = uarg{r, arr}.cast(r)); + CHECK(uarg{r, arr}.cast(r) == &arr); } } TEST_CASE("meta/meta_utilities/arg7/cast/from_nullptr") { namespace meta = meta_hpp; using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; SUBCASE("nullptr -> *") { static_assert(std::is_invocable_v); @@ -152,46 +156,46 @@ TEST_CASE("meta/meta_utilities/arg7/cast/from_nullptr") { std::nullptr_t n1{nullptr}; const std::nullptr_t n2{nullptr}; - CHECK(uarg{n1}.can_cast_to()); - CHECK(uarg{std::move(n1)}.can_cast_to()); - CHECK(uarg{n2}.can_cast_to()); - CHECK(uarg{std::move(n2)}.can_cast_to()); + CHECK(uarg{r, n1}.can_cast_to(r)); + CHECK(uarg{r, std::move(n1)}.can_cast_to(r)); + CHECK(uarg{r, n2}.can_cast_to(r)); + CHECK(uarg{r, std::move(n2)}.can_cast_to(r)); - CHECK(uarg{n1}.can_cast_to()); - CHECK(uarg{std::move(n1)}.can_cast_to()); - CHECK(uarg{n2}.can_cast_to()); - CHECK(uarg{std::move(n2)}.can_cast_to()); + CHECK(uarg{r, n1}.can_cast_to(r)); + CHECK(uarg{r, std::move(n1)}.can_cast_to(r)); + CHECK(uarg{r, n2}.can_cast_to(r)); + CHECK(uarg{r, std::move(n2)}.can_cast_to(r)); - CHECK(uarg{n1}.can_cast_to()); - CHECK(uarg{std::move(n1)}.can_cast_to()); - CHECK(uarg{n2}.can_cast_to()); - CHECK(uarg{std::move(n2)}.can_cast_to()); + CHECK(uarg{r, n1}.can_cast_to(r)); + CHECK(uarg{r, std::move(n1)}.can_cast_to(r)); + CHECK(uarg{r, n2}.can_cast_to(r)); + CHECK(uarg{r, std::move(n2)}.can_cast_to(r)); - CHECK(uarg{n1}.can_cast_to()); - CHECK(uarg{std::move(n1)}.can_cast_to()); - CHECK(uarg{n2}.can_cast_to()); - CHECK(uarg{std::move(n2)}.can_cast_to()); + CHECK(uarg{r, n1}.can_cast_to(r)); + CHECK(uarg{r, std::move(n1)}.can_cast_to(r)); + CHECK(uarg{r, n2}.can_cast_to(r)); + CHECK(uarg{r, std::move(n2)}.can_cast_to(r)); // - CHECK(uarg{n1}.cast() == nullptr); - CHECK(uarg{std::move(n1)}.cast() == nullptr); - CHECK(uarg{n2}.cast() == nullptr); - CHECK(uarg{std::move(n2)}.cast() == nullptr); + CHECK(uarg{r, n1}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n1)}.cast(r) == nullptr); + CHECK(uarg{r, n2}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n2)}.cast(r) == nullptr); - CHECK(uarg{n1}.cast() == nullptr); - CHECK(uarg{std::move(n1)}.cast() == nullptr); - CHECK(uarg{n2}.cast() == nullptr); - CHECK(uarg{std::move(n2)}.cast() == nullptr); + CHECK(uarg{r, n1}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n1)}.cast(r) == nullptr); + CHECK(uarg{r, n2}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n2)}.cast(r) == nullptr); - CHECK(uarg{n1}.cast() == nullptr); - CHECK(uarg{std::move(n1)}.cast() == nullptr); - CHECK(uarg{n2}.cast() == nullptr); - CHECK(uarg{std::move(n2)}.cast() == nullptr); + CHECK(uarg{r, n1}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n1)}.cast(r) == nullptr); + CHECK(uarg{r, n2}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n2)}.cast(r) == nullptr); - CHECK(uarg{n1}.cast() == nullptr); - CHECK(uarg{std::move(n1)}.cast() == nullptr); - CHECK(uarg{n2}.cast() == nullptr); - CHECK(uarg{std::move(n2)}.cast() == nullptr); + CHECK(uarg{r, n1}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n1)}.cast(r) == nullptr); + CHECK(uarg{r, n2}.cast(r) == nullptr); + CHECK(uarg{r, std::move(n2)}.cast(r) == nullptr); } } diff --git a/develop/untests/meta_utilities/arg_tests.cpp b/develop/untests/meta_utilities/arg_tests.cpp index ace207c..d7d71fc 100644 --- a/develop/untests/meta_utilities/arg_tests.cpp +++ b/develop/untests/meta_utilities/arg_tests.cpp @@ -74,16 +74,16 @@ namespace meta::function f_state{function_state::make("", function_ptr, {})};\ \ if ( std::is_invocable_v ) {\ - CHECK(uarg{FromValue}.can_cast_to());\ - CHECK(uarg_base{type_list{}}.can_cast_to());\ - std::ignore = uarg{FromValue}.cast();\ + CHECK(uarg{r, FromValue}.can_cast_to(r));\ + CHECK(uarg_base{r, type_list{}}.can_cast_to(r));\ + std::ignore = uarg{r, FromValue}.cast(r);\ \ CHECK(f_state.is_invocable_with());\ CHECK(f_state.invoke(FromValue).get_as() == 1);\ } else {\ - CHECK_FALSE(uarg{FromValue}.can_cast_to());\ - CHECK_FALSE(uarg_base{type_list{}}.can_cast_to());\ - /*CHECK_THROWS(std::ignore = uarg{FromValue}.cast());*/\ + CHECK_FALSE(uarg{r, FromValue}.can_cast_to(r));\ + CHECK_FALSE(uarg_base{r, type_list{}}.can_cast_to(r));\ + /*CHECK_THROWS(std::ignore = uarg{r, FromValue}.cast(r));*/\ \ CHECK_FALSE(f_state.is_invocable_with());\ CHECK_FALSE(f_state.safe_invoke(FromValue));\ @@ -118,6 +118,9 @@ TEST_CASE("meta/meta_utilities/arg") { TEST_CASE("meta/meta_utilities/arg/refs") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; { // lvalue @@ -125,9 +128,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { auto LV2 = []() -> dclazz& { static dclazz v; return v; }; auto LV3 = []() -> int& { static int v{1}; return v; }; - meta::detail::uarg a{LV()}; + uarg a{r, LV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE(LV(), f1, clazz) META_HPP_CHECK_INVOCABLE(LV(), f2, const clazz) @@ -157,9 +160,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { auto CLV2 = []() -> const dclazz& { static dclazz v; return v; }; auto CLV3 = []() -> const int& { static int v{1}; return v; }; - meta::detail::uarg a{CLV()}; + uarg a{r, CLV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE(CLV(), f1, clazz) META_HPP_CHECK_INVOCABLE(CLV(), f2, const clazz) @@ -189,9 +192,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { auto XV2 = []() -> dclazz&& { static dclazz v; return std::move(v); }; auto XV3 = []() -> int&& { static int v{1}; return std::move(v); }; - meta::detail::uarg a{XV()}; + uarg a{r, XV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE(XV(), f1, clazz) META_HPP_CHECK_INVOCABLE(XV(), f2, const clazz) @@ -221,9 +224,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { auto CXV2 = []() -> const dclazz&& { static dclazz v; return std::move(v); }; auto CXV3 = []() -> const int&& { static int v{1}; return std::move(v); }; - meta::detail::uarg a{CXV()}; + uarg a{r, CXV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE(CXV(), f1, clazz) META_HPP_CHECK_INVOCABLE(CXV(), f2, const clazz) @@ -253,9 +256,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { auto PRV2 = []() -> dclazz { return dclazz{}; }; auto PRV3 = []() -> int { return int{1}; }; - meta::detail::uarg a{PRV()}; + uarg a{r, PRV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE(PRV(), f1, clazz) META_HPP_CHECK_INVOCABLE(PRV(), f2, const clazz) @@ -284,9 +287,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { auto CPRV = []() -> const clazz { return clazz{}; }; auto CPRV2 = []() -> const dclazz { return dclazz{}; }; - meta::detail::uarg a{CPRV()}; + uarg a{r, CPRV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE(CPRV(), f1, clazz) META_HPP_CHECK_INVOCABLE(CPRV(), f2, const clazz) @@ -306,6 +309,9 @@ TEST_CASE("meta/meta_utilities/arg/refs") { TEST_CASE("meta/meta_utilities/arg/ptrs") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; { // lvalue @@ -314,9 +320,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto LV2_PTR = []() -> dclazz*& { static dclazz v; static dclazz* p{&v}; return p; }; auto LV3_PTR = []() -> int*& { static int v{1}; static int* p{&v}; return p; }; - meta::detail::uarg a{LV_PTR()}; + uarg a{r, LV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE(LV_PTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(LV_PTR(), f2, clazz* const) @@ -365,9 +371,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto LV2_CPTR = []() -> const dclazz*& { static dclazz v; static const dclazz* p{&v}; return p; }; auto LV3_CPTR = []() -> const int*& { static int v{1}; static const int* p{&v}; return p; }; - meta::detail::uarg a{LV_CPTR()}; + uarg a{r, LV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE(LV_CPTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(LV_CPTR(), f2, clazz* const) @@ -420,9 +426,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto CLV2_PTR = []() -> dclazz* const& { static dclazz v; static dclazz* p{&v}; return p; }; auto CLV3_PTR = []() -> int* const& { static int v{1}; static int* p{&v}; return p; }; - meta::detail::uarg a{CLV_PTR()}; + uarg a{r, CLV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE(CLV_PTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(CLV_PTR(), f2, clazz* const) @@ -471,9 +477,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto CLV2_CPTR = []() -> const dclazz* const& { static dclazz v; static const dclazz* p{&v}; return p; }; auto CLV3_CPTR = []() -> const int* const& { static int v{1}; static const int* p{&v}; return p; }; - meta::detail::uarg a{CLV_CPTR()}; + uarg a{r, CLV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE(CLV_CPTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(CLV_CPTR(), f2, clazz* const) @@ -526,9 +532,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto XV2_PTR = []() -> dclazz*&& { static dclazz v; static dclazz* p{&v}; return std::move(p); }; auto XV3_PTR = []() -> int*&& { static int v{1}; static int* p{&v}; return std::move(p); }; - meta::detail::uarg a{XV_PTR()}; + uarg a{r, XV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE(XV_PTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(XV_PTR(), f2, clazz* const) @@ -577,9 +583,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto XV2_CPTR = []() -> const dclazz*&& { static dclazz v; static const dclazz* p{&v}; return std::move(p); }; auto XV3_CPTR = []() -> const int*&& { static int v{1}; static const int* p{&v}; return std::move(p); }; - meta::detail::uarg a{XV_CPTR()}; + uarg a{r, XV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE(XV_CPTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(XV_CPTR(), f2, clazz* const) @@ -632,9 +638,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto CXV2_PTR = []() -> dclazz* const&& { static dclazz v; static dclazz* p{&v}; return std::move(p); }; auto CXV3_PTR = []() -> int* const&& { static int v{1}; static int* p{&v}; return std::move(p); }; - meta::detail::uarg a{CXV_PTR()}; + uarg a{r, CXV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE(CXV_PTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(CXV_PTR(), f2, clazz* const) @@ -683,9 +689,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto CXV2_CPTR = []() -> const dclazz* const&& { static dclazz v; static const dclazz* p{&v}; return std::move(p); }; auto CXV3_CPTR = []() -> const int* const&& { static int v{1}; static const int* p{&v}; return std::move(p); }; - meta::detail::uarg a{CXV_CPTR()}; + uarg a{r, CXV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE(CXV_CPTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(CXV_CPTR(), f2, clazz* const) @@ -738,9 +744,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto PRV2_PTR = []() -> dclazz* { static dclazz v; static dclazz* p{&v}; return p; }; auto PRV3_PTR = []() -> int* { static int v{1}; static int* p{&v}; return p; }; - meta::detail::uarg a{PRV_PTR()}; + uarg a{r, PRV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE(PRV_PTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(PRV_PTR(), f2, clazz* const) @@ -789,9 +795,9 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { auto PRV2_CPTR = []() -> const dclazz* { static dclazz v; static const dclazz* p{&v}; return p; }; auto PRV3_CPTR = []() -> const int* { static int v{1}; static const int* p{&v}; return p; }; - meta::detail::uarg a{PRV_CPTR()}; + uarg a{r, PRV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE(PRV_CPTR(), f1, clazz*) META_HPP_CHECK_INVOCABLE(PRV_CPTR(), f2, clazz* const) @@ -840,15 +846,18 @@ TEST_CASE("meta/meta_utilities/arg/ptrs") { TEST_CASE("meta/meta_utilities/arg/values") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; { auto LV = []() -> meta::uvalue& { static meta::uvalue v{clazz{}}; return v; }; auto LV2 = []() -> meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; }; auto LV3 = []() -> meta::uvalue& { static meta::uvalue v{int{1}}; return v; }; - meta::detail::uarg a{LV()}; + uarg a{r, LV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE_2(LV(), f1, clazz&, clazz) META_HPP_CHECK_INVOCABLE_2(LV(), f2, clazz&, const clazz) @@ -877,9 +886,9 @@ TEST_CASE("meta/meta_utilities/arg/values") { auto CLV2 = []() -> const meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; }; auto CLV3 = []() -> const meta::uvalue& { static meta::uvalue v{int{1}}; return v; }; - meta::detail::uarg a{CLV()}; + uarg a{r, CLV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE_2(CLV(), f1, const clazz&, clazz) META_HPP_CHECK_INVOCABLE_2(CLV(), f2, const clazz&, const clazz) @@ -908,9 +917,9 @@ TEST_CASE("meta/meta_utilities/arg/values") { auto XV2 = []() -> meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); }; auto XV3 = []() -> meta::uvalue&& { static meta::uvalue v{int{1}}; return std::move(v); }; - meta::detail::uarg a{XV()}; + uarg a{r, XV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(XV(), f1, clazz&&, clazz) META_HPP_CHECK_INVOCABLE_2(XV(), f2, clazz&&, const clazz) @@ -939,9 +948,9 @@ TEST_CASE("meta/meta_utilities/arg/values") { auto CXV2 = []() -> const meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); }; auto CXV3 = []() -> const meta::uvalue&& { static meta::uvalue v{int{1}}; return std::move(v); }; - meta::detail::uarg a{CXV()}; + uarg a{r, CXV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CXV(), f1, const clazz&&, clazz) META_HPP_CHECK_INVOCABLE_2(CXV(), f2, const clazz&&, const clazz) @@ -970,9 +979,9 @@ TEST_CASE("meta/meta_utilities/arg/values") { auto PRV2 = []() -> meta::uvalue { return meta::uvalue{dclazz{}}; }; auto PRV3 = []() -> meta::uvalue { return meta::uvalue{int{1}}; }; - meta::detail::uarg a{PRV()}; + uarg a{r, PRV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(PRV(), f1, clazz, clazz) META_HPP_CHECK_INVOCABLE_2(PRV(), f2, clazz, const clazz) @@ -1001,9 +1010,9 @@ TEST_CASE("meta/meta_utilities/arg/values") { auto CPRV2 = []() -> const meta::uvalue { return meta::uvalue{dclazz{}}; }; auto CPRV3 = []() -> const meta::uvalue { return meta::uvalue{int{1}}; }; - meta::detail::uarg a{CPRV()}; + uarg a{r, CPRV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CPRV(), f1, const clazz, clazz) META_HPP_CHECK_INVOCABLE_2(CPRV(), f2, const clazz, const clazz) @@ -1030,14 +1039,17 @@ TEST_CASE("meta/meta_utilities/arg/values") { TEST_CASE("meta/meta_utilities/arg/ptr_values") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; { auto LV_PTR = []() -> meta::uvalue& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto LV2_PTR = []() -> meta::uvalue& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{LV_PTR()}; + uarg a{r, LV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE_2(LV_PTR(), f1, clazz*&, clazz*) META_HPP_CHECK_INVOCABLE_2(LV_PTR(), f2, clazz*&, clazz* const) @@ -1072,9 +1084,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto LV_CPTR = []() -> meta::uvalue& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto LV2_CPTR = []() -> meta::uvalue& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{LV_CPTR()}; + uarg a{r, LV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE_2(LV_CPTR(), f1, const clazz*&, clazz*) META_HPP_CHECK_INVOCABLE_2(LV_CPTR(), f2, const clazz*&, clazz* const) @@ -1109,9 +1121,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto CLV_PTR = []() -> const meta::uvalue& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto CLV2_PTR = []() -> const meta::uvalue& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{CLV_PTR()}; + uarg a{r, CLV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE_2(CLV_PTR(), f1, clazz* const&, clazz*) META_HPP_CHECK_INVOCABLE_2(CLV_PTR(), f2, clazz* const&, clazz* const) @@ -1146,9 +1158,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto CLV_CPTR = []() -> const meta::uvalue& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto CLV2_CPTR = []() -> const meta::uvalue& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{CLV_CPTR()}; + uarg a{r, CLV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE_2(CLV_CPTR(), f1, const clazz* const&, clazz*) META_HPP_CHECK_INVOCABLE_2(CLV_CPTR(), f2, const clazz* const&, clazz* const) @@ -1183,9 +1195,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto XV_PTR = []() -> meta::uvalue&& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; auto XV2_PTR = []() -> meta::uvalue&& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; - meta::detail::uarg a{XV_PTR()}; + uarg a{r, XV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(XV_PTR(), f1, clazz*&&, clazz*) META_HPP_CHECK_INVOCABLE_2(XV_PTR(), f2, clazz*&&, clazz* const) @@ -1220,9 +1232,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto XV_CPTR = []() -> meta::uvalue&& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; auto XV2_CPTR = []() -> meta::uvalue&& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; - meta::detail::uarg a{XV_CPTR()}; + uarg a{r, XV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(XV_CPTR(), f1, const clazz*&&, clazz*) META_HPP_CHECK_INVOCABLE_2(XV_CPTR(), f2, const clazz*&&, clazz* const) @@ -1257,9 +1269,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto CXV_PTR = []() -> const meta::uvalue&& { static clazz v; static clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; auto CXV2_PTR = []() -> const meta::uvalue&& { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; - meta::detail::uarg a{CXV_PTR()}; + uarg a{r, CXV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CXV_PTR(), f1, clazz* const&&, clazz*) META_HPP_CHECK_INVOCABLE_2(CXV_PTR(), f2, clazz* const&&, clazz* const) @@ -1294,9 +1306,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto CXV_CPTR = []() -> const meta::uvalue&& { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; auto CXV2_CPTR = []() -> const meta::uvalue&& { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{std::move(p)}; return std::move(vv); }; - meta::detail::uarg a{CXV_CPTR()}; + uarg a{r, CXV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CXV_CPTR(), f1, const clazz* const&&, clazz*) META_HPP_CHECK_INVOCABLE_2(CXV_CPTR(), f2, const clazz* const&&, clazz* const) @@ -1331,9 +1343,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto PRV_PTR = []() -> meta::uvalue { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto PRV2_PTR = []() -> meta::uvalue { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{PRV_PTR()}; + uarg a{r, PRV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(PRV_PTR(), f1, clazz*, clazz*) META_HPP_CHECK_INVOCABLE_2(PRV_PTR(), f2, clazz*, clazz* const) @@ -1368,9 +1380,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto PRV_CPTR = []() -> meta::uvalue { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto PRV2_CPTR = []() -> meta::uvalue { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{PRV_CPTR()}; + uarg a{r, PRV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(PRV_CPTR(), f1, const clazz*, clazz*) META_HPP_CHECK_INVOCABLE_2(PRV_CPTR(), f2, const clazz*, clazz* const) @@ -1405,9 +1417,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto CPRV_PTR = []() -> const meta::uvalue { static clazz v; static clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto CPRV2_PTR = []() -> const meta::uvalue { static dclazz v; static dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{CPRV_PTR()}; + uarg a{r, CPRV_PTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CPRV_PTR(), f1, clazz* const, clazz*) META_HPP_CHECK_INVOCABLE_2(CPRV_PTR(), f2, clazz* const, clazz* const) @@ -1442,9 +1454,9 @@ TEST_CASE("meta/meta_utilities/arg/ptr_values") { auto CPRV_CPTR = []() -> const meta::uvalue { static clazz v; static const clazz* p{&v}; static meta::uvalue vv{p}; return vv; }; auto CPRV2_CPTR = []() -> const meta::uvalue { static dclazz v; static const dclazz* p{&v}; static meta::uvalue vv{p}; return vv; }; - meta::detail::uarg a{CPRV_CPTR()}; + uarg a{r, CPRV_CPTR()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CPRV_CPTR(), f1, const clazz* const, clazz*) META_HPP_CHECK_INVOCABLE_2(CPRV_CPTR(), f2, const clazz* const, clazz* const) diff --git a/develop/untests/meta_utilities/inst_tests.cpp b/develop/untests/meta_utilities/inst_tests.cpp index 2c94aaf..c6af82e 100644 --- a/develop/untests/meta_utilities/inst_tests.cpp +++ b/develop/untests/meta_utilities/inst_tests.cpp @@ -34,16 +34,16 @@ namespace meta::method m_state{method_state::make("", method_ptr, {})};\ \ if ( std::is_invocable_v ) {\ - CHECK(uinst{Inst}.can_cast_to());\ - CHECK(uinst_base{type_list{}}.can_cast_to());\ - std::ignore = uinst{Inst}.cast();\ + CHECK(uinst{r, Inst}.can_cast_to(r));\ + CHECK(uinst_base{r, type_list{}}.can_cast_to(r));\ + std::ignore = uinst{r, Inst}.cast(r);\ \ CHECK(m_state.is_invocable_with());\ CHECK(m_state.invoke(Inst).get_as() == 1);\ } else {\ - CHECK_FALSE(uinst{Inst}.can_cast_to());\ - CHECK_FALSE(uinst_base{type_list{}}.can_cast_to());\ - /*CHECK_THROWS(std::ignore = uinst{Inst}.cast());*/\ + CHECK_FALSE(uinst{r, Inst}.can_cast_to(r));\ + CHECK_FALSE(uinst_base{r, type_list{}}.can_cast_to(r));\ + /*CHECK_THROWS(std::ignore = uinst{r, Inst}.cast(r));*/\ \ CHECK_FALSE(m_state.is_invocable_with());\ CHECK_FALSE(m_state.safe_invoke(Inst));\ @@ -78,6 +78,10 @@ TEST_CASE("meta/meta_utilities/inst2") { TEST_CASE("meta/meta_utilities/inst2/refs") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::uinst; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; { // lvalue @@ -85,9 +89,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { auto LV2 = []() -> dclazz& { static dclazz v; return v; }; { - meta::detail::uinst i{LV()}; + uinst i{r, LV()}; CHECK(i.get_raw_type() == meta::resolve_type()); - CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::lvalue); + CHECK(i.get_ref_type() == uinst::ref_types::lvalue); } META_HPP_CHECK_INVOCABLE(LV(), m1, ) @@ -111,9 +115,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { auto CLV2 = []() -> const dclazz& { static dclazz v; return v; }; { - meta::detail::uinst i{CLV()}; + uinst i{r, CLV()}; CHECK(i.get_raw_type() == meta::resolve_type()); - CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::const_lvalue); + CHECK(i.get_ref_type() == uinst::ref_types::const_lvalue); } META_HPP_CHECK_INVOCABLE(CLV(), m1, ) @@ -137,9 +141,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { auto XV2 = []() -> dclazz&& { static dclazz v; return std::move(v); }; { - meta::detail::uinst i{XV()}; + uinst i{r, XV()}; CHECK(i.get_raw_type() == meta::resolve_type()); - CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::rvalue); + CHECK(i.get_ref_type() == uinst::ref_types::rvalue); } META_HPP_CHECK_INVOCABLE(XV(), m1, ) @@ -163,9 +167,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { auto CXV2 = []() -> const dclazz&& { static dclazz v; return std::move(v); }; { - meta::detail::uinst i{CXV()}; + uinst i{r, CXV()}; CHECK(i.get_raw_type() == meta::resolve_type()); - CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::const_rvalue); + CHECK(i.get_ref_type() == uinst::ref_types::const_rvalue); } META_HPP_CHECK_INVOCABLE(CXV(), m1, ) @@ -189,9 +193,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { auto PRV2 = []() -> dclazz { return dclazz{}; }; { - meta::detail::uinst i{PRV()}; + uinst i{r, PRV()}; CHECK(i.get_raw_type() == meta::resolve_type()); - CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::rvalue); + CHECK(i.get_ref_type() == uinst::ref_types::rvalue); } META_HPP_CHECK_INVOCABLE(PRV(), m1, ) @@ -215,9 +219,9 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { auto CPRV2 = []() -> const dclazz { return dclazz{}; }; { - meta::detail::uinst i{CPRV()}; + uinst i{r, CPRV()}; CHECK(i.get_raw_type() == meta::resolve_type()); - CHECK(i.get_ref_type() == meta::detail::uinst::ref_types::const_rvalue); + CHECK(i.get_ref_type() == uinst::ref_types::const_rvalue); } META_HPP_CHECK_INVOCABLE(CPRV(), m1, ) @@ -238,15 +242,19 @@ TEST_CASE("meta/meta_utilities/inst2/refs") { TEST_CASE("meta/meta_utilities/inst2/values") { namespace meta = meta_hpp; + using meta::detail::uarg; + using meta::detail::uinst; + using meta::detail::type_registry; + type_registry& r{type_registry::instance()}; { // lvalue auto LV = []() -> meta::uvalue& { static meta::uvalue v{clazz{}}; return v; }; auto LV2 = []() -> meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; }; - meta::detail::uarg a{LV()}; + uarg a{r, LV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::lvalue); META_HPP_CHECK_INVOCABLE_2(LV(), m1, clazz&, ) META_HPP_CHECK_INVOCABLE_2(LV(), m2, clazz&, &) @@ -268,9 +276,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") { auto CLV = []() -> const meta::uvalue& { static meta::uvalue v{clazz{}}; return v; }; auto CLV2 = []() -> const meta::uvalue& { static meta::uvalue v{dclazz{}}; return v; }; - meta::detail::uarg a{CLV()}; + uarg a{r, CLV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_lvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_lvalue); META_HPP_CHECK_INVOCABLE_2(CLV(), m1, const clazz&, ) META_HPP_CHECK_INVOCABLE_2(CLV(), m2, const clazz&, &) @@ -292,9 +300,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") { auto XV = []() -> meta::uvalue&& { static meta::uvalue v{clazz{}}; return std::move(v); }; auto XV2 = []() -> meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); }; - meta::detail::uarg a{XV()}; + uarg a{r, XV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(XV(), m1, clazz&&, ) META_HPP_CHECK_INVOCABLE_2(XV(), m2, clazz&&, &) @@ -316,9 +324,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") { auto CXV = []() -> const meta::uvalue&& { static meta::uvalue v{clazz{}}; return std::move(v); }; auto CXV2 = []() -> const meta::uvalue&& { static meta::uvalue v{dclazz{}}; return std::move(v); }; - meta::detail::uarg a{CXV()}; + uarg a{r, CXV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CXV(), m1, const clazz&&, ) META_HPP_CHECK_INVOCABLE_2(CXV(), m2, const clazz&&, &) @@ -340,9 +348,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") { auto PRV = []() -> meta::uvalue { return meta::uvalue{clazz{}}; }; auto PRV2 = []() -> meta::uvalue { return meta::uvalue{dclazz{}}; }; - meta::detail::uarg a{PRV()}; + uarg a{r, PRV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::rvalue); META_HPP_CHECK_INVOCABLE_2(PRV(), m1, clazz, ) META_HPP_CHECK_INVOCABLE_2(PRV(), m2, clazz, &) @@ -364,9 +372,9 @@ TEST_CASE("meta/meta_utilities/inst2/values") { auto CPRV = []() -> const meta::uvalue { return meta::uvalue{clazz{}}; }; auto CPRV2 = []() -> const meta::uvalue { return meta::uvalue{dclazz{}}; }; - meta::detail::uarg a{CPRV()}; + uarg a{r, CPRV()}; CHECK(a.get_raw_type() == meta::resolve_type()); - CHECK(a.get_ref_type() == meta::detail::uarg::ref_types::const_rvalue); + CHECK(a.get_ref_type() == uarg::ref_types::const_rvalue); META_HPP_CHECK_INVOCABLE_2(CPRV(), m1, const clazz, ) META_HPP_CHECK_INVOCABLE_2(CPRV(), m2, const clazz, &) diff --git a/headers/meta.hpp/meta_base/fixed_function.hpp b/headers/meta.hpp/meta_base/fixed_function.hpp index 1e26c8e..f294d39 100644 --- a/headers/meta.hpp/meta_base/fixed_function.hpp +++ b/headers/meta.hpp/meta_base/fixed_function.hpp @@ -85,7 +85,7 @@ namespace meta_hpp::detail private: struct buffer_t final { // NOLINTNEXTLINE(*-avoid-c-arrays) - alignas(std::max_align_t) std::byte data[sizeof(void*) * 2]; + alignas(std::max_align_t) std::byte data[sizeof(void*) * 3]; } buffer_{}; }; diff --git a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp index 3818691..e710c02 100644 --- a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp +++ b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp @@ -39,32 +39,32 @@ namespace meta_hpp::detail template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uarg_base(T&&) - : uarg_base{type_list{}} {} + explicit uarg_base(type_registry& registry, T&&) + : uarg_base{registry, type_list{}} {} template < arg_lvalue_ref_kind T > - explicit uarg_base(type_list) + explicit uarg_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_lvalue : ref_types::lvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} template < arg_rvalue_ref_kind T > - explicit uarg_base(type_list) + explicit uarg_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_rvalue : ref_types::rvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} - explicit uarg_base(uvalue& v) + explicit uarg_base(type_registry&, uvalue& v) : ref_type_{ref_types::lvalue} , raw_type_{v.get_type()} {} - explicit uarg_base(const uvalue& v) + explicit uarg_base(type_registry&, const uvalue& v) : ref_type_{ref_types::const_lvalue} , raw_type_{v.get_type()} {} - explicit uarg_base(uvalue&& v) + explicit uarg_base(type_registry&, uvalue&& v) : ref_type_{ref_types::rvalue} , raw_type_{v.get_type()} {} - explicit uarg_base(const uvalue&& v) + explicit uarg_base(type_registry&, const uvalue&& v) : ref_type_{ref_types::const_rvalue} , raw_type_{v.get_type()} {} @@ -83,11 +83,11 @@ namespace meta_hpp::detail template < typename To > requires(std::is_pointer_v) - [[nodiscard]] bool can_cast_to() const noexcept; + [[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept; template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] bool can_cast_to() const noexcept; + [[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept; private: ref_types ref_type_{}; @@ -110,24 +110,24 @@ namespace meta_hpp::detail template < typename T, uvalue_kind Tp = std::decay_t > // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uarg(T&& v) - : uarg_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) - , data_{const_cast(v.get_data())} {} + explicit uarg(type_registry& registry, T&& v) + : uarg_base{registry, std::forward(v)} + , data_{const_cast(v.get_data())} {} // NOLINT(*-const-cast) template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uarg(T&& v) - : uarg_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) - , data_{const_cast*>(std::addressof(v))} {} + explicit uarg(type_registry& registry, T&& v) + : uarg_base{registry, std::forward(v)} + , data_{const_cast*>(std::addressof(v))} {} // NOLINT(*-const-cast) template < typename To > requires(std::is_pointer_v) - [[nodiscard]] To cast() const; + [[nodiscard]] To cast(type_registry& registry) const; template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] To cast() const; + [[nodiscard]] To cast(type_registry& registry) const; private: void* data_{}; @@ -138,12 +138,12 @@ namespace meta_hpp::detail { template < typename To > requires(std::is_pointer_v) - [[nodiscard]] bool uarg_base::can_cast_to() const noexcept { + [[nodiscard]] bool uarg_base::can_cast_to(type_registry& registry) const noexcept { using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -193,7 +193,7 @@ namespace meta_hpp::detail template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] bool uarg_base::can_cast_to() const noexcept { + [[nodiscard]] bool uarg_base::can_cast_to(type_registry& registry) const noexcept { using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; @@ -203,7 +203,7 @@ namespace meta_hpp::detail ); const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -258,14 +258,14 @@ namespace meta_hpp::detail { template < typename To > requires(std::is_pointer_v) - [[nodiscard]] To uarg::cast() const { - META_HPP_ASSERT(can_cast_to() && "bad argument cast"); + [[nodiscard]] To uarg::cast(type_registry& registry) const { + META_HPP_ASSERT(can_cast_to(registry) && "bad argument cast"); using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); if ( to_type.is_pointer() && from_type.is_nullptr() ) { return static_cast(nullptr); @@ -286,7 +286,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 = pointer_upcast(data_, from_data_class, to_data_class); + void* to_ptr = pointer_upcast(registry, data_, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -308,7 +308,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 = pointer_upcast(*from_data_ptr, from_data_class, to_data_class); + void* to_ptr = pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -318,8 +318,8 @@ namespace meta_hpp::detail template < typename To > requires(!std::is_pointer_v) - [[nodiscard]] To uarg::cast() const { - META_HPP_ASSERT(can_cast_to() && "bad argument cast"); + [[nodiscard]] To uarg::cast(type_registry& registry) const { + META_HPP_ASSERT(can_cast_to(registry) && "bad argument cast"); using to_raw_type_cv = std::remove_reference_t; using to_raw_type = std::remove_cv_t; @@ -330,11 +330,11 @@ namespace meta_hpp::detail ); const any_type& from_type = get_raw_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); void* to_ptr = to_type == from_type // ? data_ - : pointer_upcast(data_, from_type.as_class(), to_type.as_class()); + : pointer_upcast(registry, data_, from_type.as_class(), to_type.as_class()); if constexpr ( std::is_lvalue_reference_v ) { return *static_cast(to_ptr); @@ -376,28 +376,28 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < typename ArgTypeList, typename F > - auto call_with_uargs(std::span args, F&& f) { + auto call_with_uargs(type_registry& registry, std::span args, F&& f) { META_HPP_ASSERT(args.size() == type_list_arity_v); - return [ args, &f ](std::index_sequence) { - return f(args[Is].cast>()...); + return [ args, ®istry, &f ](std::index_sequence) { + return f(args[Is].cast>(registry)...); } (std::make_index_sequence>()); } template < typename ArgTypeList > - bool can_cast_all_uargs(std::span args) { + bool can_cast_all_uargs(type_registry& registry, std::span args) { META_HPP_ASSERT(args.size() == type_list_arity_v); - return [args](std::index_sequence) { - return (... && args[Is].can_cast_to>()); + return [ args, ®istry ](std::index_sequence) { + return (... && args[Is].can_cast_to>(registry)); } (std::make_index_sequence>()); } template < typename ArgTypeList > - bool can_cast_all_uargs(std::span args) { + bool can_cast_all_uargs(type_registry& registry, std::span args) { META_HPP_ASSERT(args.size() == type_list_arity_v); - return [args](std::index_sequence) { - return (... && args[Is].can_cast_to>()); + return [ args, ®istry ](std::index_sequence) { + return (... && args[Is].can_cast_to>(registry)); } (std::make_index_sequence>()); } diff --git a/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp b/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp index b802d2d..638fd77 100644 --- a/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp +++ b/headers/meta.hpp/meta_detail/value_utilities/uinst.hpp @@ -39,32 +39,32 @@ namespace meta_hpp::detail template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uinst_base(T&&) - : uinst_base{type_list{}} {} + explicit uinst_base(type_registry& registry, T&&) + : uinst_base{registry, type_list{}} {} template < inst_class_lvalue_ref_kind T > - explicit uinst_base(type_list) + explicit uinst_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_lvalue : ref_types::lvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} template < inst_class_rvalue_ref_kind T > - explicit uinst_base(type_list) + explicit uinst_base(type_registry& registry, type_list) : ref_type_{std::is_const_v> ? ref_types::const_rvalue : ref_types::rvalue} - , raw_type_{resolve_type>()} {} + , raw_type_{registry.resolve_type>()} {} - explicit uinst_base(uvalue& v) + explicit uinst_base(type_registry&, uvalue& v) : ref_type_{ref_types::lvalue} , raw_type_{v.get_type()} {} - explicit uinst_base(const uvalue& v) + explicit uinst_base(type_registry&, const uvalue& v) : ref_type_{ref_types::const_lvalue} , raw_type_{v.get_type()} {} - explicit uinst_base(uvalue&& v) + explicit uinst_base(type_registry&, uvalue&& v) : ref_type_{ref_types::rvalue} , raw_type_{v.get_type()} {} - explicit uinst_base(const uvalue&& v) + explicit uinst_base(type_registry&, const uvalue&& v) : ref_type_{ref_types::const_rvalue} , raw_type_{v.get_type()} {} @@ -87,7 +87,7 @@ namespace meta_hpp::detail } template < inst_class_ref_kind Q > - [[nodiscard]] bool can_cast_to() const noexcept; + [[nodiscard]] bool can_cast_to(type_registry& registry) const noexcept; private: ref_types ref_type_{}; @@ -110,19 +110,19 @@ namespace meta_hpp::detail template < typename T, uvalue_kind Tp = std::decay_t > // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uinst(T&& v) - : uinst_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) + explicit uinst(type_registry& registry, T&& v) + : uinst_base{registry, std::forward(v)} // NOLINTNEXTLINE(*-const-cast) , data_{const_cast(v.get_data())} {} template < typename T, typename Tp = std::decay_t > requires(!any_uvalue_kind) // NOLINTNEXTLINE(*-forwarding-reference-overload) - explicit uinst(T&& v) - : uinst_base{std::forward(v)} // NOLINTNEXTLINE(*-const-cast) + explicit uinst(type_registry& registry, T&& v) + : uinst_base{registry, std::forward(v)} // NOLINTNEXTLINE(*-const-cast) , data_{const_cast*>(std::addressof(v))} {} template < inst_class_ref_kind Q > - [[nodiscard]] decltype(auto) cast() const; + [[nodiscard]] decltype(auto) cast(type_registry& registry) const; private: void* data_{}; @@ -132,12 +132,12 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < inst_class_ref_kind Q > - bool uinst_base::can_cast_to() const noexcept { + bool uinst_base::can_cast_to(type_registry& registry) 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 any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -182,20 +182,20 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < inst_class_ref_kind Q > - decltype(auto) uinst::cast() const { - META_HPP_ASSERT(can_cast_to() && "bad instance cast"); + decltype(auto) uinst::cast(type_registry& registry) const { + META_HPP_ASSERT(can_cast_to(registry) && "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(); + const any_type& to_type = registry.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); + void* to_ptr = pointer_upcast(registry, data_, from_class, to_class); if constexpr ( !std::is_reference_v ) { return *static_cast(to_ptr); @@ -219,7 +219,7 @@ namespace meta_hpp::detail const class_type& to_class = to_type.as_class(); void** from_data_ptr = static_cast(data_); - void* to_ptr = pointer_upcast(*from_data_ptr, from_data_class, to_class); + void* to_ptr = pointer_upcast(registry, *from_data_ptr, from_data_class, to_class); if constexpr ( !std::is_reference_v ) { return *static_cast(to_ptr); diff --git a/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp b/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp index 5c354b4..8041d01 100644 --- a/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp +++ b/headers/meta.hpp/meta_detail/value_utilities/utraits.hpp @@ -98,7 +98,12 @@ namespace meta_hpp::detail namespace meta_hpp::detail { - [[nodiscard]] inline void* pointer_upcast(void* ptr, const class_type& from, const class_type& to) { + [[nodiscard]] inline void* pointer_upcast( // + type_registry& registry, + void* ptr, + const class_type& from, + const class_type& to + ) { if ( nullptr == ptr || !from || !to ) { return nullptr; } @@ -113,25 +118,30 @@ namespace meta_hpp::detail } if ( base_type.is_derived_from(to) ) { - return pointer_upcast(base_info.upcast(ptr), base_type, to); + return pointer_upcast(registry, base_info.upcast(ptr), base_type, to); } } return nullptr; } - [[nodiscard]] inline const void* pointer_upcast(const void* ptr, const class_type& from, const class_type& to) { + [[nodiscard]] inline const void* pointer_upcast( // + type_registry& registry, + const void* ptr, + const class_type& from, + const class_type& to + ) { // NOLINTNEXTLINE(*-const-cast) - return pointer_upcast(const_cast(ptr), from, to); + return pointer_upcast(registry, const_cast(ptr), from, to); } template < class_kind To, class_kind From > - [[nodiscard]] To* pointer_upcast(From* ptr) { - return static_cast(pointer_upcast(ptr, resolve_type(), resolve_type())); + [[nodiscard]] To* pointer_upcast(type_registry& registry, From* ptr) { + return static_cast(pointer_upcast(registry, ptr, registry.resolve_type(), registry.resolve_type())); } template < class_kind To, class_kind From > - [[nodiscard]] const To* pointer_upcast(const From* ptr) { - return static_cast(pointer_upcast(ptr, resolve_type(), resolve_type())); + [[nodiscard]] const To* pointer_upcast(type_registry& registry, const From* ptr) { + return static_cast(pointer_upcast(registry, ptr, registry.resolve_type(), registry.resolve_type())); } } diff --git a/headers/meta.hpp/meta_invoke/invoke.hpp b/headers/meta.hpp/meta_invoke/invoke.hpp index 73b4e91..aee4008 100644 --- a/headers/meta.hpp/meta_invoke/invoke.hpp +++ b/headers/meta.hpp/meta_invoke/invoke.hpp @@ -27,8 +27,9 @@ namespace meta_hpp template < detail::function_pointer_kind Function, typename... Args > uvalue invoke(Function function_ptr, Args&&... args) { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; - return raw_function_invoke(function_ptr, vargs); + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; + return raw_function_invoke(registry, function_ptr, vargs); } } @@ -42,8 +43,9 @@ namespace meta_hpp template < detail::member_pointer_kind Member, typename Instance > uvalue invoke(Member member_ptr, Instance&& instance) { using namespace detail; - const uinst vinst{std::forward(instance)}; - return raw_member_getter(member_ptr, vinst); + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + return raw_member_getter(registry, member_ptr, vinst); } } @@ -57,9 +59,10 @@ namespace meta_hpp template < detail::method_pointer_kind Method, typename Instance, typename... Args > uvalue invoke(Method method_ptr, Instance&& instance, Args&&... args) { using namespace detail; - const uinst vinst{std::forward(instance)}; - const std::array vargs{uarg{std::forward(args)}...}; - return raw_method_invoke(method_ptr, vinst, vargs); + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + const std::array vargs{uarg{registry, std::forward(args)}...}; + return raw_method_invoke(registry, method_ptr, vinst, vargs); } } @@ -78,15 +81,17 @@ namespace meta_hpp template < detail::function_pointer_kind Function, typename... Args > bool is_invocable_with() { using namespace detail; - const std::array vargs{uarg_base{type_list{}}...}; - return raw_function_is_invocable_with(vargs); + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, type_list{}}...}; + return raw_function_is_invocable_with(registry, vargs); } template < detail::function_pointer_kind Function, typename... Args > bool is_invocable_with(Args&&... args) { using namespace detail; - const std::array vargs{uarg_base{std::forward(args)}...}; - return raw_function_is_invocable_with(vargs); + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; + return raw_function_is_invocable_with(registry, vargs); } } @@ -105,15 +110,17 @@ namespace meta_hpp template < detail::member_pointer_kind Member, typename Instance > bool is_invocable_with() { using namespace detail; - const uinst_base vinst{type_list{}}; - return raw_member_is_gettable_with(vinst); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + return raw_member_is_gettable_with(registry, vinst); } template < detail::member_pointer_kind Member, typename Instance > bool is_invocable_with(Instance&& instance) { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - return raw_member_is_gettable_with(vinst); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + return raw_member_is_gettable_with(registry, vinst); } } @@ -132,16 +139,18 @@ namespace meta_hpp template < detail::method_pointer_kind Method, typename Instance, typename... Args > bool is_invocable_with() { using namespace detail; - const uinst_base vinst{type_list{}}; - const std::array vargs{uarg_base{type_list{}}...}; - return raw_method_is_invocable_with(vinst, vargs); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + const std::array vargs{uarg_base{registry, type_list{}}...}; + return raw_method_is_invocable_with(registry, vinst, vargs); } template < detail::method_pointer_kind Method, typename Instance, typename... Args > bool is_invocable_with(Instance&& instance, Args&&... args) { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - const std::array vargs{uarg_base{std::forward(args)}...}; - return raw_method_is_invocable_with(vinst, vargs); + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; + return raw_method_is_invocable_with(registry, vinst, vargs); } } diff --git a/headers/meta.hpp/meta_registry.hpp b/headers/meta.hpp/meta_registry.hpp index 5d787f9..2876ef0 100644 --- a/headers/meta.hpp/meta_registry.hpp +++ b/headers/meta.hpp/meta_registry.hpp @@ -38,12 +38,16 @@ namespace meta_hpp template < typename... Ts > [[nodiscard]] any_type_list resolve_types() { - return {resolve_type()...}; + using namespace detail; + type_registry& registry = type_registry::instance(); + return {registry.resolve_type>()...}; } template < typename... Ts > [[nodiscard]] any_type_list resolve_types(type_list) { - return {resolve_type()...}; + using namespace detail; + type_registry& registry = type_registry::instance(); + return {registry.resolve_type>()...}; } } diff --git a/headers/meta.hpp/meta_states/argument.hpp b/headers/meta.hpp/meta_states/argument.hpp index 236ce7b..ebe0921 100644 --- a/headers/meta.hpp/meta_states/argument.hpp +++ b/headers/meta.hpp/meta_states/argument.hpp @@ -9,6 +9,8 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" + namespace meta_hpp::detail { inline argument_state::argument_state(argument_index nindex, metadata_map nmetadata) @@ -17,7 +19,8 @@ namespace meta_hpp::detail template < typename Argument > inline argument_state_ptr argument_state::make(std::size_t position, metadata_map metadata) { - argument_state state{argument_index{resolve_type(), position}, std::move(metadata)}; + type_registry& registry{type_registry::instance()}; + argument_state state{argument_index{registry.resolve_type(), position}, std::move(metadata)}; return make_intrusive(std::move(state)); } } diff --git a/headers/meta.hpp/meta_states/constructor.hpp b/headers/meta.hpp/meta_states/constructor.hpp index a796d1a..855271b 100644 --- a/headers/meta.hpp/meta_states/constructor.hpp +++ b/headers/meta.hpp/meta_states/constructor.hpp @@ -9,13 +9,14 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_detail/value_utilities/uarg.hpp" #include "../meta_types/constructor_type.hpp" namespace meta_hpp::detail { template < constructor_policy_kind Policy, class_kind Class, typename... Args > - uvalue raw_constructor_create(std::span args) { + uvalue raw_constructor_create(type_registry& registry, std::span args) { using ct = constructor_traits; using class_type = typename ct::class_type; using argument_types = typename ct::argument_types; @@ -37,12 +38,12 @@ namespace meta_hpp::detail && "an attempt to call a constructor with an incorrect arity" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a constructor with incorrect argument types" ); - return call_with_uargs(args, [](auto&&... all_args) -> uvalue { + return call_with_uargs(registry, args, [](auto&&... all_args) -> uvalue { if constexpr ( as_object ) { return make_uvalue(META_HPP_FWD(all_args)...); } @@ -58,7 +59,7 @@ namespace meta_hpp::detail } template < class_kind Class, typename... Args > - uvalue raw_constructor_create_at(void* mem, std::span args) { + uvalue raw_constructor_create_at(type_registry& registry, void* mem, std::span args) { using ct = constructor_traits; using class_type = typename ct::class_type; using argument_types = typename ct::argument_types; @@ -68,41 +69,47 @@ namespace meta_hpp::detail && "an attempt to call a constructor with an incorrect arity" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a constructor with incorrect argument types" ); - return call_with_uargs(args, [mem](auto&&... all_args) { + return call_with_uargs(registry, args, [mem](auto&&... all_args) { return std::construct_at(static_cast(mem), META_HPP_FWD(all_args)...); }); } template < class_kind Class, typename... Args > - bool raw_constructor_is_invocable_with(std::span args) { + bool raw_constructor_is_invocable_with(type_registry& registry, std::span args) { using ct = constructor_traits; using argument_types = typename ct::argument_types; return args.size() == ct::arity // - && can_cast_all_uargs(args); + && can_cast_all_uargs(registry, args); } } namespace meta_hpp::detail { template < constructor_policy_kind Policy, class_kind Class, typename... Args > - constructor_state::create_impl make_constructor_create() { - return &raw_constructor_create; + constructor_state::create_impl make_constructor_create(type_registry& registry) { + return [®istry](std::span args) { // + return raw_constructor_create(registry, args); + }; } template < class_kind Class, typename... Args > - constructor_state::create_at_impl make_constructor_create_at() { - return &raw_constructor_create_at; + constructor_state::create_at_impl make_constructor_create_at(type_registry& registry) { + return [®istry](void* mem, std::span args) { // + return raw_constructor_create_at(registry, mem, args); + }; } template < class_kind Class, typename... Args > - constructor_state::is_invocable_with_impl make_constructor_is_invocable_with() { - return &raw_constructor_is_invocable_with; + constructor_state::is_invocable_with_impl make_constructor_is_invocable_with(type_registry& registry) { + return [®istry](std::span args) { // + return raw_constructor_is_invocable_with(registry, args); + }; } template < class_kind Class, typename... Args > @@ -129,10 +136,11 @@ namespace meta_hpp::detail template < constructor_policy_kind Policy, class_kind Class, typename... Args > constructor_state_ptr constructor_state::make(metadata_map metadata) { - constructor_state state{constructor_index{resolve_constructor_type()}, std::move(metadata)}; - state.create = make_constructor_create(); - state.create_at = make_constructor_create_at(); - state.is_invocable_with = make_constructor_is_invocable_with(); + type_registry& registry{type_registry::instance()}; + constructor_state state{constructor_index{registry.resolve_constructor_type()}, std::move(metadata)}; + state.create = make_constructor_create(registry); + state.create_at = make_constructor_create_at(registry); + state.is_invocable_with = make_constructor_is_invocable_with(registry); state.arguments = make_constructor_arguments(); return make_intrusive(std::move(state)); } @@ -147,7 +155,8 @@ namespace meta_hpp template < typename... Args > uvalue constructor::create(Args&&... args) const { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->create(vargs); } @@ -162,7 +171,8 @@ namespace meta_hpp template < typename... Args > uvalue constructor::create_at(void* mem, Args&&... args) const { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->create_at(mem, vargs); } @@ -177,14 +187,16 @@ namespace meta_hpp template < typename... Args > bool constructor::is_invocable_with() const noexcept { using namespace detail; - const std::array vargs{uarg_base{type_list{}}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, type_list{}}...}; return state_->is_invocable_with(vargs); } template < typename... Args > bool constructor::is_invocable_with(Args&&... args) const noexcept { using namespace detail; - const std::array vargs{uarg_base{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; return state_->is_invocable_with(vargs); } diff --git a/headers/meta.hpp/meta_states/destructor.hpp b/headers/meta.hpp/meta_states/destructor.hpp index c69301e..e17e2a6 100644 --- a/headers/meta.hpp/meta_states/destructor.hpp +++ b/headers/meta.hpp/meta_states/destructor.hpp @@ -9,21 +9,22 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_detail/value_utilities/uarg.hpp" #include "../meta_types/destructor_type.hpp" namespace meta_hpp::detail { template < class_kind Class > - bool raw_destructor_destroy(const uarg& arg) { + bool raw_destructor_destroy(type_registry& registry, const uarg& arg) { using dt = destructor_traits; using class_type = typename dt::class_type; - if ( !arg.can_cast_to() ) { + if ( !arg.can_cast_to(registry) ) { return false; } - std::unique_ptr{arg.cast()}.reset(); + std::unique_ptr{arg.cast(registry)}.reset(); return true; } @@ -39,8 +40,10 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < class_kind Class > - destructor_state::destroy_impl make_destructor_destroy() { - return &raw_destructor_destroy; + destructor_state::destroy_impl make_destructor_destroy(type_registry& registry) { + return [®istry](const uarg& arg) { // + return raw_destructor_destroy(registry, arg); + }; } template < class_kind Class > @@ -57,8 +60,9 @@ namespace meta_hpp::detail template < class_kind Class > destructor_state_ptr destructor_state::make(metadata_map metadata) { - destructor_state state{destructor_index{resolve_destructor_type()}, std::move(metadata)}; - state.destroy = make_destructor_destroy(); + type_registry& registry{type_registry::instance()}; + destructor_state state{destructor_index{registry.resolve_destructor_type()}, std::move(metadata)}; + state.destroy = make_destructor_destroy(registry); state.destroy_at = make_destructor_destroy_at(); return make_intrusive(std::move(state)); } @@ -73,7 +77,8 @@ namespace meta_hpp template < typename Arg > bool destructor::destroy(Arg&& arg) const { using namespace detail; - const uarg varg{std::forward(arg)}; + type_registry& registry{type_registry::instance()}; + const uarg varg{registry, std::forward(arg)}; return state_->destroy(varg); } diff --git a/headers/meta.hpp/meta_states/evalue.hpp b/headers/meta.hpp/meta_states/evalue.hpp index fac5026..3b6e391 100644 --- a/headers/meta.hpp/meta_states/evalue.hpp +++ b/headers/meta.hpp/meta_states/evalue.hpp @@ -9,6 +9,7 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_types/enum_type.hpp" namespace meta_hpp::detail @@ -19,7 +20,8 @@ namespace meta_hpp::detail template < enum_kind Enum > evalue_state_ptr evalue_state::make(std::string name, Enum evalue, metadata_map metadata) { - evalue_state state{evalue_index{resolve_type(), std::move(name)}, std::move(metadata)}; + type_registry& registry{type_registry::instance()}; + evalue_state state{evalue_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; state.enum_value = uvalue{evalue}; state.underlying_value = uvalue{to_underlying(evalue)}; return make_intrusive(std::move(state)); diff --git a/headers/meta.hpp/meta_states/function.hpp b/headers/meta.hpp/meta_states/function.hpp index 5ec8a29..bbcebb0 100644 --- a/headers/meta.hpp/meta_states/function.hpp +++ b/headers/meta.hpp/meta_states/function.hpp @@ -9,13 +9,14 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_detail/value_utilities/uarg.hpp" #include "../meta_types/function_type.hpp" namespace meta_hpp::detail { template < function_policy_kind Policy, function_pointer_kind Function > - uvalue raw_function_invoke(Function function_ptr, std::span args) { + uvalue raw_function_invoke(type_registry& registry, Function function_ptr, std::span args) { using ft = function_traits; using return_type = typename ft::return_type; using argument_types = typename ft::argument_types; @@ -39,12 +40,12 @@ namespace meta_hpp::detail && "an attempt to call a function with an incorrect arity" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a function with incorrect argument types" ); - return call_with_uargs(args, [function_ptr](auto&&... all_args) { + return call_with_uargs(registry, args, [function_ptr](auto&&... all_args) { if constexpr ( std::is_void_v ) { function_ptr(META_HPP_FWD(all_args)...); return uvalue{}; @@ -63,27 +64,29 @@ namespace meta_hpp::detail } template < function_pointer_kind Function > - bool raw_function_is_invocable_with(std::span args) { + bool raw_function_is_invocable_with(type_registry& registry, std::span args) { using ft = function_traits; using argument_types = typename ft::argument_types; return args.size() == ft::arity // - && can_cast_all_uargs(args); + && can_cast_all_uargs(registry, args); } } namespace meta_hpp::detail { template < function_policy_kind Policy, function_pointer_kind Function > - function_state::invoke_impl make_function_invoke(Function function_ptr) { - return [function_ptr](std::span args) { // - return raw_function_invoke(function_ptr, args); + function_state::invoke_impl make_function_invoke(type_registry& registry, Function function_ptr) { + return [®istry, function_ptr](std::span args) { // + return raw_function_invoke(registry, function_ptr, args); }; } template < function_pointer_kind Function > - function_state::is_invocable_with_impl make_function_is_invocable_with() { - return &raw_function_is_invocable_with; + function_state::is_invocable_with_impl make_function_is_invocable_with(type_registry& registry) { + return [®istry](std::span args) { // + return raw_function_is_invocable_with(registry, args); + }; } template < function_pointer_kind Function > @@ -110,9 +113,10 @@ namespace meta_hpp::detail template < function_policy_kind Policy, function_pointer_kind Function > function_state_ptr function_state::make(std::string name, Function function_ptr, metadata_map metadata) { - function_state state{function_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.invoke = make_function_invoke(function_ptr); - state.is_invocable_with = make_function_is_invocable_with(); + type_registry& registry{type_registry::instance()}; + function_state state{function_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.invoke = make_function_invoke(registry, function_ptr); + state.is_invocable_with = make_function_is_invocable_with(registry); state.arguments = make_function_arguments(); return make_intrusive(std::move(state)); } @@ -131,7 +135,8 @@ namespace meta_hpp template < typename... Args > uvalue function::invoke(Args&&... args) const { using namespace detail; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->invoke(vargs); } @@ -151,14 +156,16 @@ namespace meta_hpp template < typename... Args > bool function::is_invocable_with() const noexcept { using namespace detail; - const std::array vargs{uarg_base{type_list{}}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, type_list{}}...}; return state_->is_invocable_with(vargs); } template < typename... Args > bool function::is_invocable_with(Args&&... args) const noexcept { using namespace detail; - const std::array vargs{uarg_base{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; return state_->is_invocable_with(vargs); } diff --git a/headers/meta.hpp/meta_states/member.hpp b/headers/meta.hpp/meta_states/member.hpp index 7fd9639..202dba2 100644 --- a/headers/meta.hpp/meta_states/member.hpp +++ b/headers/meta.hpp/meta_states/member.hpp @@ -9,6 +9,7 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_detail/value_utilities/uarg.hpp" #include "../meta_detail/value_utilities/uinst.hpp" #include "../meta_types/member_type.hpp" @@ -16,7 +17,7 @@ namespace meta_hpp::detail { template < member_policy_kind Policy, member_pointer_kind Member > - uvalue raw_member_getter(Member member_ptr, const uinst& inst) { + uvalue raw_member_getter(type_registry& registry, Member member_ptr, const uinst& inst) { using mt = member_traits; using class_type = typename mt::class_type; using value_type = typename mt::value_type; @@ -34,12 +35,12 @@ namespace meta_hpp::detail static_assert(as_copy || as_ptr || as_ref_wrap); if ( inst.is_inst_const() ) { - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to get a member with an incorrect instance type" ); - auto&& return_value = inst.cast().*member_ptr; + auto&& return_value = inst.cast(registry).*member_ptr; if constexpr ( as_copy ) { return uvalue{META_HPP_FWD(return_value)}; @@ -53,12 +54,12 @@ namespace meta_hpp::detail return uvalue{std::ref(return_value)}; } } else { - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to get a member with an incorrect instance type" ); - auto&& return_value = inst.cast().*member_ptr; + auto&& return_value = inst.cast(registry).*member_ptr; if constexpr ( as_copy ) { return uvalue{META_HPP_FWD(return_value)}; @@ -75,23 +76,27 @@ namespace meta_hpp::detail } template < member_pointer_kind Member > - bool raw_member_is_gettable_with(const uinst_base& inst) { + bool raw_member_is_gettable_with(type_registry& registry, const uinst_base& inst) { using mt = member_traits; using class_type = typename mt::class_type; - return inst.can_cast_to(); + return inst.can_cast_to(registry); } } namespace meta_hpp::detail { template < member_pointer_kind Member > - void raw_member_setter([[maybe_unused]] Member member_ptr, const uinst& inst, const uarg& arg) { + void raw_member_setter(type_registry& registry, Member member_ptr, const uinst& inst, const uarg& arg) { using mt = member_traits; using class_type = typename mt::class_type; using value_type = typename mt::value_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)member_ptr; + (void)inst; + (void)arg; META_HPP_ASSERT(false && "an attempt to set a constant member"); } else { META_HPP_ASSERT( // @@ -99,32 +104,35 @@ namespace meta_hpp::detail && "an attempt to set a member with an const instance type" ); - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to set a member with an incorrect instance type" ); - META_HPP_ASSERT( // - arg.can_cast_to() // + META_HPP_ASSERT( // + arg.can_cast_to(registry) // && "an attempt to set a member with an incorrect argument type" ); - inst.cast().*member_ptr = arg.cast(); + inst.cast(registry).*member_ptr = arg.cast(registry); } } template < member_pointer_kind Member > - bool raw_member_is_settable_with(const uinst_base& inst, const uarg_base& arg) { + bool raw_member_is_settable_with(type_registry& registry, const uinst_base& inst, const uarg_base& arg) { using mt = member_traits; using class_type = typename mt::class_type; using value_type = typename mt::value_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)inst; + (void)arg; return false; } else { - return !inst.is_inst_const() // - && inst.can_cast_to() // - && arg.can_cast_to(); // + return !inst.is_inst_const() // + && inst.can_cast_to(registry) // + && arg.can_cast_to(registry); // } } } @@ -132,27 +140,31 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < member_policy_kind Policy, member_pointer_kind Member > - member_state::getter_impl make_member_getter(Member member_ptr) { - return [member_ptr](const uinst& inst) { // - return raw_member_getter(member_ptr, inst); + member_state::getter_impl make_member_getter(type_registry& registry, Member member_ptr) { + return [®istry, member_ptr](const uinst& inst) { // + return raw_member_getter(registry, member_ptr, inst); }; } template < member_pointer_kind Member > - member_state::is_gettable_with_impl make_member_is_gettable_with() { - return &raw_member_is_gettable_with; - } - - template < member_pointer_kind Member > - member_state::setter_impl make_member_setter(Member member_ptr) { - return [member_ptr](const uinst& inst, const uarg& arg) { // - return raw_member_setter(member_ptr, inst, arg); + member_state::is_gettable_with_impl make_member_is_gettable_with(type_registry& registry) { + return [®istry](const uinst_base& inst) { // + return raw_member_is_gettable_with(registry, inst); }; } template < member_pointer_kind Member > - member_state::is_settable_with_impl make_member_is_settable_with() { - return &raw_member_is_settable_with; + member_state::setter_impl make_member_setter(type_registry& registry, Member member_ptr) { + return [®istry, member_ptr](const uinst& inst, const uarg& arg) { // + return raw_member_setter(registry, member_ptr, inst, arg); + }; + } + + template < member_pointer_kind Member > + member_state::is_settable_with_impl make_member_is_settable_with(type_registry& registry) { + return [®istry](const uinst_base& inst, const uarg_base& arg) { // + return raw_member_is_settable_with(registry, inst, arg); + }; } } @@ -164,11 +176,12 @@ namespace meta_hpp::detail template < member_policy_kind Policy, member_pointer_kind Member > member_state_ptr member_state::make(std::string name, Member member_ptr, metadata_map metadata) { - member_state state{member_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.getter = make_member_getter(member_ptr); - state.setter = make_member_setter(member_ptr); - state.is_gettable_with = make_member_is_gettable_with(); - state.is_settable_with = make_member_is_settable_with(); + type_registry& registry{type_registry::instance()}; + member_state state{member_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.getter = make_member_getter(registry, member_ptr); + state.setter = make_member_setter(registry, member_ptr); + state.is_gettable_with = make_member_is_gettable_with(registry); + state.is_settable_with = make_member_is_settable_with(registry); return make_intrusive(std::move(state)); } } @@ -186,7 +199,8 @@ namespace meta_hpp template < typename Instance > uvalue member::get(Instance&& instance) const { using namespace detail; - const uinst vinst{std::forward(instance)}; + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; return state_->getter(vinst); } @@ -211,8 +225,9 @@ namespace meta_hpp template < typename Instance, typename Value > void member::set(Instance&& instance, Value&& value) const { using namespace detail; - const uinst vinst{std::forward(instance)}; - const uarg vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + const uarg vvalue{registry, std::forward(value)}; state_->setter(vinst, vvalue); } @@ -238,30 +253,34 @@ namespace meta_hpp template < typename Instance > [[nodiscard]] bool member::is_gettable_with() const noexcept { using namespace detail; - const uinst_base vinst{type_list{}}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; return state_->is_gettable_with(vinst); } template < typename Instance > [[nodiscard]] bool member::is_gettable_with(Instance&& instance) const noexcept { using namespace detail; - const uinst_base vinst{std::forward(instance)}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; return state_->is_gettable_with(vinst); } template < typename Instance, typename Value > [[nodiscard]] bool member::is_settable_with() const noexcept { using namespace detail; - const uinst_base vinst{type_list{}}; - const uarg_base vvalue{type_list{}}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + const uarg_base vvalue{registry, type_list{}}; return state_->is_settable_with(vinst, vvalue); } template < typename Instance, typename Value > [[nodiscard]] bool member::is_settable_with(Instance&& instance, Value&& value) const noexcept { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - const uarg_base vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + const uarg_base vvalue{registry, std::forward(value)}; return state_->is_settable_with(vinst, vvalue); } } diff --git a/headers/meta.hpp/meta_states/method.hpp b/headers/meta.hpp/meta_states/method.hpp index 6304e52..1a6000a 100644 --- a/headers/meta.hpp/meta_states/method.hpp +++ b/headers/meta.hpp/meta_states/method.hpp @@ -9,6 +9,7 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_detail/value_utilities/uarg.hpp" #include "../meta_detail/value_utilities/uinst.hpp" #include "../meta_types/method_type.hpp" @@ -16,7 +17,7 @@ namespace meta_hpp::detail { template < method_policy_kind Policy, method_pointer_kind Method > - uvalue raw_method_invoke(Method method_ptr, const uinst& inst, std::span args) { + uvalue raw_method_invoke(type_registry& registry, Method method_ptr, const uinst& inst, std::span args) { using mt = method_traits; using return_type = typename mt::return_type; using qualified_type = typename mt::qualified_type; @@ -41,19 +42,19 @@ namespace meta_hpp::detail && "an attempt to call a method with an incorrect arity" ); - META_HPP_ASSERT( // - inst.can_cast_to() // + META_HPP_ASSERT( // + inst.can_cast_to(registry) // && "an attempt to call a method with an incorrect instance type" ); - META_HPP_ASSERT( // - can_cast_all_uargs(args) // + META_HPP_ASSERT( // + can_cast_all_uargs(registry, args) // && "an attempt to call a method with incorrect argument types" ); - return call_with_uargs(args, [method_ptr, &inst](auto&&... all_args) { + return call_with_uargs(registry, args, [method_ptr, &inst, ®istry](auto&&... all_args) { if constexpr ( std::is_void_v ) { - (inst.cast().*method_ptr)(META_HPP_FWD(all_args)...); + (inst.cast(registry).*method_ptr)(META_HPP_FWD(all_args)...); return uvalue{}; } @@ -63,36 +64,38 @@ namespace meta_hpp::detail } if constexpr ( !std::is_void_v ) { - return_type&& result = (inst.cast().*method_ptr)(META_HPP_FWD(all_args)...); + return_type&& result = (inst.cast(registry).*method_ptr)(META_HPP_FWD(all_args)...); return ref_as_ptr ? uvalue{std::addressof(result)} : uvalue{META_HPP_FWD(result)}; } }); } template < method_pointer_kind Method > - bool raw_method_is_invocable_with(const uinst_base& inst, std::span args) { + bool raw_method_is_invocable_with(type_registry& registry, const uinst_base& inst, std::span args) { using mt = method_traits; using qualified_type = typename mt::qualified_type; using argument_types = typename mt::argument_types; - return args.size() == mt::arity // - && inst.can_cast_to() // - && can_cast_all_uargs(args); + return args.size() == mt::arity // + && inst.can_cast_to(registry) // + && can_cast_all_uargs(registry, args); } } namespace meta_hpp::detail { template < method_policy_kind Policy, method_pointer_kind Method > - method_state::invoke_impl make_method_invoke(Method method_ptr) { - return [method_ptr](const uinst& inst, std::span args) { - return raw_method_invoke(method_ptr, inst, args); + method_state::invoke_impl make_method_invoke(type_registry& registry, Method method_ptr) { + return [®istry, method_ptr](const uinst& inst, std::span args) { + return raw_method_invoke(registry, method_ptr, inst, args); }; } template < method_pointer_kind Method > - method_state::is_invocable_with_impl make_method_is_invocable_with() { - return &raw_method_is_invocable_with; + method_state::is_invocable_with_impl make_method_is_invocable_with(type_registry& registry) { + return [®istry](const uinst_base& inst, std::span args) { + return raw_method_is_invocable_with(registry, inst, args); + }; } template < method_pointer_kind Method > @@ -119,9 +122,10 @@ namespace meta_hpp::detail template < method_policy_kind Policy, method_pointer_kind Method > method_state_ptr method_state::make(std::string name, Method method_ptr, metadata_map metadata) { - method_state state{method_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.invoke = make_method_invoke(method_ptr); - state.is_invocable_with = make_method_is_invocable_with(); + type_registry& registry{type_registry::instance()}; + method_state state{method_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.invoke = make_method_invoke(registry, method_ptr); + state.is_invocable_with = make_method_is_invocable_with(registry); state.arguments = make_method_arguments(); return make_intrusive(std::move(state)); } @@ -140,8 +144,9 @@ namespace meta_hpp template < typename Instance, typename... Args > uvalue method::invoke(Instance&& instance, Args&&... args) const { using namespace detail; - const uinst vinst{std::forward(instance)}; - const std::array vargs{uarg{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const uinst vinst{registry, std::forward(instance)}; + const std::array vargs{uarg{registry, std::forward(args)}...}; return state_->invoke(vinst, vargs); } @@ -161,16 +166,18 @@ namespace meta_hpp template < typename Instance, typename... Args > bool method::is_invocable_with() const noexcept { using namespace detail; - const uinst_base vinst{type_list{}}; - const std::array vargs{uarg_base{type_list{}}...}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, type_list{}}; + const std::array vargs{uarg_base{registry, type_list{}}...}; return state_->is_invocable_with(vinst, vargs); } template < typename Instance, typename... Args > bool method::is_invocable_with(Instance&& instance, Args&&... args) const noexcept { using namespace detail; - const uinst_base vinst{std::forward(instance)}; - const std::array vargs{uarg_base{std::forward(args)}...}; + type_registry& registry{type_registry::instance()}; + const uinst_base vinst{registry, std::forward(instance)}; + const std::array vargs{uarg_base{registry, std::forward(args)}...}; return state_->is_invocable_with(vinst, vargs); } diff --git a/headers/meta.hpp/meta_states/scope.hpp b/headers/meta.hpp/meta_states/scope.hpp index d6a8e90..90df6d1 100644 --- a/headers/meta.hpp/meta_states/scope.hpp +++ b/headers/meta.hpp/meta_states/scope.hpp @@ -7,15 +7,14 @@ #pragma once #include "../meta_base.hpp" -#include "../meta_registry.hpp" #include "../meta_states.hpp" #include "../meta_types.hpp" -#include "../meta_types/class_type.hpp" -#include "../meta_types/enum_type.hpp" - +#include "../meta_detail/type_registry.hpp" #include "../meta_states/function.hpp" #include "../meta_states/variable.hpp" +#include "../meta_types/class_type.hpp" +#include "../meta_types/enum_type.hpp" namespace meta_hpp::detail { @@ -74,7 +73,8 @@ namespace meta_hpp template < typename... Args > function scope::get_function_with(std::string_view name) const noexcept { - return get_function_with(name, {resolve_type()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_function_with(name, {registry.resolve_type()...}); } template < typename Iter > diff --git a/headers/meta.hpp/meta_states/variable.hpp b/headers/meta.hpp/meta_states/variable.hpp index 81ab55b..7601559 100644 --- a/headers/meta.hpp/meta_states/variable.hpp +++ b/headers/meta.hpp/meta_states/variable.hpp @@ -9,13 +9,14 @@ #include "../meta_base.hpp" #include "../meta_states.hpp" +#include "../meta_detail/type_registry.hpp" #include "../meta_detail/value_utilities/uarg.hpp" #include "../meta_types/pointer_type.hpp" namespace meta_hpp::detail { template < variable_policy_kind Policy, pointer_kind Pointer > - uvalue raw_variable_getter(Pointer variable_ptr) { + uvalue raw_variable_getter(type_registry&, Pointer variable_ptr) { using pt = pointer_traits; using data_type = typename pt::data_type; @@ -47,31 +48,36 @@ namespace meta_hpp::detail } template < pointer_kind Pointer > - void raw_variable_setter([[maybe_unused]] Pointer variable_ptr, const uarg& arg) { + void raw_variable_setter(type_registry& registry, Pointer variable_ptr, const uarg& arg) { using pt = pointer_traits; using data_type = typename pt::data_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)variable_ptr; + (void)arg; META_HPP_ASSERT(false && "an attempt to set a constant variable"); } else { - META_HPP_ASSERT( // - arg.can_cast_to() // + META_HPP_ASSERT( // + arg.can_cast_to(registry) // && "an attempt to set a variable with an incorrect argument type" ); - *variable_ptr = arg.cast(); + *variable_ptr = arg.cast(registry); } } template < pointer_kind Pointer > - bool raw_variable_is_settable_with(const uarg_base& arg) { + bool raw_variable_is_settable_with(type_registry& registry, const uarg_base& arg) { using pt = pointer_traits; using data_type = typename pt::data_type; if constexpr ( std::is_const_v ) { + (void)registry; + (void)arg; return false; } else { - return arg.can_cast_to(); + return arg.can_cast_to(registry); } } } @@ -79,22 +85,24 @@ namespace meta_hpp::detail namespace meta_hpp::detail { template < variable_policy_kind Policy, pointer_kind Pointer > - variable_state::getter_impl make_variable_getter(Pointer variable_ptr) { - return [variable_ptr]() { // - return raw_variable_getter(variable_ptr); + variable_state::getter_impl make_variable_getter(type_registry& registry, Pointer variable_ptr) { + return [®istry, variable_ptr]() { // + return raw_variable_getter(registry, variable_ptr); }; } template < pointer_kind Pointer > - variable_state::setter_impl make_variable_setter(Pointer variable_ptr) { - return [variable_ptr](const uarg& arg) { // - return raw_variable_setter(variable_ptr, arg); + variable_state::setter_impl make_variable_setter(type_registry& registry, Pointer variable_ptr) { + return [®istry, variable_ptr](const uarg& arg) { // + return raw_variable_setter(registry, variable_ptr, arg); }; } template < pointer_kind Pointer > - variable_state::is_settable_with_impl make_variable_is_settable_with() { - return &raw_variable_is_settable_with; + variable_state::is_settable_with_impl make_variable_is_settable_with(type_registry& registry) { + return [®istry](const uarg_base& arg) { // + return raw_variable_is_settable_with(registry, arg); + }; } } @@ -106,10 +114,11 @@ namespace meta_hpp::detail template < variable_policy_kind Policy, pointer_kind Pointer > variable_state_ptr variable_state::make(std::string name, Pointer variable_ptr, metadata_map metadata) { - variable_state state{variable_index{resolve_type(), std::move(name)}, std::move(metadata)}; - state.getter = make_variable_getter(variable_ptr); - state.setter = make_variable_setter(variable_ptr); - state.is_settable_with = make_variable_is_settable_with(); + type_registry& registry{type_registry::instance()}; + variable_state state{variable_index{registry.resolve_type(), std::move(name)}, std::move(metadata)}; + state.getter = make_variable_getter(registry, variable_ptr); + state.setter = make_variable_setter(registry, variable_ptr); + state.is_settable_with = make_variable_is_settable_with(registry); return make_intrusive(std::move(state)); } } @@ -145,7 +154,8 @@ namespace meta_hpp template < typename Value > void variable::set(Value&& value) const { using namespace detail; - const uarg vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uarg vvalue{registry, std::forward(value)}; state_->setter(vvalue); } @@ -170,14 +180,16 @@ namespace meta_hpp template < typename Value > bool variable::is_settable_with() const noexcept { using namespace detail; - const uarg_base vvalue{type_list{}}; + type_registry& registry{type_registry::instance()}; + const uarg_base vvalue{registry, type_list{}}; return state_->is_settable_with(vvalue); } template < typename Value > bool variable::is_settable_with(Value&& value) const noexcept { using namespace detail; - const uarg_base vvalue{std::forward(value)}; + type_registry& registry{type_registry::instance()}; + const uarg_base vvalue{registry, std::forward(value)}; return state_->is_settable_with(vvalue); } } diff --git a/headers/meta.hpp/meta_types/class_type.hpp b/headers/meta.hpp/meta_types/class_type.hpp index 03bea02..7df3545 100644 --- a/headers/meta.hpp/meta_types/class_type.hpp +++ b/headers/meta.hpp/meta_types/class_type.hpp @@ -258,7 +258,8 @@ namespace meta_hpp template < typename... Args > constructor class_type::get_constructor_with() const noexcept { - return get_constructor_with({resolve_type()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_constructor_with({registry.resolve_type()...}); } template < typename Iter > @@ -297,7 +298,8 @@ 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()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_function_with(name, {registry.resolve_type()...}); } template < typename Iter > @@ -336,7 +338,8 @@ 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()...}); + detail::type_registry& registry{detail::type_registry::instance()}; + return get_method_with(name, {registry.resolve_type()...}); } template < typename Iter > diff --git a/headers/meta.hpp/meta_uvalue/uvalue.hpp b/headers/meta.hpp/meta_uvalue/uvalue.hpp index 6a5b0db..db50f39 100644 --- a/headers/meta.hpp/meta_uvalue/uvalue.hpp +++ b/headers/meta.hpp/meta_uvalue/uvalue.hpp @@ -495,8 +495,11 @@ namespace meta_hpp auto uvalue::try_get_as() noexcept -> std::conditional_t, T, T*> { static_assert(std::is_same_v>); + using detail::type_registry; + type_registry& registry{type_registry::instance()}; + const any_type& from_type = get_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -530,7 +533,7 @@ namespace meta_hpp 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 = detail::pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -547,7 +550,7 @@ namespace meta_hpp const class_type& to_class = to_type.as_class(); const class_type& from_class = from_type.as_class(); - T* to_ptr = static_cast(detail::pointer_upcast(get_data(), from_class, to_class)); + T* to_ptr = static_cast(detail::pointer_upcast(registry, get_data(), from_class, to_class)); return to_ptr; } } @@ -560,8 +563,11 @@ namespace meta_hpp auto uvalue::try_get_as() const noexcept -> std::conditional_t, T, const T*> { static_assert(std::is_same_v>); + using detail::type_registry; + type_registry& registry{type_registry::instance()}; + const any_type& from_type = get_type(); - const any_type& to_type = resolve_type(); + const any_type& to_type = registry.resolve_type(); const auto is_a = [](const any_type& base, const any_type& derived) { return (base == derived) // @@ -595,7 +601,7 @@ namespace meta_hpp 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 = detail::pointer_upcast(registry, *from_data_ptr, from_data_class, to_data_class); return static_cast(to_ptr); } } @@ -612,7 +618,7 @@ namespace meta_hpp const class_type& to_class = to_type.as_class(); const class_type& from_class = from_type.as_class(); - const T* to_ptr = static_cast(detail::pointer_upcast(get_data(), from_class, to_class)); + const T* to_ptr = static_cast(detail::pointer_upcast(registry, get_data(), from_class, to_class)); return to_ptr; } }