Tools for interacting with kumi::tuple. More...
Classes | |
| class | kumi::boolean_and |
| A type representing the logical and monoid and it's associated identity. The identity of the boolean_and is true. More... | |
| class | kumi::boolean_or |
| A type representing the logical or monoid and it's associated identity. The identity of boolean_or is false. More... | |
| class | kumi::boolean_xor |
| A type representing the logical xor monoid and it's associated identity. The identity of boolean_xor is false. More... | |
| class | kumi::builder< T > |
| 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 | kumi::identifier< ID, Checker > |
| identifier definition class More... | |
| struct | kumi::index_t< N > |
| Integral constant type. More... | |
| class | kumi::indexes_t< V > |
| Compile time tuple of index used to pass several indexes_t as NTTP. More... | |
| struct | kumi::name< ID > |
| Compile-time text based ID. More... | |
| class | kumi::numeric_add |
| A type representing the addition monoid with it's associated identity. The identity of the addition is 0. More... | |
| class | kumi::numeric_prod |
| A type representing the multiplication monoid with it's associated identity. The identity of the multiplication is 1. More... | |
| class | kumi::str |
| Static string used to create named fields. More... | |
| class | kumi::unit |
| A type representing the product of no type also called the unit type. More... | |
| struct | kumi::unknown |
| Type indicating a identifier was not found in a given kumi::product_type. More... | |
Functions | |
| template<concepts::product_type Tuple> requires (size_v<Tuple> != 0) | |
| constexpr decltype(auto) | kumi::back (Tuple &&t) |
| Retrieves the back of a tuple. | |
| template<typename T> | |
| constexpr decltype(auto) | kumi::field_value_of (T &&t) noexcept |
| Extracts the value from a kumi::field or returns the parameter. | |
| template<concepts::product_type Tuple> requires (size_v<Tuple> != 0) | |
| constexpr decltype(auto) | kumi::front (Tuple &&t) |
| Retrieves the front of a tuple. | |
| template<concepts::identifier Name, concepts::product_type T> | |
| consteval auto | kumi::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 | kumi::get_index_of_type () |
| Helper to retrive the index of a type in a product type by it s type. | |
| template<concepts::indexer... Ts> | |
| consteval auto | kumi::indexes (Ts... ts) noexcept |
| Creates a kumi::indexes object, deducing the target type from the types of arguments. | |
| template<concepts::indexer... Ts> | |
| KUMI_CUDA | kumi::indexes_t (Ts...) -> indexes_t< Ts... > |
| kumi::indexes_t deduction guide | |
| template<typename C, typename... Ts> requires (std::is_invocable<C, Ts...>::value) | |
| constexpr decltype(auto) | kumi::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 | kumi::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<valid_display_name T> | |
| consteval str | kumi::_::make_str (T const &t) |
| Provides an extension point to_str in order to output types with no textual representation defined. | |
| template<typename T> | |
| auto | kumi::_::make_streamable (T const &e) |
| Provides an extension point as_streamable in order to output values of types with no stream operator defined. | |
| template<typename Target, concepts::product_type T> | |
| constexpr auto | kumi::member_cast (T &&t) |
| Converts a product_type<Ts...> to an instance of a product_type<Target...>. | |
| template<typename T> | |
| consteval auto | kumi::name_of () noexcept |
| Extracts the name from a kumi::field or returns the parameter. | |
| template<char... c> | |
| constexpr auto | kumi::operator""_c () noexcept |
| Forms a integral constant literal of the desired value. | |
| template<kumi::str ID> | |
| constexpr auto | kumi::operator""_id () noexcept |
| Forms a constant string literal of the desired value. | |
| template<template< class > class Pred> | |
| constexpr auto | kumi::predicate () noexcept |
| Convert a unary template meta-program in a running predicate. | |
Variables | |
| constexpr boolean_and | kumi::function::bit_and {} |
| Forms a binary monoid callable that can be used in kumi::algoritm. It represents the logical and operation. | |
| constexpr boolean_or | kumi::function::bit_or {} |
| Forms a binary monoid callable that can be used in kumi::algoritm. It represents the logical or operation. | |
| constexpr boolean_xor | kumi::function::bit_xor {} |
| Forms a binary monoid callable that can be used in kumi::algoritm. It represents the logical xor operation. | |
| template<template< class > typename Traits> | |
| constexpr traits_check< Traits > | kumi::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 | kumi::index = {} |
| Inline integral constant value for kumi::index_t. | |
| constexpr numeric_prod | kumi::function::multiplies {} |
| Forms a binary monoid callable that can be used in kumi::algoritm. It represents the multiplication. | |
| constexpr unit | kumi::none = {} |
| Inline constant representing a kumi::unit. | |
| template<typename T> | |
| constexpr only_t< T > | kumi::only = {} |
| Option specifying the single type a identifier will accept. | |
| constexpr numeric_add | kumi::function::plus {} |
| Forms a binary monoid callable that can be used in kumi::algoritm. It represents the addition. | |
