Metaprogramming¶

Template metaprogramming utilities and C++ type traits.

A¶

function advance(T *, ptrdiff_t)
function advance(void *, ptrdiff_t)
function align_down(T *, size_t)
function align_down(T, std::type_identity_t<T>)
function align_up(T *, size_t)
function align_up(T, std::type_identity_t<T>)
function aligned_allocate(size_t) Allocates aligned memory
function aligned_allocate(size_t, size_t) Allocates aligned memory
function aligned_deallocate(T *) Deallocates aligned memory
struct aligned_new
function data_allocator<T>::allocate(size_type)
function cvals_t<T, values>::array() Pointer to a static array holding all values
function cvals_t<T>::array() Pointer to the (empty) array (always nullptr)
class array_ref<T> Reference to array
constructor array_ref<T>::array_ref<T>()
constructor array_ref<T>::array_ref<T>(array_ref<T> &&)
constructor array_ref<T>::array_ref<T>(const array_ref<T> &)
function array_ref<T>::array_ref<T>(Container &&)
constructor array_ref<T>::array_ref<T>(std::initializer_list<T>)
constructor array_ref<T>::array_ref<T>(T *, size_type)
function array_to_string(const std::array<size_t, Dims> &, Getter &&, int, int, std::string_view, std::string_view, std::string_view) Render a multi-dimensional array as a nested, brace-delimited string.
function array_to_string(size_t, Getter &&, int, int, std::string_view, std::string_view, std::string_view) Convenience overload of array_to_string for a one-dimensional array accessed through a getter callable.
function array_to_string(size_t, T *, int, int, std::string_view, std::string_view, std::string_view) Convenience overload of array_to_string for a raw pointer buffer.
function as_string(const Args &...) Convert arbitrary values to a std::string using KFR's built-in formatting.
function compound_type_traits<std::pair<T, T>>::at(const std::pair<subtype, subtype> &, size_t)
function compound_type_traits<T>::at(const T &, size_t)
class autocast_impl<Tfrom> Helper returned by autocast that converts to any type via static_cast .
function autocast(const Tfrom &)
class autofree<T> Smart pointer for aligned memory with automatic deallocation.
constructor autofree<T>::autofree<T>() Default constructor.
constructor autofree<T>::autofree<T>(autofree<T> &&)
constructor autofree<T>::autofree<T>(const autofree<T> &)
constructor autofree<T>::autofree<T>(size_t) Allocates aligned memory for given size.

B¶

enum constant datatype::b
typedef b8 Short names for common types
enum constant datatype::b8
function cvals_t<T, values>::back() Returns the last value
function array_ref<T>::back()
function cvals_t<T, values>::begin() Iterator to the first value
function array_ref<T>::begin()
function range<T>::begin()
function bind_func(Fn &&, Args &&...)
function bitcast_anything(const Tin &)
variable typebits<T>::bits
function build_fmt_str(cchars_t<'@', chars...>, ctypes_t<Arg, Args...>) Build a compile-time format string: replace the leading '@' with the specifier for Arg and recurse on the remaining arguments.
function build_fmt_str(cchars_t<ch, chars...>, ctypes_t<Args...>) Build a compile-time format string: copy a literal character and recurse.
function build_fmt_str(cchars_t<>, ctypes_t<>) Build a compile-time printf format string from a literal template and argument types.

C¶

variable special_value::c Active variant tag
enum constant datatype::c
enum constant datatype::c32
enum constant datatype::c64
function cstring<N>::c_str()
function call_with_temp(size_t, Fn &&) Calls a function with a temporary buffer, allocated on the stack if small enough, otherwise on the heap.
function array_ref<T>::cbegin()
variable cbool
typedef cbool_t Compile-time boolean constant
variable cbools Constant instance of cbools_t<vals...>
typedef cbools_t Compile-time list of boolean values
variable cchars Constant instance of cchars_t<vals...>
typedef cchars_t Compile-time list of char values
function cconcat(T1, Ts...) Returns a value of the concatenated list type
function array_ref<T>::cend()
variable cfalse Constant instance of cfalse_t
typedef cfalse_t Compile-time false value type
variable cfalse_true Constant instance of
typedef cfilter_t Filters a cvals_t list, keeping only elements whose corresponding flag is
function cfilter(cvals_t<T, vals...>, cvals_t<bool, flags...>)
function cfind(cvals_t<T, values...>, std::type_identity_t<T>)
class cfor_t<stop, start, conditional> Compile-time for loop helper that unrolls iteration over [start, stop) .
variable cfor_v Constant instance of cfor_t<stop, start, conditional> used as the left-hand side of KFR_FOR / KFR_FORC .
function cfor(cval_t<T, start>, cval_t<T, stop>, BodyFn &&)
function cforeach(A0 &&, A1 &&, A2 &&, A3 &&, Fn &&) Invokes
function cforeach(A0 &&, A1 &&, A2 &&, Fn &&) Invokes
function cforeach(A0 &&, A1 &&, Fn &&)
function cforeach(const std::tuple<Ts...> &, Fn &&)
function cforeach(ctypes_t<Ts...>, Fn &&)
function cforeach(cvals_t<T, values...>, Fn &&)
function cforeach(T &&, Fn &&)
function choose_const() Selects the constant of the specific type from a list of candidates. Returns the candidate whose type matches T ; triggers a static_assert if T is not present.
function choose_const_fallback(C1) Single-argument fallback: converts
function choose_const_fallback(C1, Cs...)
function choose_const(C1, Cs...) Recursively skips candidates whose type does not match
function cif(cbool_t<false>, TrueFn &&, FalseFn &&) Compile-time conditional: invokes
function cif(cbool_t<true>, TrueFn &&, FalseFn &&)
variable cint Constant instance of cint_t<val>
typedef cint_t Compile-time int constant
variable cintrange Constant instance of the int range
variable cints Constant instance of cints_t<vals...>
typedef cints_t Compile-time list of int values
variable cintseq Constant instance of an int sequence with
function cmatch(T &&, Fn &&, Args...)
function cmaxof(cvals_t<T>) Returns the maximum value in the list (min of
function cmaxof(cvals_t<T, val, vals...>) Returns the maximum value in the list
function cminof(cvals_t<T>) Returns the minimum value in the list (max of
function cminof(cvals_t<T, val, vals...>) Returns the minimum value in the list
class compound_type_traits<std::pair<T, T>> Specialization of compound_type_traits for std::pair<T, T>
class compound_type_traits<T> Traits describing how a type composes scalar elements. Specialized for compound types (e.g. std::pair ) to expose width, subtype and accessors.
function concat_cstring()
function concat_cstring(const cstring<N1> &)
function concat_cstring(const cstring<N1> &, const cstring<N2> &, const Args &...)
typedef concat_lists Concatenates two or more cvals_t or ctypes_t lists into a single list
typedef array_ref<T>::const_iterator
typedef array_ref<T>::const_pointer
typedef data_allocator<T>::const_pointer
typedef range<T>::const_pointer
typedef array_ref<T>::const_reference
typedef data_allocator<T>::const_reference
typedef range<T>::const_reference
typedef array_ref<T>::const_reverse_iterator
typedef container_value_type
function cprod(cvals_t<T>) Returns the product of all values in the list (1 for an empty list)
function cprod(cvals_t<T, first, rest...>) Returns the product of all values in the list
variable csize Constant instance of csize_t<val>
typedef csize_t Compile-time size_t constant
variable csizerange Constant instance of the size_t range
variable csizes Constant instance of csizes_t<vals...>
typedef csizes_t Compile-time list of size_t values
variable csizeseq Constant instance of csizeseq_t with
typedef csizeseq_t Compile-time sequence of size_t values
class cstring<N>
function csum(cvals_t<T>) Returns the sum of all values in the list (0 for an empty list)
function csum(cvals_t<T, first, rest...>) Returns the sum of all values in the list
function cswitch(cvals_t<T>, std::type_identity_t<T>, Fn &&, DefFn &&, CmpFn &&) Switch over an empty list: always invokes the default handler
function cswitch(cvals_t<T, v0, values...>, std::type_identity_t<T>, Fn &&, DefFn &&, CmpFn &&)
function cswitch(cvals_t<T, vs...>, const U &, Function &&, Fallback &&)
variable ctrue Constant instance of ctrue_t
typedef ctrue_t Compile-time true value type
variable ctype Constant instance of ctype_t<T>
function ctype_name()
class ctype_t<T> Compile-time wrapper for a single type. Used to pass types as values in metaprogramming contexts.
function ctypeid() Gets unique value associated with the type
function ctypeid(T) Gets unique value associated with the type
variable ctypes Constant instance of ctypes_t<Ts...>
class ctypes_t<Ts> Compile-time list of types.
variable cuint Constant instance of cuint_t<val>
typedef cuint_t Compile-time unsigned constant
variable cuintrange Constant instance of the unsigned range
variable cuints Constant instance of cuints_t<vals...>
typedef cuints_t Compile-time list of unsigned values
variable cuintseq Constant instance of an unsigned sequence with
variable cval Constant instance of cval_t<T, val>
class cval_t<T, val> Compile-time constant wrapper carrying a value of type T . Usable as a non-type template parameter and convertible to its underlying value.
constructor cval_t<T, val>::cval_t<T, val>()
constructor cval_t<T, val>::cval_t<T, val>(const cval_t<T, val> &)
constructor cval_t<T, val>::cval_t<T, val>(cval_t<T, val> &&)
variable cvalrange Constant instance of the value range
variable cvals Constant instance of cvals_t<T, values...>
class cvals_t<T> Empty specialization of cvals_t.
class cvals_t<T, values> Compile-time list of constant values of type T . Supports indexing, slicing, mapping and equality comparison at compile time.
constructor cvals_t<T, values>::cvals_t<T, values...>()
variable cvalseq Constant instance of cvalseq_t with
typedef cvalseq_t Compile-time arithmetic sequence of size values starting at start with step step .

D¶

variable special_value::d Stored floating-point literal
function cstring<N>::data()
function array_ref<T>::data()
function autofree<T>::data() Returns pointer to underlying data.
function autofree<T>::data() Returns const pointer to underlying data.
class data_allocator<T> Aligned allocator
constructor data_allocator<T>::data_allocator<T>()
constructor data_allocator<T>::data_allocator<T>(const data_allocator<T> &)
function data_allocator<T>::data_allocator<T>(const data_allocator<U> &)
enum datatype An enumeration representing data type
function data_allocator<T>::deallocate(pointer, size_type)
typedef compound_type_traits<T>::deep_rebind
typedef compound_type_traits<std::pair<T, T>>::deep_rebind
typedef compound_type_traits<T>::deep_subtype
typedef deep_subtype The deepest scalar subtype of a (possibly nested) compound type
typedef compound_type_traits<std::pair<T, T>>::deep_subtype
variable compound_type_traits<T>::deep_width
variable compound_type_traits<std::pair<T, T>>::deep_width
enum constant special_constant::default_constructed value-initialized
variable default_memory_alignment
variable compound_type_traits<T>::depth
variable compound_type_traits<std::pair<T, T>>::depth
function derived_cast(const U *) Down-casts a const pointer from
function derived_cast(U *)
typedef range<T>::diff_type
typedef array_ref<T>::difference_type
typedef data_allocator<T>::difference_type
function range<T>::distance()
function distance(const void *, const void *)
function dont_deduce(T)

E¶

variable elements Constant instance of elements_t<vals...>
typedef elements_t Compile-time list of element indices (size_t values)
function array_ref<T>::empty()
class empty_struct<tag> Empty type tagged with a unique integer tag .
function cvals_t<T, values>::end() Iterator past the last value
function array_ref<T>::end()
function range<T>::end()
enum constant special_constant::epsilon machine epsilon
function cvals_t<T, values>::equal(cvals_t<T, values...>) Returns
function cvals_t<T, values>::equal(cvals_t<T, values2...>) Returns
function error(const Args &...) Print values to stderr, each formatted with its default conversion specifier.
function errorln(const Args &...) Print values to stderr followed by a newline, then flush stderr.

F¶

enum constant datatype::f
enum constant datatype::f16
typedef f32
enum constant datatype::f32
typedef f64
enum constant datatype::f64
typedef f80
enum constant datatype::f80
concept f_class
typedef fbase
typedef findinttype
typedef fix_type
typedef float_type Maps a bit width to the corresponding floating-point type (32 -> float, 64 -> double)
enum constant special_constant::floating_point floating-point literal carried by
function floor_div(long long, long long)
typedef flt_type
typedef fmax
class fmt_t<T, t, width, prec> Wrapper that carries a value together with printf-style format options.
function fmt(const T &) Wrap value with a custom conversion specifier.
function fmtwidth(const T &) Wrap value with only width/precision, keeping the default conversion specifier.
struct fn_get_first
struct fn_get_second
struct fn_get_third
struct fn_is_between
struct fn_is_equal
struct fn_is_greater
struct fn_is_greaterorequal
struct fn_is_less
struct fn_is_lessorequal
struct fn_is_notequal
class fn_noinline<Fn> Functor wrapper that invokes Fn through noinline .
struct fn_noop
struct fn_pass_through
class fn_return_constant<T, value> Functor returning a fixed constant of type T , ignoring all arguments.
class fn_returns<T>
class format_t<chars> Callable object holding a compile-time format literal (built by operator""_format).
function format(const std::string &, const Args &...) Format values into a std::string using a {}"-based format string.
function fprintfmt(FILE *, const std::string &, const Args &...) Print to a file f using a {}"-based format string.
function cvals_t<T, values>::front() Returns the first value
function array_ref<T>::front()
typedef fsubtype
typedef ftype
typedef function_arguments Extracts the argument types of a functor's
typedef function_result Extracts the return type of a functor's

G¶

function special_value::get() Returns the value converted to type
function get_first(T1 &&, Ts &&...) Function that returns its first argument and ignores all other arguments
function get_second(T1, T2 &&, Ts &&...) Function that returns its second argument and ignores all other arguments
function get_third(T1 &&, T2 &&, T3 &&, Ts &&...) Function that returns its third argument and ignores all other arguments
function representation<named_arg<T>>::get(const named_arg<T> &)
function representation<std::array<T, Size>>::get(const std::array<T, Size> &)
function representation<std::pair<T1, T2>>::get(const std::pair<T1, T2> &)
function representation<std::shared_ptr<T1>>::get(const std::shared_ptr<T1> &)
function representation<std::shared_ptr<void>>::get(const std::shared_ptr<void> &)
function representation<std::string_view>::get(const std::string_view &)
function representation<std::unique_ptr<T1>>::get(const std::unique_ptr<T1> &)
function representation<std::vector<T, Allocator>>::get(const std::vector<T, Allocator> &)
function representation<std::weak_ptr<T1>>::get(const std::weak_ptr<T1> &)
function representation<T>::get(const T &)
function cvals_t<T, values>::get(csize_t<index>) Returns the value at
function ctypes_t<Ts>::get(csize_t<index>) Returns a ctype_t wrapping the type at position

H¶

concept has_begin_end Concept satisfied by types that support
concept has_data_size Concept satisfied by types that support
function map_indices_impl<size, Fn>::helper(csizes_t<I...>)

I¶

enum constant datatype::i
typedef i16
enum constant datatype::i16
enum constant datatype::i24
typedef i32
enum constant datatype::i32
typedef i64
enum constant datatype::i64
typedef i8
enum constant datatype::i8
concept i_class
variable type_id_t::id
function ilog2(T) Returns the base-2 logarithm of
typedef imax
function implicit_cast(U &&)
variable indicesfor Constant instance of indicesfor_t for the given type list
typedef indicesfor_t Returns a sequence of indices
enum constant special_constant::infinity positive infinity
typedef map_indices_impl<size, Fn>::input_type
typedef int_type Maps a bit width to the corresponding signed integer type
enum constant special_constant::integer integer literal carried by
function is_between(T, std::type_identity_t<T>, std::type_identity_t<T>)
variable is_compound_type if
function is_constant_val(cval_t<T, value>) Returns
function is_constant_val(T) Returns
function is_divisible(T, T)
function is_equal(const T1 &, const T2 &) Returns
function is_even(T) Returns
variable is_f_class
function is_greater(const T1 &, const T2 &) Returns
function is_greaterorequal(const T1 &, const T2 &) Returns
variable is_i_class
function is_less(const T1 &, const T2 &) Returns
function is_lessorequal(const T1 &, const T2 &) Returns
function is_notequal(const T1 &, const T2 &) Returns
variable is_number if
variable is_number_or_bool if
variable is_numbers
variable is_numeric Check if the type argument is a number or a compound type of numbers
variable is_numeric_args Check if the type arguments are numbers or compound types of numbers
variable is_numeric_or_bool Check if the type argument is a number, bool or a compound type of numbers or bool
function is_odd(T) Returns
function is_poweroftwo(T) Returns
variable compound_type_traits<T>::is_scalar
variable compound_type_traits<std::pair<T, T>>::is_scalar
function is_sequence(csizes_t<number, numbers...>)
variable is_u_class
typedef is_val_t
typedef isubtype
typedef array_ref<T>::iterator
struct range<T>::iterator
typedef itype

J¶

function join(T) Convert a single value to a string (terminator of join ).
function join(T, U, Ts...) Join values into a comma-separated string of the form {x}, {y}, {rest...}".
function just_value(T)

K¶

macro KFR_BIN_OP
macro KFR_CALL_CONV_SPEC
macro KFR_CLASS_REFCOUNT
macro KFR_CVAL
macro KFR_ENABLE_IF
macro KFR_ENABLE_IF_IMPL
macro KFR_ESC
macro KFR_FOR
macro KFR_FORC
macro KFR_META_FN
macro KFR_META_FN_TPL
macro KFR_STANDARD_PACK
macro KFR_UN_OP

L¶

function cstring<N>::length()
variable special_value::ll Stored integer literal
enum constant special_constant::lowest most negative representable value

M¶

function make_array_ref(Container &&)
function make_array_ref(T *, std::size_t)
function make_cstring(cchars_t<chars...>)
function make_cstring(const char (&)[N])
function make_nonmember(const Fn &)
function make_range(T, T) Make iterable range object
function make_range(T, T, D) Make iterable range object with step
function map_indices() Returns a value of map_indices_t<size, Fn...> for use in non-type contexts.
class map_indices_impl<size, Fn> Compile-time index transformer used to build shuffle/permutation tables.
typedef map_indices_t Alias for the csizes_t produced by map_indices_impl<size, Fn...> .
function cvals_t<T, values>::map(Fn &&) Returns a new list with
enum constant special_constant::max maximum representable value
variable range<T>::max
variable max_size_t Maximum value representable by size_t
enum constant special_constant::min minimum positive normalized value
variable range<T>::min

N¶

variable named_arg<T>::name
variable named::name
struct named
class named_arg<T>
constructor named::named(const char *)
enum constant special_constant::neg_infinity negative infinity
enum constant special_constant::neg_max negated maximum representable value
function next_poweroftwo(T) Returns a nearest power of two that is greater or equal than n
function noinline(Fn &&, Args &&...)
function noop(Ts &&...) Function that returns void and ignores all its arguments
concept not_f_class
concept not_i_class
concept not_u_class
function cvals_t<T, values>::notequal(cvals_t<T, values...>) Returns
typedef ctypes_t<Ts>::nth The type at position
concept numeric Concept satisfied by numeric types (numbers or compound types of numbers)

O¶

function cval_t<T, val>::operator()() Returns the wrapped value
function range<T>::iterator::operator*()
function range<T>::iterator::operator->()
function range<T>::iterator::operator++()
function operator
function operator User-defined literal returning a format_t for the given string literal.
function operator User-defined literal returning a print_t for the given string literal.
function fn_pass_through::operator()(Args &&...)
function fn_noop::operator()(Args &&...)
function fn_get_first::operator()(Args &&...)
function fn_get_second::operator()(Args &&...)
function fn_get_third::operator()(Args &&...)
function fn_returns<T>::operator()(Args &&...)
function fn_return_constant<T, value>::operator()(Args &&...) Returns the wrapped constant
function fn_is_equal::operator()(Args &&...)
function fn_is_notequal::operator()(Args &&...)
function fn_is_less::operator()(Args &&...)
function fn_is_greater::operator()(Args &&...)
function fn_is_lessorequal::operator()(Args &&...)
function fn_is_greaterorequal::operator()(Args &&...)
function fn_is_between::operator()(Args &&...)
function fn_noinline<Fn>::operator()(Args &&...) Invokes the wrapped callable non-inlined
function array_ref<T>::operator=(array_ref<T> &&)
function autofree<T>::operator=(autofree<T> &&)
function format_t<chars>::operator()(const Args &...) Format the given arguments using the stored literal.
function print_t<chars>::operator()(const Args &...) Print the given arguments to stdout using the stored literal.
function array_ref<T>::operator=(const array_ref<T> &)
function autofree<T>::operator=(const autofree<T> &)
function cstring<N>::operator==(const cstring<N> &, const cstring<N> &)
function cstring<N>::operator!=(const cstring<N> &, const cstring<N> &)
function cstring<N>::operator==(const cstring<NN> &)
function cstring<N>::operator!=(const cstring<NN> &)
function operator==(const data_allocator<T1> &, const data_allocator<T2> &)
function operator!=(const data_allocator<T1> &, const data_allocator<T2> &)
function range<T>::iterator::operator!=(const iterator &)
function cvals_t<T, values>::operator[](csize_t<index>) Returns the value at
function operator-(cval_t<T1, val1>)
function operator+(cval_t<T1, val1>)
function operator~(cval_t<T1, val1>)
function operator!(cval_t<T1, val1>)
function operator&&(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator||(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator==(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator!=(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator<(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator>(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator<=(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator>=(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator+(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator-(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator*(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator/(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator%(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator<<(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator>>(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator&(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator|(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function operator^(cval_t<T1, val1>, cvals_t<T2, vals2...>)
function cvals_t<T, values>::operator[](cvals_t<size_t, indices...>) Returns a sub-list containing the values at
function operator-(cvals_t<T1, vals1...>)
function operator+(cvals_t<T1, vals1...>)
function operator~(cvals_t<T1, vals1...>)
function operator!(cvals_t<T1, vals1...>)
function operator&&(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator||(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator==(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator!=(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator<(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator>(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator<=(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator>=(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator+(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator-(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator*(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator/(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator%(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator<<(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator>>(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator&(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator|(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator^(cvals_t<T1, vals1...>, cval_t<T2, val2>)
function operator&&(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator||(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator==(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator!=(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator<(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator>(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator<=(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator>=(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator+(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator-(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator*(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator/(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator%(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator<<(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator>>(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator&(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator|(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator^(cvals_t<T1, vals1...>, cvals_t<T2, vals2...>)
function operator|(datatype, datatype)
function operator&(datatype, datatype)
function aligned_new::operator
function aligned_new::operator
function cfor_t<stop, start, conditional>::operator=(Fn &&) Invokes fn for each index in [start, stop) , passing i as template argument.
function range<T>::iterator::operator++(int)
function aligned_new::operator
function aligned_new::operator
function cstring<N>::operator[](size_t)
function autofree<T>::operator[](size_t) Access element at index.
function autofree<T>::operator[](size_t) Const access to element at index.
function array_ref<T>::operator[](std::size_t)
function named::operator=(T &&)
function type_id_t::operator==(type_id_t)
function type_id_t::operator!=(type_id_t)
operator cval_t<T, val>::operator Implicit conversion to the underlying value
function special_value::operator Converts to type
function autocast_impl<Tfrom>::operator Converts the stored value to
typedef or_type If
typedef data_allocator<T>::rebind<U>::other
variable overload_auto Convenience instance of the highest-priority tag for use in overload resolution
typedef overload_generic Alias for the lowest-priority tag, used as a fallback overload
struct overload_priority<0> Lowest priority tag, base of the overload_priority chain
class overload_priority<n> Tag type forming a linear inheritance chain used to rank overload candidates. overload_priority<n> derives from overload_priority<n-1> , so larger n is a better match.

P¶

function pack_elements() Returns the identity value (0) for an empty pack
function pack_elements(Arg, Args...)
function padcenter(size_t, const std::string &, char) Center text within a field of size characters using character.
function padleft(size_t, const std::string &, char) Left-align text within a field of size characters by appending character.
function padright(size_t, const std::string &, char) Right-align text within a field of size characters by prepending character.
function pass_through(T &&) Function that returns its first argument
typedef pconstvoid Pointer to const void
typedef array_ref<T>::pointer
typedef data_allocator<T>::pointer
typedef range<T>::pointer
function prev_poweroftwo(T) Returns a nearest power of two that is less or equal than n
class print_t<chars> Callable object holding a compile-time format literal (built by operator""_print).
function print(const Args &...) Print values to stdout, each formatted with its default conversion specifier.
function printfmt(const std::string &, const Args &...) Print to stdout using a {}"-based format string.
function println(const Args &...) Print values to stdout followed by a newline.
variable autofree<T>::ptr Unique pointer with custom deleter for aligned memory.
function ptr_cast(const U *) Reinterprets a const pointer of type
function ptr_cast(U *)
function ptr_cast(U *, ptrdiff_t)
typedef pvoid Pointer to void

Q¶

function q(T) Wrap the string representation of x in double quotes.

R¶

enum constant special_constant::random_bits value filled with random bits
function special_value::random_bits()
function special_value::random_generator() Returns a reference to the shared mt19937 random generator (seeded with 1)
class range<T> Iterable range
constructor range<T>::range<T>(value_type, value_type, diff_type)
typedef compound_type_traits<T>::rebind
typedef compound_type_traits<std::pair<T, T>>::rebind
class data_allocator<T>::rebind<U>
function ref_cast(const U &) Reinterprets a const reference of type
function ref_cast(U &)
typedef array_ref<T>::reference
typedef data_allocator<T>::reference
typedef range<T>::reference
typedef repr_type Alias for the type used by representation<T> when formatting values of type T.
class representation<named_arg<T>> Representation of named_arg as name = value".
class representation<std::array<T, Size>> Representation of std::array as a brace-delimited list of its elements.
class representation<std::pair<T1, T2>> Representation of std::pair as (first; second)".
class representation<std::shared_ptr<T1>> Representation of std::shared_ptr as Type(value) or Type(nullptr)".
struct representation<std::shared_ptr<void>> Representation of std::shared_ptr<void> as Type(pointer) or Type(nullptr)".
struct representation<std::string_view> Representation of std::string_view as a std::string.
class representation<std::unique_ptr<T1>> Representation of std::unique_ptr as Type(value) or Type(nullptr)".
class representation<std::vector<T, Allocator>> Representation of std::vector as a brace-delimited list of its elements.
class representation<std::weak_ptr<T1>> Representation of std::weak_ptr as Type(value) or Type(nullptr)".
class representation<T> Primary template for converting a value of type T to its string representation.
function return_constant(Args &&...) Function that returns constant of type T and ignores all its arguments
function returns(Ts &&...) Function that returns value-initialization of type T and ignores all its arguments
typedef array_ref<T>::reverse_iterator

S¶

function scale()
function scale(csizes_t<indices...>)
function select(cvals_t<bool, flags...>, cvals_t<T, values1...>, cvals_t<T, values2...>) Element-wise selection between two value lists based on a flag list. For each position, returns values1[i] if flags[i] is true , otherwise values2[i] .
function cvals_t<T, values>::size() Number of values in the list
function cvals_t<T>::size() Number of values (always 0)
function ctypes_t<Ts>::size() Number of types in the list
function cstring<N>::size()
function array_ref<T>::size()
typedef cstring<N>::size_type
typedef array_ref<T>::size_type
typedef data_allocator<T>::size_type
function cstring<N>::slice(csize_t<start>)
function cstring<N>::slice(csize_t<start>, csize_t<count>)
function snprintfmt(char *, size_t, const std::string &, const Args &...) Write to a buffer using a {}"-based format string.
enum special_constant Enumeration of special numeric values selectable through special_value .
struct special_value Type-erased constant convertible to any numeric type T . Holds either a special_constant tag, an integer literal, or a floating-point literal, and converts to T according to the active variant.
constructor special_value::special_value(const special_value &)
constructor special_value::special_value(double) Constructs from a double literal
constructor special_value::special_value(int) Constructs from an int literal
constructor special_value::special_value(long long) Constructs from a long long literal
constructor special_value::special_value(special_constant) Constructs from a special_constant tag
variable range<T>::iterator::step
variable range<T>::step
function stop_constexpr() Non-constexpr function used to halt constant evaluation in
function str_find(const cstring<N1> &, const cstring<Nneedle> &)
function str_replace(const cstring<N1> &, const cstring<Nfrom> &, const cstring<Nto> &)
typedef cvals_t<T, values>::subscript
class cvals_t<T, values>::subscript_t<cvals_t<size_t, indices...>>
class cvals_t<T, values>::subscript_t<U>
typedef compound_type_traits<T>::subtype
typedef subtype The immediate subtype of a compound type
typedef compound_type_traits<std::pair<T, T>>::subtype
typedef typebits<T>::subtype
struct swallow Utility class to use in list-initialization context Accepts any number of arguments and discards them; useful for pack expansion side effects.
function swallow::swallow(T &&...) Constructs from any arguments, discarding them

T¶

typedef cval_t<T, val>::type
typedef cvals_t<T, values>::type
typedef cvals_t<T, values>::subscript_t<cvals_t<size_t, indices...>>::type
typedef cvals_t<T>::type
typedef ctype_t<T>::type The wrapped type
typedef map_indices_impl<size, Fn>::type
typedef representation<T>::type
typedef representation<named_arg<T>>::type
typedef representation<std::pair<T1, T2>>::type
typedef representation<std::unique_ptr<T1>>::type
typedef representation<std::weak_ptr<T1>>::type
typedef representation<std::shared_ptr<T1>>::type
typedef representation<std::shared_ptr<void>>::type
typedef representation<std::array<T, Size>>::type
typedef representation<std::vector<T, Allocator>>::type
typedef representation<std::string_view>::type
struct type_id_t
constructor type_id_t::type_id_t(const void *)
function type_name() Gets the fully qualified name of the type, including namespace and template parameters (if any)
function type_name(T) Gets the fully qualified name of the type, including namespace and template parameters (if any)
typedef type_of Extracts the wrapped type from a ctype_t-like wrapper
enum constant datatype::typebits_mask
class typebits<T>
variable typeclass
enum constant datatype::typeclass_mask
function typeindex() Returns the zero-based index of type

U¶

enum constant datatype::u
typedef u16
enum constant datatype::u16
enum constant datatype::u24
typedef u32
enum constant datatype::u32
typedef u64
enum constant datatype::u64
typedef u8
enum constant datatype::u8
concept u_class
typedef uitype
typedef umax
typedef unsigned_type Maps a bit width to the corresponding unsigned integer type
typedef usubtype
typedef utype

V¶

function val_of(cval_t<T, value>) Extracts the value from a cval_t constant
function val_of(T) Returns the value itself (overload for runtime values)
variable cval_t<T, val>::value The wrapped constant value
variable autocast_impl<Tfrom>::value
variable cstring<N>::value
variable named_arg<T>::value
variable fmt_t<T, t, width, prec>::value
variable range<T>::iterator::value
typedef value_or_ref
typedef cval_t<T, val>::value_type
typedef cstring<N>::value_type
typedef array_ref<T>::value_type
typedef data_allocator<T>::value_type
typedef range<T>::value_type
typedef value_type_of Extracts the

W¶

variable compound_type_traits<T>::width
variable compound_type_traits<std::pair<T, T>>::width
variable typebits<T>::width
function widthof() Returns the width (number of scalar components) of
function widthof(T) Returns the width (number of scalar components) of
function wrap_fmt(const U &, ctype_t<Fmt>) Wrap val with the format type Fmt when Fmt is not void.
function wrap_fmt(const U &, ctype_t<void>) Identity pass-through used when no format type is specified.

This file was generated by cxxdox, a C++ documentation generator based on MkDocs Material and libclang.