Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

►Netl
►Nchrono
Cday	The class day represents a day in a month
Cduration	Class template etl::chrono::duration represents a time interval
Cduration_values	The etl::chrono::duration_values type defines three common durations
Cis_clock	If T satisfies the Clock requirements, provides the member constant value equal true. For any other type, value is false
Clast_spec	Last_spec is an empty tag type that is used in conjunction with other calendar types to indicate the last thing in a sequence
Clocal_t	The class local_t is a pseudo-clock that is used as the first template argument to etl::chrono::time_point to indicate that the time point represents local time with respect of a not-yet-specified time zone. local_time supports streaming and the full set of time point arithmetic
Cmonth	The class month represents a month in a year
Cmonth_day
Cmonth_day_last
Cmonth_weekday
Cmonth_weekday_last
Csystem_clock
Ctime_point	Class template time_point represents a point in time. It is implemented as if it stores a value of type Duration indicating the time interval from the start of the Clock's epoch
Ctreat_as_floating_point	The etl::chrono::treat_as_floating_point trait helps determine if a duration can be converted to another duration with a different tick period
Cweekday
Cweekday_indexed
Cweekday_last
Cyear
Cyear_month
Cyear_month_day
Cyear_month_day_last
Cyear_month_weekday
Cyear_month_weekday_last
►Nexecution
Csequenced_policy	The execution policy type used as a unique type to disambiguate parallel algorithm overloading and require that a parallel algorithm's execution may not be parallelized. The invocations of element access functions in parallel algorithms invoked with this policy (usually specified as etl::execution::seq) are indeterminately sequenced in the calling thread
Cunsequenced_policy	The execution policy type used as a unique type to disambiguate parallel algorithm overloading and indicate that a parallel algorithm's execution may be vectorized, e.g., executed on a single thread using instructions that operate on multiple data items
►Nexperimental
►Nfreertos
Cforever	Runs the task loop forever
Cnever	Runs the task loop 0 times
Cqueue	Wrapper around a FreeRTOS queue
Cstream_buffer	Stream buffers are an RTOS task to RTOS task, and interrupt to task communication primitives
Ctimes	Runs the task loop Count times
►Nhardware
►Nmcp23017
Cdevice
►Nstm32
Cgpio_memory_layout
Cisr
Cport
►Nnet
Cconst_buffer
Cmutable_buffer
►Nlinalg
Caccessor_conjugate
Caccessor_scaled
Ccolumn_major_t
Cexplicit_diagonal_t
Cimplicit_unit_diagonal_t
►Clayout_transpose
Cmapping
Clower_triangle_t
Crow_major_t
Cupper_triangle_t
►Nmeta
Cat
Cat< 0, list< Head, Tail... > >
Cat< I, list< Head, Tail... > >
Ccontains
Ccontains< Needle, list< Ts... > >
Ccount
Ccount< Needle, list< Ts... > >
Chead
Chead< list< Head, Tail... > >
Cindex_of
Cindex_of< Head, list< Head, Tail... > >
Cindex_of< T, list< Head, Tail... > >
Clist
Cpush_back
Cpush_back< T, list< Ts... > >
Cpush_front
Cpush_front< T, list< Ts... > >
Ctail
Ctail< list< Head, Tail... > >
►Nranges
Cconstruct_at_fn
Cdangling
Cdestroy_at_fn
Cdestroy_fn
Cin_fun_result
►Nstrings
Cfrom_floating_point_options
Cfrom_floating_point_result
Cfrom_integer_options
Cfrom_integer_result
Cto_floating_point_result
Cto_integer_options
Cto_integer_result
C_swap_no_throw
C_swappable_with_helper
C_swappable_with_helper< T, U, void_t< decltype(swap(declval< T >(), declval< U >()))> >
Cadd_const	Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). Adds const
Cadd_cv	Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). Adds both const and volatile
Cadd_lvalue_reference	Creates a lvalue reference type of T
Cadd_pointer	If T is a reference type, then provides the member typedef type which is a pointer to the referred type. Otherwise, if T names an object type, a function type that is not cv- or ref-qualified, or a (possibly cv-qualified) void type, provides the member typedef type which is the type T*. Otherwise (if T is a cv- or ref-qualified function type), provides the member typedef type which is the type T. The behavior of a program that adds specializations for add_pointer is undefined
Cadd_rvalue_reference	Creates a rvalue reference type of T
Cadd_volatile	Provides the member typedef type which is the same as T, except it has a cv-qualifier added (unless T is a function, a reference, or already has this cv-qualifier). Adds volatile
Cadopt_lock_t	Empty struct tag types used to specify locking strategy for etl::lock_guard, etl::scoped_lock, etl::unique_lock, and etl::shared_lock
►Caligned_storage	Provides the nested type type, which is a trivial standard-layout type suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment requirement is a divisor of Align. The default value of Align is the most stringent (the largest) alignment requirement for any object whose size is at most Len. If the default value is not used, Align must be the value of alignof(T) for some type T, or the behavior is undefined
Ctype
►Caligned_union	Provides the nested type type, which is a trivial standard-layout type of a size and alignment suitable for use as uninitialized storage for an object of any of the types listed in Types. The size of the storage is at least Len. aligned_union also determines the strictest (largest) alignment requirement among all Types and makes it available as the constant alignment_value. If sizeof...(Types) == 0 or if any of the types in Types is not a complete object type, the behavior is undefined. It is implementation-defined whether any extended alignment is supported. The behavior of a program that adds specializations for aligned_union is undefined
Ctype
Calignment_of	Alignment_of
Callocator_arg_t	Allocator_arg_t is an empty class type used to disambiguate the overloads of constructors and member functions of allocator-aware objects
Callocator_traits
Carray	A container that encapsulates fixed size arrays
Cassert_msg	Payload for an assertion
Cback_insert_iterator	Etl::back_insert_iterator is a LegacyOutputIterator that appends to a container for which it was constructed. The container's push_back() member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the etl::back_insert_iterator is a no-op
Cbad_function_call
Cbad_optional_access	Defines a type of object to be thrown by etl::optional::value when accessing an optional object that does not contain a value
Cbad_variant_access	Etl::bad_variant_access is the type of the exception thrown in the following situations: (1) etl::get(etl::variant) called with an index or type that does not match the currently active alternative. (2) etl::visit called to visit a variant that is valueless_by_exception
►Cbasic_bitset
Creference
Cbasic_common_reference	The class template basic_common_reference is a customization point that allows users to influence the result of common_reference for user-defined types (typically proxy references). The primary template is empty
Cbasic_common_reference< pair< T1, T2 >, pair< U1, U2 >, TQual, UQual >
►Cbasic_format_arg
Chandle
Cbasic_format_args
Cbasic_format_context	Provides access to formatting state consisting of the formatting arguments and the output iterator
Cbasic_format_parse_context
Cbasic_format_string
Cbasic_inplace_string	Basic_inplace_string class with fixed size capacity
Cbasic_string_view	The class template basic_string_view describes an object that can refer to a constant contiguous sequence of char-like objects with the first element of the sequence at position zero. A typical implementation holds only two members: a pointer to constant Char and a size
►Cbernoulli_distribution
Cparam_type
Cbidirectional_iterator_tag	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories
Cbinary_t
Cbit_and	Function object for performing bitwise AND. Effectively calls operator& on type T
Cbit_and< void >
Cbit_not	Function object for performing bitwise NOT. Effectively calls operator~ on type T
Cbit_not< void >
Cbit_or	Function object for performing bitwise OR. Effectively calls operator| on type T
Cbit_or< void >
Cbit_xor	Function object for performing bitwise XOR. Effectively calls operator^ on type T. https://en.cppreference.com/w/cpp/utility/functional/bit_xor
Cbit_xor< void >
Cbitset	The class template bitset represents a fixed-size sequence of Bits bits. Bitsets can be manipulated by standard logic operators
Cchar_traits	The char_traits class is a traits class template that abstracts basic character and string operations for a given character type
Cchar_traits< char >	Specializations of char_traits for type char
Cchar_traits< char16_t >	Specializations of char_traits for type char16_t
Cchar_traits< char32_t >	Specializations of char_traits for type char32_t
Cchar_traits< char8_t >	Specializations of char_traits for type char8_t
Cchar_traits< wchar_t >	Specializations of char_traits for type wchar_t
Ccommon_comparison_category
Ccommon_reference	Determines the common reference type of the types T..., that is, the type to which all the types in T... can be converted or bound. If such a type exists (as determined according to the rules below), the member type names that type. Otherwise, there is no member type. The behavior is undefined if any of the types in T... is an incomplete type other than (possibly cv-qualified) void
Ccommon_reference< T >
Ccommon_reference< T, U >
Ccommon_reference<>
Ccommon_type	Determines the common type among all types T..., that is the type all T... can be implicitly converted to. If such a type exists, the member type names that type. Otherwise, there is no member type
Ccommon_type< chrono::duration< Rep1, Period1 >, chrono::duration< Rep2, Period2 > >	Exposes the type named type, which is the common type of two etl::chrono::durations, whose period is the greatest common divisor of Period1 and Period2
Ccommon_type< chrono::time_point< Clock, Duration1 >, chrono::time_point< Clock, Duration2 > >	Exposes the type named type, which is the common type of two chrono::time_points
Ccommon_type< T >
Ccommon_type< T1, T2 >
Ccommon_type< T1, T2, R... >
Ccompare_three_way_result
Ccompare_three_way_result< T, U >
Ccomplex	A complex number
Cconditional	Provides member typedef type, which is defined as T if B is true at compile time, or as F if B is false
Cconditional< false, T, F >
Cconjunction	Forms the logical conjunction of the type traits B..., effectively performing a logical AND on the sequence of traits
Ccontiguous_iterator_tag	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories
Ccoroutine_handle
Ccoroutine_handle< void >
Ccoroutine_traits
Cdecay	Applies lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T, removes cv-qualifiers, and defines the resulting type as the member typedef type
Cdefault_accessor
Cdefault_delete
Cdefault_delete< T[]>
Cdefault_searcher	Default searcher. A class suitable for use with Searcher overload of etl::search that delegates the search operation to the pre-C++17 standard library's etl::search
Cdefer_lock_t	Empty struct tag types used to specify locking strategy for etl::lock_guard, etl::scoped_lock, etl::unique_lock, and etl::shared_lock
Cdestroying_delete_t	Tag type used to identify the destroying delete form of operator delete
Cdisjunction	Forms the logical disjunction of the type traits B..., effectively performing a logical OR on the sequence of traits
Cdiv_t	Return type for div
Cdivides	Function object for performing division. Effectively calls operator/ on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/divides
Cdivides< void >
Cdomain_error
Cdynamic_array
Cempty_c_array
Cenable_if	Define a member typedef only if a boolean constant is true
Cenable_if< true, Type >
Cequal_to	Function object for performing comparisons. Unless specialised, invokes operator== on type T. https://en.cppreference.com/w/cpp/utility/functional/equal_to
Cequal_to< void >
Cexception
Cexpected
Cextent	If T is an array type, provides the member constant value equal to the number of elements along the Nth dimension of the array, if N is in [0, rank_v<T>). For any other type, or if T is an array of unknown bound along its first dimension and N is 0, value is 0
Cextent< T[], 0 >
Cextent< T[], N >
Cextent< T[I], 0 >
Cextent< T[I], N >
Cextents
Cflat_multiset
Cflat_set	A flat_set is a container adaptor that provides an associative container interface that supports unique keys (contains at most one of each key value) and provides for fast retrieval of the keys themselves. flat_set supports random access iterators. Any sequence container supporting random access iteration can be used to instantiate flat_set
Cformat_to_n_result	Etl::format_to_n_result has no base classes, or members other than out, size and implicitly declared special member functions
Cformatter	The enabled specializations of formatter define formatting rules for a given type. Enabled specializations meet the Formatter requirements
Cformatter< char const *, char >
Cformatter< char, char >	Standard specializations for basic type char
Cformatter< char[N], char >
Cformatter< etl::inplace_string< Capacity >, char >
Cformatter< etl::string_view, char >
Cformatter< int, char >
Cformatter< long long, char >
Cformatter< long, char >
Cformatter< short, char >
Cformatter< unsigned long long, char >
Cformatter< unsigned long, char >
Cformatter< unsigned short, char >
Cformatter< unsigned, char >
Cforward_iterator_tag	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories
Cfrom_chars_result	Primitive numerical input conversion
Cfront_insert_iterator	Front_insert_iterator is an LegacyOutputIterator that prepends elements to a container for which it was constructed
Cfull_extent_t
Cfunction_ref	Non-owning view of a callable
Cfunction_ref< R(Args...) noexcept >
Cfunction_ref< R(Args...)>
Cgreater	Function object for performing comparisons. Unless specialised, invokes operator> on type T. https://en.cppreference.com/w/cpp/utility/functional/greater
Cgreater< void >
Cgreater_equal	Function object for performing comparisons. Unless specialised, invokes operator>= on type T. https://en.cppreference.com/w/cpp/utility/functional/greater_equal
Cgreater_equal< void >
Chalf
Chas_unique_object_representations	If T is TriviallyCopyable and if any two objects of type T with the same value have the same object representation, provides the member constant value equal true. For any other type, value is false
Chas_virtual_destructor	Https://en.cppreference.com/w/cpp/types/has_virtual_destructor
Chash	Hash
Chash< bool >
Chash< char >
Chash< char16_t >
Chash< char32_t >
Chash< char8_t >
Chash< coroutine_handle< T > >
Chash< double >
Chash< etl::nullptr_t >
Chash< etl::optional< T > >	The template specialization of etl::hash for the etl::optional class allows users to obtain hashes of the values contained in optional objects
Chash< float >
Chash< int >
Chash< long >
Chash< long double >
Chash< long long >
Chash< short >
Chash< signed char >
Chash< T * >
Chash< unsigned char >
Chash< unsigned int >
Chash< unsigned long >
Chash< unsigned long long >
Chash< unsigned short >
Chash< wchar_t >
Cidentity	Etl::identity is a function object type whose operator() returns its argument unchanged
Cidiv_result
Cignore	An object of unspecified type such that any value can be assigned to it with no effect. Intended for use with etl::tie when unpacking a etl::tuple, as a placeholder for the arguments that are not used
Cimaxdiv_t	Return type for imaxdiv
Cin_place_index_t	Disambiguation tags that can be passed to the constructors of etl::optional, etl::variant, and etl::any to indicate that the contained object should be constructed in-place, and (for the latter two) the type of the object to be constructed
Cin_place_t	Disambiguation tags that can be passed to the constructors of optional, variant, and any to indicate that the contained object should be constructed in-place, and (for the latter two) the type of the object to be constructed
Cin_place_type_t	Disambiguation tags that can be passed to the constructors of etl::optional, etl::variant, and etl::any to indicate that the contained object should be constructed in-place, and (for the latter two) the type of the object to be constructed
Cincrementable_traits
Cincrementable_traits< T * >
Cincrementable_traits< T >
Cincrementable_traits< T const >
Cindirectly_readable_traits
Cindirectly_readable_traits< I >
Cindirectly_readable_traits< T * >
Cindirectly_readable_traits< T >
Cindirectly_readable_traits< T const >
Cinplace_function
Cinplace_function< R(Args...), Capacity, Alignment >
Cinplace_vector
Cinplace_vector< T, 0 >
Cinput_iterator_tag	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories
Cinteger_sequence
Cintegral_constant
Cinvalid_argument
Cinvoke_result	Deduces the return type of an INVOKE expression at compile time
Cis_abstract
Cis_aggregate
Cis_arithmetic	If T is an arithmetic type (that is, an integral type or a floating-point type) or a cv-qualified version thereof, provides the member constant value equal true. For any other type, value is false. The behavior of a program that adds specializations for is_arithmetic or is_arithmetic_v (since C++17) is undefined
Cis_array	Checks whether T is an array type. Provides the member constant value which is equal to true, if T is an array type. Otherwise, value is equal to false
Cis_array< T[]>
Cis_array< T[N]>
Cis_assignable	If the expression etl::declval<T>() = etl::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type
Cis_base_of	If Derived is derived from Base or if both are the same non-union class (in both cases ignoring cv-qualification), provides the member constant value equal to true. Otherwise value is false
Cis_bitmask_type
Cis_bounded_array	Checks whether T is an array type of known bound. Provides the member constant value which is equal to true, if T is an array type of known bound. Otherwise, value is equal to false
Cis_bounded_array< T[N]>
Cis_builtin_integer
Cis_builtin_signed_integer
Cis_builtin_unsigned_integer	True if T is unsigned char or unsigned short or unsigned int or unsigned long or unsigned long long
Cis_class
Cis_compound	If T is a compound type (that is, array, function, object pointer, function pointer, member object pointer, member function pointer, reference, class, union, or enumeration, including any cv-qualified variants), provides the member constant value equal true. For any other type, value is false
Cis_const	If T is a const-qualified type (that is, const, or const volatile), provides the member constant value equal to true. For any other type, value is false
Cis_const< T const >
Cis_convertible	If the imaginary function definition To test() { return etl::declval<From>(); } is well-formed, (that is, either etl::declval<From>() can be converted to To using implicit conversions, or both From and To are possibly cv-qualified void), provides the member constant value equal to true. Otherwise value is false. For the purposes of this check, the use of etl::declval in the return statement is not considered an odr-use. Access checks are performed as if from a context unrelated to either type. Only the validity of the immediate context of the expression in the return statement (including conversions to the return type) is considered
Cis_copy_assignable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T const&>::value
Cis_copy_constructible	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_constructible<T, T const&>::value
Cis_default_constructible	If etl::is_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false
Cis_destructible	Because the C++ program terminates if a destructor throws an exception during stack unwinding (which usually cannot be predicted), all practical destructors are non-throwing even if they are not declared noexcept. All destructors found in the C++ standard library are non-throwing
Cis_destructible< Type[]>
Cis_destructible< void >
Cis_empty	F T is an empty type (that is, a non-union class type with no non-static data members other than bit-fields of size 0, no virtual functions, no virtual base classes, and no non-empty base classes), provides the member constant value equal to true. For any other type, value is false
Cis_enum
Cis_error_condition_enum
Cis_error_condition_enum< errc >
Cis_execution_policy	Checks whether T is a standard or implementation-defined execution policy type
Cis_execution_policy< etl::execution::sequenced_policy >
Cis_execution_policy< etl::execution::unsequenced_policy >
Cis_final	If T is a final class (that is, a class declared with the final specifier), provides the member constant value equal true. For any other type, value is false. If T is a class type, T shall be a complete type; otherwise, the behavior is undefined
Cis_floating_point	Checks whether T is a floating-point type. Provides the member constant value which is equal to true, if T is the type float, double, long double, including any cv-qualified variants. Otherwise, value is equal to false
Cis_function
Cis_fundamental	If T is a fundamental type (that is, arithmetic type, void, or nullptr_t), provides the member constant value equal true. For any other type, value is false
Cis_implicit_default_constructible
Cis_implicit_default_constructible< T, decltype(test_implicit_default_constructible< T const & >({})), false_type >
Cis_implicit_default_constructible< T, decltype(test_implicit_default_constructible< T const & >({})), true_type >
Cis_integral
Cis_invocable
Cis_invocable_r
Cis_lvalue_reference	Checks whether T is a lvalue reference type. Provides the member constant value which is equal to true, if T is a lvalue reference type. Otherwise, value is equal to false
Cis_lvalue_reference< T & >
Cis_member_function_pointer	Checks whether T is a non-static member function pointer. Provides the member constant value which is equal to true, if T is a non-static member function pointer type. Otherwise, value is equal to false
Cis_member_object_pointer	Checks whether T is a non-static member object pointer. Provides the member constant value which is equal to true, if T is a non-static member object pointer type. Otherwise, value is equal to false
Cis_member_pointer	If T is pointer to non-static member object or a pointer to non-static member function, provides the member constant value equal true. For any other type, value is false. The behavior of a program that adds specializations for is_member_pointer or is_member_pointer_v (since C++17) is undefined
Cis_move_assignable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T&&>::value
Cis_move_constructible	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_constructible<T, T&&>::value
Cis_nothrow_assignable	If the expression etl::declval<T>() = etl::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type
Cis_nothrow_assignable< T, U >
Cis_nothrow_constructible	The variable definition does not call any operation that is not trivial. For the purposes of this check, the call to etl::declval is considered trivial
Cis_nothrow_convertible
Cis_nothrow_convertible< From, To >
Cis_nothrow_copy_assignable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_nothrow_assignable<T&, T const&>::value
Cis_nothrow_copy_constructible	Same as copy, but uses etl::is_nothrow_constructible<T, T const&>
Cis_nothrow_default_constructible	If etl::is_nothrow_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false
Cis_nothrow_destructible	Https://en.cppreference.com/w/cpp/types/is_destructible
Cis_nothrow_destructible< Type & >
Cis_nothrow_destructible< Type && >
Cis_nothrow_destructible< Type[N]>
Cis_nothrow_move_assignable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T&&>::value
Cis_nothrow_move_constructible	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_nothrow_constructible<T, T&&>::value
Cis_nothrow_swappable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_nothrow_swappable_with<T&, T&>::value
Cis_nothrow_swappable_with
Cis_null_pointer
Cis_object	If T is an object type (that is any possibly cv-qualified type other than function, reference, or void types), provides the member constant value equal true. For any other type, value is false
Cis_placeholder
Cis_placeholder< T const >
Cis_placeholder< T const volatile >
Cis_placeholder< T volatile >
Cis_pointer	Checks whether T is a pointer to object or a pointer to function (but not a pointer to member/member function). Provides the member constant value which is equal to true, if T is a object/function pointer type. Otherwise, value is equal to false
Cis_polymorphic
Cis_reference	If T is a reference type (lvalue reference or rvalue reference), provides the member constant value equal true. For any other type, value is false. The behavior of a program that adds specializations for is_reference or is_reference_v is undefined
Cis_reference< T & >
Cis_reference< T && >
Cis_reference_wrapper
Cis_reference_wrapper< reference_wrapper< U > >
Cis_rvalue_reference	Checks whether T is a rvalue reference type. Provides the member constant value which is equal to true, if T is a rvalue reference type. Otherwise, value is equal to false
Cis_rvalue_reference< T && >
Cis_same	If T and U name the same type (taking into account const/volatile qualifications), provides the member constant value equal to true. Otherwise value is false
Cis_scalar	If T is a scalar type (that is a possibly cv-qualified arithmetic, pointer, pointer to member, enumeration, or etl::nullptr_t type), provides the member constant value equal true. For any other type, value is false
Cis_scoped_enum
Cis_scoped_enum< T >
Cis_signed	If T is an arithmetic type, provides the member constant value equal to true if T(-1) < T(0): this results in true for the floating-point types and the signed integer types, and in false for the unsigned integer types and the type bool. For any other type, value is false
Cis_specialized
Cis_specialized< Template, T, void_t< decltype(Template< T >{})> >
Cis_standard_layout	If T is a standard layout type (that is, a scalar type, a standard-layout class, or an array of such type/class, possibly cv-qualified), provides the member constant value equal to true. For any other type, value is false
Cis_swappable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_swappable_with<T&, T&>::value
Cis_swappable_with
Cis_trivial	If T is TrivialType (that is, a scalar type, a trivially copyable class with a trivial default constructor, or array of such type/class, possibly cv-qualified), provides the member constant value equal to true. For any other type, value is false
Cis_trivially_assignable	If the expression etl::declval<T>() = etl::declval<U>() is well-formed in unevaluated context, provides the member constant value equal true. Otherwise, value is false. Access checks are performed as if from a context unrelated to either type
Cis_trivially_constructible	The variable definition does not call any operation that is not trivial. For the purposes of this check, the call to etl::declval is considered trivial
Cis_trivially_copy_assignable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_trivially_assignable<T&, T const&>::value
Cis_trivially_copy_constructible	Same as copy, but uses etl::is_trivially_constructible<T, T const&>
Cis_trivially_copyable	If T is a TriviallyCopyable type, provides the member constant value equal to true. For any other type, value is false. The only trivially copyable types are scalar types, trivially copyable classes, and arrays of such types/classes (possibly cv-qualified). group is_trivial_copyable
Cis_trivially_default_constructible	If etl::is_trivially_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false
Cis_trivially_destructible	Storage occupied by trivially destructible objects may be reused without calling the destructor
Cis_trivially_move_assignable	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_assignable<T&, T&&>::value
Cis_trivially_move_constructible	If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to etl::is_trivially_constructible<T, T&&>::value
Cis_typename
Cis_unbounded_array	Checks whether T is an array type of unknown bound. Provides the member constant value which is equal to true, if T is an array type of unknown bound. Otherwise, value is equal to false
Cis_unbounded_array< T[]>
Cis_union
Cis_unsigned	If T is an arithmetic type, provides the member constant value equal to true if T(0) < T(-1): this results in true for the unsigned integer types and the type bool and in false for the signed integer types and the floating-point types. For any other type, value is false. The behavior of a program that adds specializations for is_unsigned or is_unsigned_v (since C++17) is undefined
Cis_void	Define a member typedef only if a boolean constant is true
Cis_volatile
Cis_volatile< T volatile >
Citerator_traits	Iterator_traits is the type trait class that provides uniform interface to the properties of LegacyIterator types. This makes it possible to implement algorithms only in terms of iterators
Citerator_traits< T * >
►Clayout_left
Cmapping
►Clayout_right
Cmapping
►Clayout_stride
Cmapping
Cldiv_t	Return type for ldiv
Clength_error
Cless	Function object for performing comparisons. Unless specialised, invokes operator< on type T. https://en.cppreference.com/w/cpp/utility/functional/less
Cless< void >
Cless_equal	Function object for performing comparisons. Unless specialised, invokes operator<= on type T. https://en.cppreference.com/w/cpp/utility/functional/less_equal
Cless_equal< void >
Clldiv_t	Return type for lldiv
Clock_guard	The struct lock_guard is a mutex wrapper that provides a convenient RAII-style mechanism for owning a mutex for the duration of a scoped block. When a lock_guard object is created, it attempts to take ownership of the mutex it is given. When control leaves the scope in which the lock_guard object was created, the lock_guard is destructed and the mutex is released. The lock_guard struct is non-copyable
Clogic_error
Clogical_and	Function object for performing logical AND (logical conjunction). Effectively calls operator&& on type T. https://en.cppreference.com/w/cpp/utility/functional/logical_and
Clogical_and< void >
Clogical_not	Function object for performing logical NOT (logical negation). Effectively calls operator! for type T. https://en.cppreference.com/w/cpp/utility/functional/logical_not
Clogical_not< void >
Clogical_or	Function object for performing logical OR (logical disjunction). Effectively calls operator|| on type T. https://en.cppreference.com/w/cpp/utility/functional/logical_or
Clogical_or< void >
Cmake_signed	If T is an integral (except bool) or enumeration type, provides the member typedef type which is the unsigned integer type corresponding to T, with the same cv-qualifiers. If T is signed or unsigned char, short, int, long, long long; the unsigned type from this list corresponding to T is provided. The behavior of a program that adds specializations for make_signed is undefined
Cmake_unsigned	If T is an integral (except bool) or enumeration type, provides the member typedef type which is the unsigned integer type corresponding to T, with the same cv-qualifiers. If T is signed or unsigned char, short, int, long, long long; the unsigned type from this list corresponding to T is provided. The behavior of a program that adds specializations for make_unsigned is undefined
Cmax_align_t	Etl::max_align_t is a trivial standard-layout type whose alignment requirement is at least as strict (as large) as that of every scalar type
Cmdarray
Cmdspan
Cminus	Function object for performing subtraction. Effectively calls operator- on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/minus
Cminus< void >
Cmodulus	Function object for computing remainders of divisions. Implements operator% for type T. https://en.cppreference.com/w/cpp/utility/functional/modulus
Cmodulus< void >
Cmonostate	Unit type intended for use as a well-behaved empty alternative in etl::variant. In particular, a variant of non-default-constructible types may list etl::monostate as its first alternative: this makes the variant itself default-constructible
Cmonotonic_allocator
Cmultiplies	Function object for performing multiplication. Effectively calls operator* on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/multiplies
Cmultiplies< void >
Cnegate	Function object for performing negation. Effectively calls operator- on an instance of type T. https://en.cppreference.com/w/cpp/utility/functional/negate
Cnegate< void >
Cnegation	Forms the logical negation of the type trait B
Cnontype_t
Cnot_equal_to	Function object for performing comparisons. Unless specialised, invokes operator!= on type T. https://en.cppreference.com/w/cpp/utility/functional/not_equal_to
Cnot_equal_to< void >
Cnothrow_t	Etl::nothrow_t is an empty class type used to disambiguate the overloads of throwing and non-throwing allocation functions
Cnullopt_t	Etl::nullopt_t is an empty class type used to indicate optional type with uninitialized state. In particular, etl::optional has a constructor with nullopt_t as a single argument, which creates an optional that does not contain a value
Cnumeric_limits
Cnumeric_limits< bool >
Cnumeric_limits< char >
Cnumeric_limits< char8_t >
Cnumeric_limits< double >
Cnumeric_limits< float >
Cnumeric_limits< int >
Cnumeric_limits< long >
Cnumeric_limits< long double >
Cnumeric_limits< long long >
Cnumeric_limits< short >
Cnumeric_limits< signed char >
Cnumeric_limits< T const >
Cnumeric_limits< T const volatile >
Cnumeric_limits< T volatile >
Cnumeric_limits< unsigned char >
Cnumeric_limits< unsigned int >
Cnumeric_limits< unsigned long >
Cnumeric_limits< unsigned long long >
Cnumeric_limits< unsigned short >
Coptional	The class template optional manages an optional contained value, i.e. a value that may or may not be present
Coptional< T & >
Cout_of_range
Coutput_iterator_tag	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories
Coverflow_error
Coverload
Cpair	Etl::pair is a class template that provides a way to store two heterogeneous objects as a single unit. A pair is a specific case of a etl::tuple with two elements. If neither T1 nor T2 is a possibly cv-qualified class type with non-trivial destructor, or array thereof, the destructor of pair is trivial
Cpartial_ordering
Cpiecewise_construct_t	Etl::piecewise_construct_t is an empty class tag type used to disambiguate between different functions that take two tuple arguments
Cplus	Function object for performing addition. Effectively calls operator+ on two instances of type T. https://en.cppreference.com/w/cpp/utility/functional/plus
Cplus< void >
Cpointer_int_pair	This struct implements a pair of a pointer and small integer. It is designed to represent this in the space required by one pointer by bitmangling the integer into the low part of the pointer. This can only be done for small integers: typically up to 3 bits, but it depends on the number of bits available according to pointer_like_traits for the type
Cpointer_int_pair_info
Cpointer_like_traits	A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity
Cpointer_like_traits< pointer_int_pair< PtrT, IntBits, IntT, PtrTraits > >
Cpointer_like_traits< T const * >	Provide pointer_like_traits for const pointers
Cpointer_like_traits< T const >	Provide pointer_like_traits for const things
Cpointer_like_traits< uintptr_t >	Provide pointer_like_traits for uintptr_t
Cpointer_traits	The pointer_traits class template provides the standardized way to access certain properties of pointer-like types
Cpointer_traits< T * >	The pointer_traits class template provides the standardized way to access certain properties of pointer-like types
Crandom_access_iterator_tag	Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five (until C++20) six (since C++20) iterator categories
Crange_error
Crank	If Type is an array type, provides the member constant value equal to the number of dimensions of the array. For any other type, value is 0. The behavior of a program that adds specializations for rank or rank_v is undefined
Crank< T[]>
Crank< T[N]>
Cratio	The typename template provides compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number as long as its numerator Num and denominator Denom are representable as compile-time constants of type intmax_t
Cratio_equal	Compares two ratio objects for equality at compile-time. If the ratios R1 and R2 are equal, provides the member constant value equal true. Otherwise, value is false
Cratio_greater	Compares two ratio objects for equality at compile-time. If the ratio R1 is greater than the ratio R2, provides the member constant value equal true. Otherwise, value is false
Cratio_greater_equal	Compares two ratio objects for equality at compile-time. If the ratio R1 is greater than or equal to the ratio R2, provides the member constant value equal true. Otherwise, value is false
Cratio_less	Compares two ratio objects for equality at compile-time. If the ratio R1 is less than the ratio R2, provides the member constant value equal true. Otherwise, value is false
Cratio_less_equal	Compares two ratio objects for equality at compile-time. If the ratio R1 is less than or equal to the ratio R2, provides the member constant value equal true. Otherwise, value is false
Cratio_not_equal	Compares two ratio objects for equality at compile-time. If the ratios R1 and R2 are not equal, provides the member constant value equal true. Otherwise, value is false
Creference_wrapper	Reference_wrapper is a class template that wraps a reference in a copyable, assignable object. It is frequently used as a mechanism to store references inside standard containers (like etl::static_vector) which cannot normally hold references. Specifically, reference_wrapper is a CopyConstructible and CopyAssignable wrapper around a reference to object or reference to function of type T. Instances of reference_wrapper are objects (they can be copied or stored in containers) but they are implicitly convertible to T&, so that they can be used as arguments with the functions that take the underlying type by reference. If the stored reference is Callable, reference_wrapper is callable with the same arguments
Cremove_all_extents	If T is a multidimensional array of some type X, provides the member typedef type equal to X, otherwise type is T. The behavior of a program that adds specializations for remove_all_extents is undefined
Cremove_all_extents< T[]>
Cremove_all_extents< T[N]>
Cremove_const	Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed. Removes the topmost const
Cremove_const< Type const >
Cremove_cv	Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed. Removes the topmost const, or the topmost volatile, or both, if present
Cremove_cvref	If the type T is a reference type, provides the member typedef type which is the type referred to by T with its topmost cv-qualifiers removed. Otherwise type is T with its topmost cv-qualifiers removed
Cremove_extent	If T is an array of some type X, provides the member typedef type equal to X, otherwise type is T. Note that if T is a multidimensional array, only the first dimension is removed. The behavior of a program that adds specializations for remove_extent is undefined
Cremove_extent< T[]>
Cremove_extent< T[N]>
Cremove_pointer	Provides the member typedef type which is the type pointed to by T, or, if T is not a pointer, then type is the same as T. The behavior of a program that adds specializations for remove_pointer is undefined
Cremove_pointer< T * >
Cremove_pointer< T *const >
Cremove_pointer< T *const volatile >
Cremove_pointer< T *volatile >
Cremove_reference
Cremove_reference< T & >
Cremove_reference< T && >
Cremove_volatile	Provides the member typedef type which is the same as T, except that its topmost cv-qualifiers are removed. Removes the topmost volatile
Cremove_volatile< Type volatile >
Creverse_iterator	Reverse_iterator is an iterator adaptor that reverses the direction of a given iterator. In other words, when provided with a bidirectional iterator, reverse_iterator produces a new iterator that moves from the end to the beginning of the sequence defined by the underlying bidirectional iterator. This is the iterator returned by member functions rbegin() and rend() of the standard library containers
Cruntime_error
Cscope_exit	The class template scope_exit is a general-purpose scope guard intended to call its exit function when a scope is exited
Csmall_ptr	Compressed pointer to specified size. Intended to be used as a drop in replacement for native pointers
Csorted_equivalent_t
Csorted_unique_t
Csource_location	A class representing information about the source code, such as file names, line numbers, and function names
Cspan	A non-owning view over a contiguous sequence of objects
Cstack	The stack class is a container adapter that gives the programmer the functionality of a stack - specifically, a LIFO (last-in, first-out) data structure
Cstatic_set	Static_set is an associative container that contains a sorted set of unique objects of type Key. Sorting is done using the key comparison function Compare
Cstatic_vector	Dynamically-resizable fixed-capacity vector
Cstrided_slice
Cstring_constant
Cstrong_ordering
Csubmdspan_mapping_result
Csuspend_always
Csuspend_never
Ctimespec
Ctm
Cto_chars_result	Primitive numerical output conversion
Ctry_to_lock_t	Empty struct tag types used to specify locking strategy for etl::lock_guard, etl::scoped_lock, etl::unique_lock, and etl::shared_lock
Ctuple
Ctuple_element	Provides compile-time indexed access to the type of the elements of the array using tuple-like interface
Ctuple_element< I, array< T, N > >
Ctuple_element< I, etl::complex< T > >
Ctuple_element< I, pair< T1, T2 > >	The partial specializations of tuple_element for pairs provide compile-time access to the types of the pair's elements, using tuple-like syntax. The program is ill-formed if I >= 2
Ctuple_element< I, T const >
Ctuple_element< I, T const volatile >
Ctuple_element< I, T volatile >
Ctuple_element< I, tuple< Ts... > >
Ctuple_size
Ctuple_size< array< T, N > >	Provides access to the number of elements in an array as a compile-time constant expression
Ctuple_size< etl::complex< T > >
Ctuple_size< pair< T1, T2 > >	The partial specialization of tuple_size for pairs provides a compile-time way to obtain the number of elements in a pair, which is always 2, using tuple-like syntax
Ctuple_size< T const >
Ctuple_size< T const volatile >
Ctuple_size< T volatile >
Ctuple_size< tuple< Ts... > >
Ctype_identity
Cunderflow_error
Cunderlying_type	The underlying type of an enum
Cunexpect_t
Cunexpected
►Cuniform_int_distribution
Cparam_type
►Cuniform_real_distribution
Cparam_type
Cuninitialized_array
Cuninitialized_array< T, Size >
Cuninitialized_union
Cunique_lock	The struct unique_lock is a general-purpose mutex ownership wrapper allowing deferred locking, time-constrained attempts at locking, recursive locking, transfer of lock ownership, and use with condition variables
Cunwrap_ref_decay
Cunwrap_reference
Cunwrap_reference< reference_wrapper< T > >
Cuses_allocator	If T has a member typedef allocator_type which is convertible from Alloc, the member constant value is true. Otherwise value is false
Cvariadic_union
Cvariadic_union< T, Ts... >
Cvariant
Cvariant_alternative	Provides compile-time indexed access to the types of the alternatives of the possibly cv-qualified variant, combining cv-qualifications of the variant (if any) with the cv-qualifications of the alternative
Cvariant_alternative< Idx, T const >
Cvariant_alternative< Idx, T const volatile >
Cvariant_alternative< Idx, T volatile >
Cvariant_alternative< Idx, variant< Ts... > >
Cvariant_size
Cvariant_size< T const >
Cvariant_size< T const volatile >
Cvariant_size< T volatile >
Cvariant_size< variant< Ts... > >
Cvector
Cweak_ordering
Cxorshift	Https://en.wikipedia.org/wiki/Xorshift
Cxoshiro128plus
Cxoshiro128plusplus
Cxoshiro128starstar