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 based on the given template parameter. If the provided product type is a not a record_type the builder will output a tuple otherwise a record. One can specialize the builder for it's own type matching the product type semantic. More... | |
| struct | common_product_type |
| Extracts the common product_type of a parameter pack. 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 | has_static_size |
| Detects if a given kumi::container instance size is static. More... | |
| class | identifier |
| identifier definition class More... | |
| class | index_t |
| Integral constant type. More... | |
| struct | is_container |
| Traits detecting types behaving like a kumi::container. More... | |
| struct | is_homogeneous |
| Detects if a given kumi::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... | |
| class | label_t |
| Literal constant type. More... | |
| struct | member |
| Computes the return type of a call to kumi::get. More... | |
| class | name |
| Compile-time text based identifier. 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... | |
| class | projection_map |
| A stateless, compile-time schema for product type transformation. More... | |
| struct | raw_element |
| Provides indexed access to the types of the elements of a product type and unwraps the returned field_capture for 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 tagged fields, tags 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... | |
| class | 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 &&t) noexcept |
| Computes the reduction of a product type over the && operator. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr auto | all_of (T &&t, Pred p) noexcept |
| Checks if a unary predicate p returns true for every element of 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 t. | |
| template<concepts::product_type T> | |
| constexpr auto | any_of (T &&t) noexcept |
| Computes the reduction of a product type over the || operator. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr auto | any_of (T &&t, Pred p) noexcept |
| Checks if a unary predicate p returns true for any element of t. | |
| template<typename Function, concepts::product_type T> | |
| constexpr decltype(auto) | apply (Function &&f, T &&t) noexcept(kumi_implementation_defined) |
| Invoke the Callable object f with the elements of the product type unrolled as arguments. | |
| template<concepts::product_type T> | |
| auto | as_flat_ptr (T &&t) noexcept |
| Convert a product type to a flat product type of pointers to each its components. | |
| template<concepts::non_empty_product_type T> | |
| constexpr decltype(auto) | back (T &&t) |
| Retrieves the back of a product type. | |
| 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<kumi_implementation_defined 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 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 ID> | |
| constexpr bool | contains (T &&t, ID const &id) noexcept |
| Checks if a product type contains a given identifier. | |
| template<concepts::product_type T, concepts::identifier... Is> | |
| constexpr bool | contains_any (T &&t, Is const &... ids) noexcept |
| Checks if a product type contains at least one of many identifiers. | |
| template<concepts::product_type T, concepts::identifier... Is> | |
| constexpr bool | contains_none (T &&t, Is const &... ids) noexcept |
| Checks if a product type contains no fields based on any of the selected identifiers. | |
| template<concepts::product_type T, concepts::identifier... Is> | |
| constexpr bool | contains_only (T &&t, Is const &... ids) noexcept |
| Checks if a product type contains fields based only on selected identifiers. | |
| template<concepts::product_type T> | |
| constexpr std::size_t | count (T &&t) 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 &&t, 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 T> | |
| constexpr auto | extract (T &&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 T> | |
| constexpr auto | extract (T &&t, index_t< I0 > i0, index_t< I1 > i1) noexcept |
| Extracts a sub product type 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::concepts::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::non_empty_product_type 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::non_empty_product_type 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 T, concepts::product_type... Ts> requires (concepts::compatible_product_types<T, Ts...>) | |
| constexpr void | for_each (Function f, T &&t, Ts &&... ts) |
| Applies the Callable object f on each element of a product type. f is applied on the values if the given product_type is a record type. | |
| template<typename Function, concepts::record_type R, concepts::record_type... Rs> requires (concepts::compatible_product_types<R, Rs...>) | |
| constexpr void | for_each_field (Function f, R &&r, Rs &&... rs) |
| Applies the Callable object f on each element of a record type and its field. | |
| template<typename Function, concepts::product_type T, concepts::product_type... Ts> requires (!concepts::record_type<T> && (!concepts::record_type<Ts> && ...)) | |
| constexpr void | for_each_index (Function f, T &&t, Ts &&... ts) |
| Applies the Callable object f on each element of a product type and its index. | |
| template<concepts::non_empty_product_type T> | |
| constexpr decltype(auto) | front (T &&t) |
| Retrieves the front of a product type. | |
| 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<concepts::identifier Id, 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 identifier. | |
| 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 T> | |
| consteval auto | identifier_of () noexcept |
| Extracts the identifiers from a kumi::concepts::field or returns the parameter. | |
| template<concepts::identifier... Ts> | |
| consteval auto | identifiers (Ts... ts) noexcept |
| Creates a kumi::projection_map object, deducing the target type from the types of arguments. | |
| 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::index... Ts> | |
| consteval auto | indexes (Ts... ts) noexcept |
| Creates a kumi::projection_map object, deducing the target type from the types of arguments. | |
|
template<concepts::product_type S1, concepts::sized_product_type< size_v< S1 > > S2, typename T> requires (concepts::compatible_product_types<S1, S2>) | |
| 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> requires (concepts::compatible_product_types<S1, S2>) | |
| 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 T> | |
| consteval str | label_of () noexcept |
| Extracts the label from a kumi::concepts::field or returns the parameter. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr auto | locate (T &&t, Pred p) noexcept |
| Return the index of a value which type satisfies a given predicate. | |
| template<std::convertible_to< std::size_t > auto... vs> | |
| consteval auto | make_indexes () noexcept |
| Creates a kumi::projection_map object, deducing the target type from the types of arguments. | |
| template<concepts::product_type T, typename Function, concepts::sized_product_type< size_v< T > >... Ts> requires (concepts::compatible_product_types<T, Ts...>) | |
| constexpr auto | map (Function f, T &&t0, Ts &&... others) |
| Applies the Callable object f on each product types' elements. | |
| template<concepts::record_type T, typename Function, concepts::sized_product_type< size_v< T > >... Ts> requires (concepts::compatible_product_types<T, Ts...>) | |
| constexpr auto | map_field (Function f, T &&t0, Ts &&... others) |
| Applies the Callable object f on each records' fields and their associated names. | |
| template<concepts::product_type T, typename Function, concepts::sized_product_type< size_v< T > >... Ts> requires (!concepts::record_type<T> && (!concepts::record_type<Ts> && ...)) | |
| constexpr auto | map_index (Function f, T &&t0, Ts &&... others) |
| Applies 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 identifiers of the fields of a 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<concepts::product_type T> | |
| constexpr bool | none_of (T &&t) noexcept |
| Checks if no elements of a product type are true. | |
| template<typename Pred, concepts::product_type T> | |
| constexpr bool | none_of (T &&t, Pred p) noexcept |
| Checks if a unary predicate p does not returns true for any element in 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<kumi::str ID> | |
| constexpr auto | operator""_l () 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 T> | |
| constexpr auto | pop_back (T &&t) |
| Remove the last (if any) element of a kumi::product_type. | |
| template<concepts::product_type T> | |
| constexpr auto | pop_front (T &&t) |
| Remove the first (if any) element of t. | |
| 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::projection... Ts> | |
| KUMI_CUDA | projection_map (Ts...) -> projection_map< Ts... > |
| kumi::indexes_t deduction guide | |
| template<concepts::product_type T, typename V> | |
| constexpr auto | push_back (T &&t, V &&v) |
| Constructs a product type by adding a value v at the end of t. | |
| template<concepts::product_type T, typename V> | |
| constexpr auto | push_front (T &&t, V &&v) |
| Constructs a product type 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::projection_map auto Projections, 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 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 T> | |
| constexpr auto | reverse (T &&t) |
| Reverse elements of a 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 T> | |
| constexpr auto | split (T &&t, index_t< I0 > i0) noexcept |
| Split a product type 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> | |
| 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 product type. | |
| template<std::size_t N, concepts::product_type T> | |
| constexpr auto | windows (T &&t) |
| Creates a 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 product type of all ith elements of t0,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 t0,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 product type of all ith elements of t0,ts... | |
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_projection_map_v = requires { T::is_projection_map; } |
| Checks if a type can be used as a kumi::projection_map. | |
| template<str Label> | |
| constexpr label_t< Label > const | label = {} |
| Inline literal constant value for kumi::label_t. | |
| 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<typename Type, typename... Ts> requires (!concepts::product_type<Type> && kumi_implementation_defined) | |
| 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. | |
|
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. | |
Record construction | |
| template<concepts::identifier auto... Fields, typename... Ts> | |
| constexpr auto | tie (Ts &... ts) -> record< field< decltype(Fields), Ts & >... > requires(sizeof...(Fields)==sizeof...(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 && >... > requires(sizeof...(Fields)==sizeof...(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 >... > requires(concepts::entirely_uniquely_named< 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. | |
Record conversion | |
| template<concepts::record_type Type, typename... Ts> requires (concepts::equivalent<typename kumi_implementation_defined::type, tuple<Ts...>>) | |
| constexpr auto | from_record (record< Ts... > const &r) |
| Converts a kumi::record to an instance of a type that models kumi::record_type. | |
| template<concepts::record_type Type> | |
| constexpr auto | to_record (Type &&r) |
| Converts a kumi::record_type to an instance kumi::record. | |
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 | forward_as_tuple (Ts &&... ts) -> tuple< Ts &&... > |
| Creates a kumi::tuple of forwarding 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<concepts::product_type T> | |
| constexpr auto | to_ref (T &&t) |
| Creates a kumi::tuple of references given a reference to a kumi::product_type. | |
Record Deduction Guides | |
| template<typename... Ts> | |
| KUMI_CUDA | record (Ts &&...) -> record< std::unwrap_ref_decay_t< Ts >... > |
| kumi::record deduction guide | |
Record accessors | |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &r) noexcept |
| Extracts the Ith field from a kumi::record. | |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &&r) noexcept |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &r) noexcept |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &&r) noexcept |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &r) noexcept |
| Extracts the element of the field labeled L from a kumi::record if it exists. | |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &&r) noexcept |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &r) noexcept |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &&r) noexcept |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &r) noexcept |
| Extracts the field identified by Id from a kumi::record if it exists. | |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &&r) noexcept |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &r) noexcept |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &&r) noexcept |
| 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<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > &&r) noexcept |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &r) noexcept |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (record< Ts... > const &&r) noexcept |
Tuple deduction guides | |
| template<typename... Ts> | |
| KUMI_CUDA | tuple (Ts &&...) -> tuple< std::unwrap_ref_decay_t< Ts >... > |
| kumi::tuple deduction guide | |
Tuple Accessors | |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &t) noexcept |
| Extracts the Ith element from a kumi::tuple. | |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &&arg) noexcept |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &arg) noexcept |
| template<std::size_t I, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &&arg) noexcept |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &t) noexcept |
| Extracts the field labeled L from a kumi::tuple if it exists. | |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &&t) noexcept |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &t) noexcept |
| template<str L, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &&t) noexcept |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &t) noexcept |
| Extracts the field identified by Id from a kumi::tuple if it exists. | |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &&t) noexcept |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &t) noexcept |
| template<concepts::identifier auto Id, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &&t) noexcept |
| 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. | |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > &&t) noexcept |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &t) noexcept |
| template<typename T, typename... Ts> | |
| decltype(auto) constexpr | get (tuple< Ts... > const &&t) noexcept |
