simplify argument states filling and checking

BlackMATov · Feb 11, 2024 · b53cb02 · b53cb02
1 parent a89f27e
commit b53cb02
Show file tree

Hide file tree

Showing 9 changed files with 125 additions and 104 deletions.
diff --git a/develop/singles/headers/meta.hpp/meta_all.hpp b/develop/singles/headers/meta.hpp/meta_all.hpp
@@ -1182,6 +1182,20 @@ namespace meta_hpp::detail
         static constexpr void for_each(F&& f) {
             (f.template operator()<Types>(), ...);
         }
+
+        template < typename F >
+        // NOLINTNEXTLINE(*-missing-std-forward)
+        static constexpr auto unpack_types(F&& f) {
+            return f.template operator()<Types...>();
+        }
+
+        template < typename F >
+        // NOLINTNEXTLINE(*-missing-std-forward)
+        static constexpr auto unpack_indices(F&& f) {
+            return [&f]<std::size_t... Is>(std::index_sequence<Is...>) {
+                return f.template operator()<Is...>();
+            }(std::index_sequence_for<Types...>());
+        }
     };
 
     template < std::size_t I >
@@ -1227,6 +1241,7 @@ namespace meta_hpp::detail
 
     template < template < typename > class Pred, typename TypeList >
     inline constexpr std::size_t type_list_count_of_v = type_list_count_of<Pred, TypeList>::value;
+
 }
 
 namespace meta_hpp::detail
@@ -6568,19 +6583,21 @@ namespace meta_hpp::detail
         if ( args.size() != type_list_arity_v<ArgTypeList> ) {
             return false;
         }
-        return [args, &registry]<std::size_t... Is>(std::index_sequence<Is...>) {
+
+        return ArgTypeList::unpack_indices([args, &registry]<std::size_t... Is>() {
             return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>(registry));
-        }(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
+        });
     }
 
     template < typename ArgTypeList >
     bool can_cast_all_uargs(type_registry& registry, std::span<const uarg_base> args) noexcept {
         if ( args.size() != type_list_arity_v<ArgTypeList> ) {
             return false;
         }
-        return [args, &registry]<std::size_t... Is>(std::index_sequence<Is...>) {
+
+        return ArgTypeList::unpack_indices([args, &registry]<std::size_t... Is>() {
             return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>(registry));
-        }(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
+        });
     }
 
     template < typename ArgTypeList, typename F >
@@ -6939,17 +6956,14 @@ namespace meta_hpp::detail::function_type_data_impl
         using ft = function_traits<Function>;
         using ft_argument_types = typename ft::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            any_type_list argument_types;
-            argument_types.reserve(type_list_arity_v<ft_argument_types>);
+        any_type_list result;
+        result.reserve(ft::arity);
 
-            [[maybe_unused]] const auto make_argument_type = []<std::size_t I>(index_constant<I>) {
-                return resolve_type<type_list_at_t<I, ft_argument_types>>();
-            };
+        ft_argument_types::for_each([&result]<typename Arg>() { //
+            result.emplace_back(resolve_type<Arg>());
+        });
 
-            (argument_types.emplace_back(make_argument_type(index_constant<Is>{})), ...);
-            return argument_types;
-        }(std::make_index_sequence<type_list_arity_v<ft_argument_types>>());
+        return result;
     }
 }
 
@@ -7074,13 +7088,14 @@ namespace meta_hpp::detail
         using ft = function_traits<std::remove_pointer_t<Function>>;
         using ft_argument_types = typename ft::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            [[maybe_unused]] const auto make_argument = []<std::size_t I>(index_constant<I>) {
-                using P = type_list_at_t<I, ft_argument_types>;
-                return argument{argument_state::make<P>(I, metadata_map{})};
-            };
-            return argument_list{make_argument(index_constant<Is>{})...};
-        }(std::make_index_sequence<ft::arity>());
+        argument_list result;
+        result.reserve(ft::arity);
+
+        ft_argument_types::unpack_indices([&result]<std::size_t... Is>() {
+            (result.emplace_back(argument_state::make<type_list_at_t<Is, ft_argument_types>>(Is, metadata_map{})), ...);
+        });
+
+        return result;
     }
 }
 
@@ -7819,17 +7834,14 @@ namespace meta_hpp::detail::method_type_data_impl
         using mt = method_traits<Method>;
         using mt_argument_types = typename mt::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            any_type_list argument_types;
-            argument_types.reserve(type_list_arity_v<mt_argument_types>);
+        any_type_list result;
+        result.reserve(mt::arity);
 
-            [[maybe_unused]] const auto make_argument_type = []<std::size_t I>(index_constant<I>) {
-                return resolve_type<type_list_at_t<I, mt_argument_types>>();
-            };
+        mt_argument_types::for_each([&result]<typename Arg>() { //
+            result.emplace_back(resolve_type<Arg>());
+        });
 
-            (argument_types.emplace_back(make_argument_type(index_constant<Is>{})), ...);
-            return argument_types;
-        }(std::make_index_sequence<type_list_arity_v<mt_argument_types>>());
+        return result;
     }
 }
 
@@ -7970,13 +7982,14 @@ namespace meta_hpp::detail
         using mt = method_traits<Method>;
         using mt_argument_types = typename mt::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            [[maybe_unused]] const auto make_argument = []<std::size_t I>(index_constant<I>) {
-                using P = type_list_at_t<I, mt_argument_types>;
-                return argument{argument_state::make<P>(I, metadata_map{})};
-            };
-            return argument_list{make_argument(index_constant<Is>{})...};
-        }(std::make_index_sequence<mt::arity>());
+        argument_list result;
+        result.reserve(mt::arity);
+
+        mt_argument_types::unpack_indices([&result]<std::size_t... Is>() {
+            (result.emplace_back(argument_state::make<type_list_at_t<Is, mt_argument_types>>(Is, metadata_map{})), ...);
+        });
+
+        return result;
     }
 }
 
@@ -8564,17 +8577,14 @@ namespace meta_hpp::detail::constructor_type_data_impl
         using ct = constructor_traits<Class, Args...>;
         using ct_argument_types = typename ct::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            any_type_list argument_types;
-            argument_types.reserve(type_list_arity_v<ct_argument_types>);
+        any_type_list result;
+        result.reserve(ct::arity);
 
-            [[maybe_unused]] const auto make_argument_type = []<std::size_t I>(index_constant<I>) {
-                return resolve_type<type_list_at_t<I, ct_argument_types>>();
-            };
+        ct_argument_types::for_each([&result]<typename Arg>() { //
+            result.emplace_back(resolve_type<Arg>());
+        });
 
-            (argument_types.emplace_back(make_argument_type(index_constant<Is>{})), ...);
-            return argument_types;
-        }(std::make_index_sequence<type_list_arity_v<ct_argument_types>>());
+        return result;
     }
 }
 
@@ -8728,13 +8738,14 @@ namespace meta_hpp::detail
         using ct = constructor_traits<Class, Args...>;
         using ct_argument_types = typename ct::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            [[maybe_unused]] const auto make_argument = []<std::size_t I>(index_constant<I>) {
-                using P = type_list_at_t<I, ct_argument_types>;
-                return argument{argument_state::make<P>(I, metadata_map{})};
-            };
-            return argument_list{make_argument(index_constant<Is>{})...};
-        }(std::make_index_sequence<ct::arity>());
+        argument_list result;
+        result.reserve(ct::arity);
+
+        ct_argument_types::unpack_indices([&result]<std::size_t... Is>() {
+            (result.emplace_back(argument_state::make<type_list_at_t<Is, ct_argument_types>>(Is, metadata_map{})), ...);
+        });
+
+        return result;
     }
 }
 

diff --git a/headers/meta.hpp/meta_base/type_list.hpp b/headers/meta.hpp/meta_base/type_list.hpp
@@ -17,6 +17,20 @@ namespace meta_hpp::detail
         static constexpr void for_each(F&& f) {
             (f.template operator()<Types>(), ...);
         }
+
+        template < typename F >
+        // NOLINTNEXTLINE(*-missing-std-forward)
+        static constexpr auto unpack_types(F&& f) {
+            return f.template operator()<Types...>();
+        }
+
+        template < typename F >
+        // NOLINTNEXTLINE(*-missing-std-forward)
+        static constexpr auto unpack_indices(F&& f) {
+            return [&f]<std::size_t... Is>(std::index_sequence<Is...>) {
+                return f.template operator()<Is...>();
+            }(std::index_sequence_for<Types...>());
+        }
     };
 
     template < std::size_t I >

diff --git a/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp b/headers/meta.hpp/meta_detail/value_utilities/uarg.hpp
@@ -367,19 +367,21 @@ namespace meta_hpp::detail
         if ( args.size() != type_list_arity_v<ArgTypeList> ) {
             return false;
         }
-        return [args, &registry]<std::size_t... Is>(std::index_sequence<Is...>) {
+
+        return ArgTypeList::unpack_indices([args, &registry]<std::size_t... Is>() {
             return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>(registry));
-        }(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
+        });
     }
 
     template < typename ArgTypeList >
     bool can_cast_all_uargs(type_registry& registry, std::span<const uarg_base> args) noexcept {
         if ( args.size() != type_list_arity_v<ArgTypeList> ) {
             return false;
         }
-        return [args, &registry]<std::size_t... Is>(std::index_sequence<Is...>) {
+
+        return ArgTypeList::unpack_indices([args, &registry]<std::size_t... Is>() {
             return (... && args[Is].can_cast_to<type_list_at_t<Is, ArgTypeList>>(registry));
-        }(std::make_index_sequence<type_list_arity_v<ArgTypeList>>());
+        });
     }
 
     template < typename ArgTypeList, typename F >

diff --git a/headers/meta.hpp/meta_states/constructor.hpp b/headers/meta.hpp/meta_states/constructor.hpp
@@ -130,13 +130,14 @@ namespace meta_hpp::detail
         using ct = constructor_traits<Class, Args...>;
         using ct_argument_types = typename ct::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            [[maybe_unused]] const auto make_argument = []<std::size_t I>(index_constant<I>) {
-                using P = type_list_at_t<I, ct_argument_types>;
-                return argument{argument_state::make<P>(I, metadata_map{})};
-            };
-            return argument_list{make_argument(index_constant<Is>{})...};
-        }(std::make_index_sequence<ct::arity>());
+        argument_list result;
+        result.reserve(ct::arity);
+
+        ct_argument_types::unpack_indices([&result]<std::size_t... Is>() {
+            (result.emplace_back(argument_state::make<type_list_at_t<Is, ct_argument_types>>(Is, metadata_map{})), ...);
+        });
+
+        return result;
     }
 }
 

diff --git a/headers/meta.hpp/meta_states/function.hpp b/headers/meta.hpp/meta_states/function.hpp
@@ -101,13 +101,14 @@ namespace meta_hpp::detail
         using ft = function_traits<std::remove_pointer_t<Function>>;
         using ft_argument_types = typename ft::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            [[maybe_unused]] const auto make_argument = []<std::size_t I>(index_constant<I>) {
-                using P = type_list_at_t<I, ft_argument_types>;
-                return argument{argument_state::make<P>(I, metadata_map{})};
-            };
-            return argument_list{make_argument(index_constant<Is>{})...};
-        }(std::make_index_sequence<ft::arity>());
+        argument_list result;
+        result.reserve(ft::arity);
+
+        ft_argument_types::unpack_indices([&result]<std::size_t... Is>() {
+            (result.emplace_back(argument_state::make<type_list_at_t<Is, ft_argument_types>>(Is, metadata_map{})), ...);
+        });
+
+        return result;
     }
 }
 

diff --git a/headers/meta.hpp/meta_states/method.hpp b/headers/meta.hpp/meta_states/method.hpp
@@ -113,13 +113,14 @@ namespace meta_hpp::detail
         using mt = method_traits<Method>;
         using mt_argument_types = typename mt::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            [[maybe_unused]] const auto make_argument = []<std::size_t I>(index_constant<I>) {
-                using P = type_list_at_t<I, mt_argument_types>;
-                return argument{argument_state::make<P>(I, metadata_map{})};
-            };
-            return argument_list{make_argument(index_constant<Is>{})...};
-        }(std::make_index_sequence<mt::arity>());
+        argument_list result;
+        result.reserve(mt::arity);
+
+        mt_argument_types::unpack_indices([&result]<std::size_t... Is>() {
+            (result.emplace_back(argument_state::make<type_list_at_t<Is, mt_argument_types>>(Is, metadata_map{})), ...);
+        });
+
+        return result;
     }
 }
 

diff --git a/headers/meta.hpp/meta_types/constructor_type.hpp b/headers/meta.hpp/meta_types/constructor_type.hpp
@@ -20,17 +20,14 @@ namespace meta_hpp::detail::constructor_type_data_impl
         using ct = constructor_traits<Class, Args...>;
         using ct_argument_types = typename ct::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            any_type_list argument_types;
-            argument_types.reserve(type_list_arity_v<ct_argument_types>);
+        any_type_list result;
+        result.reserve(ct::arity);
 
-            [[maybe_unused]] const auto make_argument_type = []<std::size_t I>(index_constant<I>) {
-                return resolve_type<type_list_at_t<I, ct_argument_types>>();
-            };
+        ct_argument_types::for_each([&result]<typename Arg>() { //
+            result.emplace_back(resolve_type<Arg>());
+        });
 
-            (argument_types.emplace_back(make_argument_type(index_constant<Is>{})), ...);
-            return argument_types;
-        }(std::make_index_sequence<type_list_arity_v<ct_argument_types>>());
+        return result;
     }
 }
 

diff --git a/headers/meta.hpp/meta_types/function_type.hpp b/headers/meta.hpp/meta_types/function_type.hpp
@@ -20,17 +20,14 @@ namespace meta_hpp::detail::function_type_data_impl
         using ft = function_traits<Function>;
         using ft_argument_types = typename ft::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            any_type_list argument_types;
-            argument_types.reserve(type_list_arity_v<ft_argument_types>);
+        any_type_list result;
+        result.reserve(ft::arity);
 
-            [[maybe_unused]] const auto make_argument_type = []<std::size_t I>(index_constant<I>) {
-                return resolve_type<type_list_at_t<I, ft_argument_types>>();
-            };
+        ft_argument_types::for_each([&result]<typename Arg>() { //
+            result.emplace_back(resolve_type<Arg>());
+        });
 
-            (argument_types.emplace_back(make_argument_type(index_constant<Is>{})), ...);
-            return argument_types;
-        }(std::make_index_sequence<type_list_arity_v<ft_argument_types>>());
+        return result;
     }
 }
 

diff --git a/headers/meta.hpp/meta_types/method_type.hpp b/headers/meta.hpp/meta_types/method_type.hpp
@@ -20,17 +20,14 @@ namespace meta_hpp::detail::method_type_data_impl
         using mt = method_traits<Method>;
         using mt_argument_types = typename mt::argument_types;
 
-        return []<std::size_t... Is>(std::index_sequence<Is...>) {
-            any_type_list argument_types;
-            argument_types.reserve(type_list_arity_v<mt_argument_types>);
+        any_type_list result;
+        result.reserve(mt::arity);
 
-            [[maybe_unused]] const auto make_argument_type = []<std::size_t I>(index_constant<I>) {
-                return resolve_type<type_list_at_t<I, mt_argument_types>>();
-            };
+        mt_argument_types::for_each([&result]<typename Arg>() { //
+            result.emplace_back(resolve_type<Arg>());
+        });
 
-            (argument_types.emplace_back(make_argument_type(index_constant<Is>{})), ...);
-            return argument_types;
-        }(std::make_index_sequence<type_list_arity_v<mt_argument_types>>());
+        return result;
     }
 }