Main KUMI namespace. More...
Main KUMI namespace.
Classes | |
| struct | all_unique_names |
| Checks if a parameter pack only contains distinct kumi::field_member names. Evaluates to false if no type is a kumi::field_member. More... | |
| struct | all_uniques |
| Checks if a parameter pack only contains distinct types. More... | |
| class | as |
| Lightweight type-wrapper. More... | |
| struct | as_tuple |
| Generate a kumi::tuple type from a type. More... | |
| class | boolean_and |
| A type representing the logical and monoid and it's associated identity. The identity of the boolean_and is true. More... | |
| class | boolean_or |
| A type representing the logical or monoid and it's associated identity. The identity of boolean_or is false. More... | |
| class | boolean_xor |
| A type representing the logical xor monoid and it's associated identity. The identity of boolean_xor is false. More... | |
| class | builder |
| Helper structure to build the correct output product_type. If the provided Product type is a not a record_type the builder will output a tuple otherwise a record. More... | |
| struct | common_product_type |
| Extracts the common product_type of a parameter pack, if all the types are record then it returns an empty record, otherwise returns an empty kumi::tuple. As we are unable to compute the Least Restrictive Subtypes of a pack, this trait should be specialized for each case one would want to write. More... | |
| struct | container_size |
| Returns the number of elements of a kumi::static_container. More... | |
| struct | container_type |
| Provides access to the type of the elements of a kumi::static_container. More... | |
| struct | element |
| Provides indexed access to the types of the elements of a kumi::product_type. More... | |
| class | field |
| Named wrapper over a type. More... | |
| struct | field< Id, T > |
| Specialisation to clearly indicate an error. More... | |
| struct | identifier |
| identifier definition class More... | |
| struct | index_t |
| Integral constant type. More... | |
| class | indexes_t |
| Compile time tuple of index used to pass several indexes_t as NTTP. More... | |
| struct | is_homogeneous |
| Detects if a given kwk::product_type instance is homogeneous. More... | |
| struct | is_product_type |
| Detects if a type follows the tuple protocol. More... | |
| struct | is_record_type |
| Opt-in traits for types behaving like a kumi::product_type. More... | |
| struct | is_static_container |
| Traits detecting types behaving like a kumi::static_container. More... | |
| struct | member |
| Computes the return type of a call to kumi::get. More... | |
| struct | name |
| Compile-time text based ID. More... | |
| class | numeric_add |
| A type representing the addition monoid with it's associated identity. The identity of the addition is 0. More... | |
| class | numeric_prod |
| A type representing the multiplication monoid with it's associated identity. The identity of the multiplication is 1. More... | |
| struct | raw_element |
| Provides indexed access to the types of the elements of a kumi::product_type and unwraps the returned field for kumi::record_type. More... | |
| struct | raw_member |
| Computes the return type of a call to kumi::get on a kumi::tuple and unwrap the field returned by kumi::get on a kumi::record. More... | |
| class | record |
| Fixed-size collection of heterogeneous fields necessarily named, names are unique. More... | |
| struct | size |
| Computes the number of elements of a kumi::product_type. More... | |
| class | str |
| Static string used to create named fields. More... | |
| class | tuple |
| Fixed-size collection of heterogeneous values. More... | |
| class | unit |
| A type representing the product of no type also called the unit type. More... | |
| struct | unknown |
| Type indicating a identifier was not found in a given kumi::product_type. More... | |
Functions | |
| template<concepts::product_type T> | |
| constexpr auto | all_of (T &&ts) noexcept |
| Computes the reduction of a tuple over the && operator. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr auto | all_of (T &&ts, Pred p) noexcept |
| Checks if unary predicate p returns true for all elements in the value t. | |
| template<concepts::product_type T> | |
| constexpr auto | all_unique (T &&t) |
| Return the product type containing the values of the first occurence of each type in the input product type. | |
| template<concepts::product_type T> | |
| constexpr auto | any_of (T &&ts) noexcept |
| Computes the reduction of a tuple over the || operator. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr auto | any_of (T &&ts, Pred p) noexcept |
| Checks if unary predicate p returns true for any elements in the value t. | |
| template<typename Function, concepts::product_type T> requires _::supports_apply<Function, T> | |
| constexpr decltype(auto) | apply (Function &&f, T &&t) noexcept(_::supports_nothrow_apply< Function &&, T && >) |
| Invoke the Callable object f with a product_type of arguments. f is applied on the values if the given product_type is a kumi::record. | |
| template<concepts::product_type T> | |
| auto | as_flat_ptr (T &&t) noexcept |
| Convert a kumi::product_type to a flat product type of pointers to each its components. | |
| template<concepts::product_type Tuple> requires (size_v<Tuple> != 0) | |
| constexpr decltype(auto) | back (Tuple &&t) |
| Retrieves the back of a tuple. | |
| template<concepts::product_type T> | |
| constexpr auto | bit_and (T &&t) |
| Computes the bitwise AND of all elements. | |
| template<concepts::product_type T, typename Value> | |
| constexpr auto | bit_and (T &&t, Value init) |
| Computes the bitwise AND of all elements. | |
| template<concepts::product_type T> | |
| constexpr auto | bit_or (T &&t) |
| Computes the bitwise OR of all elements. | |
| template<concepts::product_type T, typename Value> | |
| constexpr auto | bit_or (T &&t, Value init) |
| Computes the bitwise OR of all elements. | |
| template<concepts::product_type T> | |
| constexpr auto | bit_xor (T &&t) |
| Computes the bitwise XOR of all elements. | |
| template<concepts::product_type T, typename Value> | |
| constexpr auto | bit_xor (T &&t, Value init) |
| Computes the bitwise XOR of all elements. | |
| template<_::identifier auto Name, typename T> | |
| decltype(auto) constexpr | capture_field (T &&t) noexcept |
| Creates a field from a given value keeping the qualifiers. | |
| template<concepts::product_type... Ts> requires (concepts::follows_same_semantic<Ts...>) | |
| constexpr auto | cartesian_product (Ts &&... ts) |
| Return the Cartesian Product of all elements of its arguments product types. | |
| template<concepts::product_type... Ts> requires (concepts::follows_same_semantic<Ts...>) | |
| constexpr auto | cat (Ts &&... ts) |
| Concatenates product types in a single one. | |
| template<std::size_t N, concepts::product_type T> | |
| constexpr auto | chunks (T &&t) |
| Creates a kumi::tuple of product_types, each containing N consecutive elements from t. Chunks starts at 0 and advance by N element each time. | |
| template<concepts::product_type T, concepts::identifier K> | |
| constexpr bool | contains (T &&t, K const &k) noexcept |
| Checks if product type contains a given identifier. | |
| template<concepts::product_type T, concepts::identifier... Ks> | |
| constexpr bool | contains_any (T &&t, Ks const &... ks) noexcept |
| Checks if product type contains at least one of many identifier. | |
| template<concepts::product_type T, concepts::identifier... Ks> | |
| constexpr bool | contains_none (T &&t, Ks const &... ks) noexcept |
| Checks if product type contains no fields based on any of the selected identifiers. | |
| template<concepts::product_type T, concepts::identifier... Ks> | |
| constexpr bool | contains_only (T &&t, Ks const &... ks) noexcept |
| Checks if product type contains fields based only on selected identifiers. | |
| template<concepts::product_type T> | |
| constexpr std::size_t | count (T &&ts) noexcept |
| Counts the number of elements of t not equivalent to false. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr std::size_t | count_if (T &&ts, Pred p) noexcept |
| Counts the number of elements of t satisfying predicates p. | |
| template<typename Function, concepts::product_type T, typename Value> | |
| constexpr auto | exclusive_scan_left (Function f, T &&t, Value init) |
| Computes the exclusive prefix scan of all elements of a product type using a tail recursive call. | |
| template<concepts::monoid M, concepts::sized_product_type_or_more< 1 > T> | |
| constexpr auto | exclusive_scan_left (M &&m, T &&t) |
| Computes the exclusive prefix scan of all elements of a product type using a tail recursive call. | |
| template<typename Function, concepts::product_type T, typename Value> | |
| constexpr auto | exclusive_scan_right (Function f, T &&t, Value init) |
| Computes the exclusive suffix scan of all elements of a product type using a tail recursive call. | |
| template<concepts::monoid M, concepts::sized_product_type_or_more< 1 > T> | |
| constexpr auto | exclusive_scan_right (M &&m, T &&t) |
| Computes the exclusive suffix scan of all elements of a product type using a non-tail recursive call. | |
| template<std::size_t I0, concepts::product_type Tuple> | |
| constexpr auto | extract (Tuple &&t, index_t< I0 > i0) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I0, std::size_t I1, concepts::product_type Tuple> | |
| constexpr auto | extract (Tuple &&t, index_t< I0 > i0, index_t< I1 > i1) noexcept |
| Extracts a sub-tuple from a product type. | |
| template<typename U, typename T> | |
| decltype(auto) constexpr | field_cast (T &&t) noexcept |
| Casts the provided value to the target type using static_cast. | |
| template<typename T> | |
| constexpr decltype(auto) | field_value_of (T &&t) noexcept |
| Extracts the value from a kumi::field or returns the parameter. | |
| template<std::size_t N, typename T> | |
| constexpr auto | fill (T const &v) noexcept |
| Creates a kumi::tuple containing N copies of v. | |
| template<template< typename > typename Pred, concepts::product_type T> | |
| constexpr auto | filter (T &&t) noexcept |
| Filters a product type over a predicate. | |
| template<template< typename > typename Pred, concepts::product_type T> | |
| constexpr auto | filter_not (T &&t) noexcept |
| Filters a product type over a predicate. | |
| template<concepts::product_type T> | |
| constexpr auto | flatten (T &&t) |
| Converts a product type of product types into a product type of all elements. | |
| template<concepts::product_type T> | |
| constexpr auto | flatten_all (T &&t) |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::product_type T, typename Func> | |
| constexpr auto | flatten_all (T &&t, Func f) |
| Recursively converts a product type of product types into a product type of all elements. | |
| template<typename Function, concepts::sized_product_type_or_more< 1 > T> | |
| constexpr auto | fold_left (Function f, T &&t) |
| Computes the generalized associative combination of all elements using a tail recursive call. | |
| template<typename Function, concepts::product_type T, typename Value> | |
| constexpr auto | fold_left (Function f, T &&t, Value init) |
| Computes the generalized combination of all elements using a tail recursive call. | |
| template<typename Function, concepts::sized_product_type_or_more< 1 > T> | |
| constexpr auto | fold_right (Function f, T &&t) |
| Computes the generalized associative combinationof all elements using a non-tail recursive call. | |
| template<typename Function, concepts::product_type T, typename Value> | |
| constexpr auto | fold_right (Function f, T &&t, Value init) |
| Computes the generalized combination of all elements using a non-tail recursive call. | |
| template<typename Function, concepts::product_type Tuple, concepts::product_type... Tuples> requires ((concepts::compatible_product_types<Tuple, Tuples...>) && (_::supports_call<Function&, Tuple, Tuples...>)) | |
| constexpr void | for_each (Function f, Tuple &&t, Tuples &&... ts) |
| Applies the Callable object f on each element of a kumi::product_type. f is applied on the values if the given product_type is a kumi::record. | |
| template<typename Function, concepts::record_type Tuple, concepts::record_type... Tuples> | |
| constexpr void | for_each_field (Function f, Tuple &&t, Tuples &&... ts) |
| Applies the Callable object f on each element of a kumi::record_type and its field. | |
| template<typename Function, concepts::product_type Tuple, concepts::product_type... Tuples> | |
| constexpr void | for_each_index (Function f, Tuple &&t, Tuples &&... ts) |
| Applies the Callable object f on each element of a kumi::product_type and its index. | |
| template<concepts::product_type Tuple> requires (size_v<Tuple> != 0) | |
| constexpr decltype(auto) | front (Tuple &&t) |
| Retrieves the front of a tuple. | |
| template<std::size_t N, typename Function> | |
| constexpr auto | generate (Function const &f) noexcept |
| Creates a kumi::tuple containing N applications of the f Callable. | |
| template<typename U, typename R> | |
| constexpr auto | get (R &&r)=delete |
| No get<type> on records. | |
| template<concepts::identifier auto S, typename R> | |
| constexpr auto | get (R &&r)=delete |
| Improves diagnostic for non present name. | |
| template<str S, typename R> | |
| constexpr auto | get (R &&r)=delete |
| Improves diagnostic for non present name. | |
| template<std::integral auto I, typename R> | |
| constexpr auto | get (R &&r)=delete |
| Improves diagnostic for out of bounds index. | |
| template<std::integral auto I, typename T> | |
| constexpr auto | get (T &&r)=delete |
| Improves diagnostic for out of bounds index. | |
| template<typename U, typename T> | |
| constexpr auto | get (T &&t)=delete |
| No get<type> on records. | |
| template<concepts::identifier auto S, typename T> | |
| constexpr auto | get (T &&t)=delete |
| Improves diagnostic for non present identifier. | |
| template<str S, typename T> | |
| constexpr auto | get (T &&t)=delete |
| Improves diagnostic for non present name. | |
| template<concepts::identifier Name, concepts::product_type T> | |
| consteval auto | get_index_of_field () |
| Helper to retrive the index of a type in a product type by it s name. | |
| template<typename U, concepts::product_type T> | |
| consteval auto | get_index_of_type () |
| Helper to retrive the index of a type in a product type by it s type. | |
| template<typename Function, concepts::product_type T, typename Value> | |
| constexpr auto | inclusive_scan_left (Function f, T &&t, Value init) |
| Computes the inclusive prefix scan of all elements of a product type using a tail recursive call. | |
| template<concepts::monoid M, concepts::sized_product_type_or_more< 1 > T> | |
| constexpr auto | inclusive_scan_left (M &&m, T &&t) |
| Computes the inclusive prefix scan of all elements of a product type using a tail recursive call. | |
| template<typename Function, concepts::product_type T, typename Value> | |
| constexpr auto | inclusive_scan_right (Function f, T &&t, Value init) |
| Computes the inclusive suffix scan of all elements of a product type using a non-tail recursive call. | |
| template<concepts::monoid M, concepts::sized_product_type_or_more< 1 > T> | |
| constexpr auto | inclusive_scan_right (M &&m, T &&t) |
| Computes the inclusive suffix scan of all elements of a product type using a non-tail recursive call. | |
| template<concepts::indexer... Ts> | |
| consteval auto | indexes (Ts... ts) noexcept |
| Creates a kumi::indexes object, deducing the target type from the types of arguments. | |
| template<concepts::indexer... Ts> | |
| KUMI_CUDA | indexes_t (Ts...) -> indexes_t< Ts... > |
| kumi::indexes_t deduction guide | |
| template<concepts::product_type S1, concepts::sized_product_type< size_v< S1 > > S2, typename T> | |
| constexpr auto | inner_product (S1 &&s1, S2 &&s2, T init) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::product_type S1, concepts::sized_product_type< size_v< S1 > > S2, typename T, typename Sum, typename Prod> | |
| constexpr auto | inner_product (S1 &&s1, S2 &&s2, T init, Sum sum, Prod prod) noexcept |
| Computes inner product (i.e. sum of products). | |
| template<typename C, typename... Ts> requires (std::is_invocable<C, Ts...>::value) | |
| constexpr decltype(auto) | invoke (C &&c, Ts &&... ts) noexcept(std::is_nothrow_invocable< C, Ts... >::value) |
| Invoke the Callable object c with a pack of arguments. | |
| template<typename R, typename C, typename... Ts> requires (std::is_invocable_r<R, C, Ts...>::value) | |
| constexpr R | invoke_r (C &&c, Ts &&... ts) noexcept(std::is_nothrow_invocable_r< R, C, Ts... >::value) |
| Invoke the Callable object c with a pack of arguments with return type R. | |
| template<std::size_t N, typename T> | |
| constexpr auto | iota (T v) noexcept |
| Creates a kumi::tuple containing an increasing ramp of values. | |
| template<typename Pred, concepts::product_type Tuple> | |
| constexpr auto | locate (Tuple &&t, Pred p) noexcept |
| Return the index of a value which type satisfies a given predicate. | |
| template<concepts::product_type Tuple, typename Function, concepts::sized_product_type< size_v< Tuple > >... Tuples> requires (concepts::compatible_product_types<Tuple, Tuples...> && _::supports_call<Function, Tuple &&, Tuples && ...>) | |
| constexpr auto | map (Function f, Tuple &&t0, Tuples &&... others) |
| Apply the Callable object f on each tuples' elements. | |
| template<concepts::record_type Tuple, typename Function, concepts::sized_product_type< size< Tuple >::value >... Tuples> | |
| constexpr auto | map_field (Function f, Tuple &&t0, Tuples &&... others) |
| Apply the Callable object f on each records' elements and their field names. | |
| template<concepts::product_type Tuple, typename Function, concepts::sized_product_type< size_v< Tuple > >... Tuples> requires (!concepts::record_type<Tuple> && (!concepts::record_type<Tuples> && ...)) | |
| constexpr auto | map_index (Function f, Tuple &&t0, Tuples &&... others) |
| Apply the Callable object f on each tuples' elements and their indexes. | |
| template<concepts::product_type T, concepts::monoid M, typename Function> | |
| constexpr auto | map_reduce (Function f, M &&m, T &&t) |
| Performs a tree-like reduction of all elements of a product type. The given map function is applied before excution the reduction to each element of the input. | |
| template<concepts::monoid M, concepts::product_type T, typename Function, typename Value> | |
| constexpr auto | map_reduce (Function f, M &&m, T &&t, Value init) |
| Performs a tree-like reduction of all elements of a product type. The given map function is applied before excution the reduction to each element of the input. | |
| template<concepts::product_type T> | |
| constexpr auto | max (T &&t) noexcept |
| Computes the maximum value all elements of t. | |
| template<concepts::product_type T, typename F> | |
| constexpr auto | max (T &&t, F f) noexcept |
| Computes the maximum value of applications of f to all elements of t. | |
| template<concepts::product_type T, typename F> | |
| constexpr auto | max_flat (T &&t, F f) noexcept |
| Computes the maximum value of applications of f to all elements of kumi::flatten_all(t). | |
| template<typename Target, concepts::product_type T> | |
| constexpr auto | member_cast (T &&t) |
| Converts a product_type<Ts...> to an instance of a product_type<Target...>. | |
| template<concepts::product_type T> | |
| constexpr auto | members_of (as< T >) noexcept |
| Extracts the names of the fields of a kumi::product_type. | |
| template<concepts::product_type T> | |
| constexpr auto | min (T &&t) noexcept |
| Computes the minimum value all elements of t. | |
| template<concepts::product_type T, typename F> | |
| constexpr auto | min (T &&t, F f) noexcept |
| Computes the minimum value of applications of f to all elements of t. | |
| template<concepts::product_type T, typename F> | |
| constexpr auto | min_flat (T &&t, F f) noexcept |
| Computes the minimum value of applications of f to all elements of kumi::flatten_all(t). | |
| template<typename T> | |
| consteval auto | name_of () noexcept |
| Extracts the name from a kumi::field or returns the parameter. | |
| template<concepts::product_type Tuple> | |
| constexpr bool | none_of (Tuple &&ts) noexcept |
| Checks no elements of a tuple are true. | |
| template<typename Pred, concepts::product_type Tuple> | |
| constexpr bool | none_of (Tuple &&ts, Pred p) noexcept |
| Checks if unary predicate p returns true for no elements in the value t. | |
| template<char... c> | |
| constexpr auto | operator""_c () noexcept |
| Forms a integral constant literal of the desired value. | |
| template<kumi::str ID> | |
| constexpr auto | operator""_id () noexcept |
| Forms a constant string literal of the desired value. | |
| template<concepts::identifier L, kumi::concepts::identifier R> | |
| constexpr bool | operator== (L const &, R const &) |
| identifier comparison | |
| template<template< typename > typename Pred, concepts::product_type T> | |
| constexpr auto | partition (T &&t) noexcept |
| Partition a product type over a predicate. | |
| template<concepts::product_type Tuple> | |
| constexpr auto | pop_back (Tuple &&t) |
| Remove the last (if any) element of a kumi::product_type. | |
| template<concepts::product_type Tuple> | |
| constexpr auto | pop_front (Tuple &&t) |
| Remove the first (if any) element of a kumi::product_type. | |
| template<template< class > class Pred> | |
| constexpr auto | predicate () noexcept |
| Convert a unary template meta-program in a running predicate. | |
| template<concepts::product_type T> | |
| constexpr auto | prod (T &&t) |
| Computes the product of all elements. | |
| template<concepts::product_type T, typename Value> | |
| constexpr auto | prod (T &&t, Value init) |
| Computes the product of all elements. | |
| template<concepts::product_type Tuple, typename T> | |
| constexpr auto | push_back (Tuple &&t, T &&v) |
| Constructs a tuple by adding a value v at the end of t. | |
| template<concepts::product_type Tuple, typename T> | |
| constexpr auto | push_front (Tuple &&t, T &&v) |
| Constructs a tuple by adding a value v at the beginning of t. | |
| template<concepts::monoid M, concepts::product_type T> | |
| constexpr auto | reduce (M &&m, T &&t) |
| Performs a tree-like reduction of all elements of a product type. | |
| template<concepts::monoid M, concepts::product_type T, typename Value> | |
| constexpr auto | reduce (M &&m, T &&t, Value init) |
| Performs a tree-like reduction of all elements of a product type. | |
| template<concepts::index_map auto Indexes, concepts::product_type T> | |
| constexpr auto | reindex (T &&t) |
| Reindex elements of a kumi::product_type. | |
| template<std::size_t... Idx, concepts::product_type T> | |
| constexpr auto | reorder (T &&t) |
| Reorder elements of a kumi::product_type. | |
| template<concepts::identifier auto... Name, concepts::product_type Tuple> | |
| constexpr auto | reorder_fields (Tuple &&t) |
| Reorder elements of a kumi::record. | |
| template<concepts::product_type Tuple> | |
| constexpr auto | reverse (Tuple &&t) |
| Reverse elements of a kumi::product_type. | |
| template<std::size_t R, concepts::product_type T> | |
| constexpr auto | rotate_left (T &&t) |
| Rotates the element of a product type R positions to the left, wrapping around when getting to the beginning. | |
| template<std::size_t R, concepts::product_type T> | |
| constexpr auto | rotate_right (T &&t) |
| Rotates the element of a product type R positions to the right, wrapping around when getting to the end. | |
| template<std::size_t I0, concepts::product_type Tuple> | |
| constexpr auto | split (Tuple &&t, index_t< I0 > i0) noexcept |
| Split a tuple into two. | |
| template<concepts::product_type T> | |
| constexpr auto | sum (T &&t) |
| Computes the sum of all elements. | |
| template<concepts::product_type T, typename Value> | |
| constexpr auto | sum (T &&t, Value init) |
| Computes the sum of all elements. | |
| template<concepts::product_type T> requires (_::supports_transpose<T>) | |
| constexpr auto | transpose (T &&t) |
| Transpose a product type of product types by shifting elements in their transposed position always returning a tuple as the external product type. | |
| template<concepts::product_type T> | |
| constexpr auto | unique (T &&t) |
| Returns a product type with consecutive duplicate types removed (pairwise uniqueness). | |
| template<concepts::product_type T> | |
| constexpr auto | values_of (T &&t) noexcept |
| Extracts the values of the fields of a kumi::product_type. | |
| template<std::size_t N, concepts::product_type T> | |
| constexpr auto | windows (T &&t) |
| Creates a kumi::tuple of product_types, each containing N consecutive elements from t. Windows starts at 0 and advance by 1 element each time. | |
| template<concepts::product_type T0, concepts::sized_product_type< size_v< T0 > >... Ts> requires (concepts::follows_same_semantic<T0, Ts...>) | |
| constexpr auto | zip (T0 &&t0, Ts &&... ts) |
| Constructs a tuple where the ith element is the prduct type of all ith elements of ts... | |
| template<concepts::product_type T0, concepts::product_type... Ts> requires (concepts::follows_same_semantic<T0, Ts...>) | |
| constexpr auto | zip_max (T0 &&t0, Ts &&... ts) |
| Constructs a tuple where the ith element is the product type of all ith elements of ts... | |
| template<concepts::product_type T0, concepts::product_type... Ts> requires (concepts::follows_same_semantic<T0, Ts...>) | |
| constexpr auto | zip_min (T0 &&t0, Ts &&... ts) |
| Constructs a tuple where the ith element is the prudct type of all ith elements of ts... | |
Record Deduction Guides | |
| template<typename... Ts> | |
| KUMI_CUDA | record (Ts &&...) -> record< std::unwrap_ref_decay_t< Ts >... > |
| kumi::record deduction guide | |
Tuple Deduction Guides | |
| template<typename... Ts> | |
| KUMI_CUDA | tuple (Ts &&...) -> tuple< std::unwrap_ref_decay_t< Ts >... > |
| kumi::tuple deduction guide | |
Variables | |
| template<template< class > typename Traits> | |
| constexpr traits_check< Traits > | if_ = {} |
| Option specifying a traits that type should verify for being used as a identifier value. | |
| template<std::size_t N> | |
| constexpr index_t< N > const | index = {} |
| Inline integral constant value for kumi::index_t. | |
| template<typename T> | |
| constexpr auto | is_index_map_v = requires { T::is_index_map; } |
| Checks if a type can be used as a kumi::index_map. | |
| constexpr unit | none = {} |
| Inline constant representing a kumi::unit. | |
| template<typename T> | |
| constexpr only_t< T > | only = {} |
| Option specifying the single type a identifier will accept. | |
Tuple conversions | |
|
template<concepts::static_container S> requires (!concepts::product_type<S>) | |
| constexpr auto | to_tuple (S &&s) |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename Type, typename... Ts> | |
| constexpr auto | from_tuple (tuple< Ts... > const &t) |
| Converts a kumi::tuple to an instance of an arbitrary type. | |
| template<concepts::product_type T> | |
| constexpr auto | to_tuple (T &&t) |
| Converts a kumi::product_type to an instance kumi::tuple. | |
Record construction | |
| template<concepts::identifier auto... Fields, typename... Ts> | |
| constexpr auto | tie (Ts &... ts) -> record< field< decltype(Fields), Ts & >... > |
| Creates a kumi::record of lvalue references to its arguments. | |
| template<concepts::identifier auto... Fields, typename... Ts> | |
| constexpr auto | forward_as_record (Ts &&... ts) -> record< field< decltype(Fields), Ts && >... > |
| Creates a kumi::record of forwarding references to its arguments. | |
| template<typename... Ts> | |
| constexpr auto | make_record (Ts &&... ts) -> record< std::unwrap_ref_decay_t< Ts >... > |
| Creates a record object, deducing the target type from the types of arguments. | |
| template<concepts::record_type R> | |
| constexpr auto | to_ref (R &&r) |
| Creates a kumi::record of references given a reference to a kumi::record_type. | |
Accessors | |
| template<std::size_t I, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<str Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<str Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<str Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > &r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Name, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename T, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename T, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename T, typename... Ts> | |
| constexpr decltype(auto) | get (record< Ts... > const &&r) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > &&arg) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &arg) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &&arg) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<str S, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > &&t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<str S, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<str S, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &&t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Id, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > &&t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Id, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<concepts::identifier auto Id, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &&t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename T, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > &&t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename T, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<typename T, typename... Ts> | |
| constexpr decltype(auto) | get (tuple< Ts... > const &&t) noexcept |
| This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &r) noexcept |
| Extracts the Ith field from a kumi::record. | |
| template<str Name, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &r) noexcept |
| Extracts the element of the field labeled Name from a kumi::record if it exists. | |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &r) noexcept |
| Extracts the field which underlying type is T from a kumi::record if it exist. | |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &t) noexcept |
| Extracts the Ith element from a kumi::tuple. | |
| template<str S, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &t) noexcept |
| Extracts the field labeled S from a kumi::tuple if it exists. | |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &t) noexcept |
| Extracts the field which type is T from a kumi::tuple if it exist. | |
Tuple construction | |
| template<typename... Ts> | |
| constexpr auto | tie (Ts &... ts) -> tuple< Ts &... > |
| Creates a kumi::tuple of lvalue references to its arguments. | |
| template<typename... Ts> | |
| constexpr auto | make_tuple (Ts &&... ts) -> tuple< std::unwrap_ref_decay_t< Ts >... > |
| Creates a tuple object, deducing the target type from the types of arguments. | |
| template<typename... Ts> | |
| constexpr auto | forward_as_tuple (Ts &&... ts) -> tuple< Ts &&... > |
| Creates a kumi::tuple of forwarding references to its arguments. | |
| template<concepts::product_type T> | |
| constexpr auto | to_ref (T &&t) |
| Creates a kumi::tuple of references given a reference to a kumi::product_type. | |
