Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

Caccessor_conjugate< Accessor >
Caccessor_scaled< ScalingFactor, Accessor >
Cadd_const< T >	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< T >	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< T >	Creates a lvalue reference type of T
Cadd_pointer< T >	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< T >	Creates a rvalue reference type of T
Cadd_volatile< T >	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< Len, Align >	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
Caligned_union< Len, Types >	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
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< Alloc >
Carray< Type, Size >	A container that encapsulates fixed size arrays
Cassert_msg	Payload for an assertion
Cat< I, List >
Cat< 0, list< Head, Tail... > >
Cat< I, list< Head, Tail... > >
Cback_insert_iterator< Container >	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
Cbasic_bitset< Bits, WordType >
Cbasic_common_reference< T, U, TQ, UQ >	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< Context >
Cbasic_format_args< Context >
Cbasic_format_context< OutputIt, CharT >	Provides access to formatting state consisting of the formatting arguments and the output iterator
Cbasic_format_parse_context< CharT >
Cbasic_format_string< CharT, Args >
Cbasic_inplace_string< Char, Capacity, Traits >	Basic_inplace_string class with fixed size capacity
Cbasic_string_view< Char, Traits >	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
Cbinary_t
Cbit_and< T >	Function object for performing bitwise AND. Effectively calls operator& on type T
Cbit_and< void >
Cbit_not< T >	Function object for performing bitwise NOT. Effectively calls operator~ on type T
Cbit_not< void >
Cbit_or< T >	Function object for performing bitwise OR. Effectively calls operator| on type T
Cbit_or< void >
Cbit_xor< T >	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< Bits >	The class template bitset represents a fixed-size sequence of Bits bits. Bitsets can be manipulated by standard logic operators
►Cbool_constant<(R1::num *R2::den > R2::num *R1::den)>
Cratio_greater< R1, R2 >	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
►Cbool_constant<(R1::num *R2::den >=R2::num *R1::den)>
Cratio_greater_equal< R1, R2 >	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
►Cbool_constant<(R1::num *R2::den< R2::num *R1::den)>
Cratio_less< R1, R2 >	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
►Cbool_constant<(R1::num *R2::den<=R2::num *R1::den)>
Cratio_less_equal< R1, R2 >	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
Cchar_traits< CharT >	The char_traits class is a traits class template that abstracts basic character and string operations for a given character type
►Cchar_traits_base< char, int, -1 >
Cchar_traits< char >	Specializations of char_traits for type char
►Cchar_traits_base< char16_t, uint_least16_t, uint_least16_t(0xFFFF)>
Cchar_traits< char16_t >	Specializations of char_traits for type char16_t
►Cchar_traits_base< char32_t, uint_least32_t, uint_least32_t(0xFFFFFFFF)>
Cchar_traits< char32_t >	Specializations of char_traits for type char32_t
►Cchar_traits_base< char8_t, unsigned, static_cast< unsigned >(-1)>
Cchar_traits< char8_t >	Specializations of char_traits for type char8_t
►Cchar_traits_base< wchar_t, wint_t, static_cast< wint_t >(WEOF)>
Cchar_traits< wchar_t >	Specializations of char_traits for type wchar_t
Ccolumn_major_t
►Ccommon_cmpcat_base<(0U|...|(is_same_v< Ts, strong_ordering > ? 0U :is_same_v< Ts, weak_ordering > ? 4U :is_same_v< Ts, partial_ordering > ? 2U :1U))>
Ccommon_comparison_category< Ts >
Ccommon_reference< T >	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< T >	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< common_type< T1, T2 >::type, R... >
►Ccommon_type< T, T >
Ccommon_type< T >
►Ccommon_type_2_impl< decay_t< T1 >, decay_t< T2 > >
Ccommon_type< T1, T2 >
►Ccommon_type_multi_impl< void, T1, T2, R... >
Ccommon_type< T1, T2, R... >
Ccompare_three_way_result< T, U >
Ccompare_three_way_result< T, U >
Ccomplex< T >	A complex number
Cconditional< B, T, F >	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 >
►Cconditional_t
Cunwrap_ref_decay< T >
Cconst_buffer
Cconstruct_at_fn
Ccontains< Needle, Haystack >
►Ccoro_traits< R, typename >
Ccoroutine_traits< R, Args >
Ccoroutine_handle< Promise >
Ccoroutine_handle< void >
Ccount< Needle, Haystack >
Cdangling
Cday	The class day represents a day in a month
Cdecay< T >	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< ElementType >
Cdefault_delete< T >
Cdefault_delete< T[]>
Cdefault_searcher< ForwardIter, Predicate >	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
Cdestroy_at_fn
Cdestroy_fn
Cdestroying_delete_t	Tag type used to identify the destroying delete form of operator delete
Cdevice< Driver >
Cdiv_t	Return type for div
Cdivides< T >	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 >
Cduration< Rep, Period >	Class template etl::chrono::duration represents a time interval
Cduration_values< Rep >	The etl::chrono::duration_values type defines three common durations
Cdynamic_array< T, Allocator >
Cempty_c_array
Cenable_if< bool, Type >	Define a member typedef only if a boolean constant is true
Cenable_if< true, Type >
Cequal_to< T >	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
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
►Clogic_error
Cdomain_error
Cinvalid_argument
Clength_error
Cout_of_range
►Cruntime_error
Coverflow_error
Crange_error
Cunderflow_error
Cexpected< T, E >
Cexplicit_diagonal_t
Cextents< IndexType, Extents >
Cflat_multiset< Key, KeyContainer, Compare >
Cflat_set< Key, Container, Compare >	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
Cforever	Runs the task loop forever
Cformat_to_n_result< Out >	Etl::format_to_n_result has no base classes, or members other than out, size and implicitly declared special member functions
Cformatter< T, CharT >	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 >
Cfrom_chars_result	Primitive numerical input conversion
Cfrom_floating_point_options
Cfrom_floating_point_result
Cfrom_integer_options
Cfrom_integer_result
Cfront_insert_iterator< Container >	Front_insert_iterator is an LegacyOutputIterator that prepends elements to a container for which it was constructed
Cfull_extent_t
Cfunction_ref< Signature >	Non-owning view of a callable
►Cfunction_ref< false, R(Args...)>
Cfunction_ref< R(Args...)>
►Cfunction_ref< true, R(Args...)>
Cfunction_ref< R(Args...) noexcept >
►CFunctor...
Coverload< Functor >
Cgpio_memory_layout
Cgreater< T >	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< T >	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
Cbasic_format_arg< Context >::handle
Chash< T >	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 >
Chead< Ts >
Chead< list< Head, Tail... > >
Cidentity	Etl::identity is a function object type whose operator() returns its argument unchanged
Cidiv_result< Int >
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
Cimplicit_unit_diagonal_t
Cin_fun_result< I, F >
Cin_place_index_t< I >	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< 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< I >
Cincrementable_traits< T * >
►Cincrementable_traits< T >
Cincrementable_traits< T const >
Cindex_of< T, List >
Cindirectly_readable_traits< I >
Cindirectly_readable_traits< I >
Cinplace_function< Signature, Capacity, Alignment >
Cinplace_function< R(Args...), Capacity, Alignment >
Cinplace_vector< T, Capacity >
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
►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
►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
►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
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
Cinteger_sequence< T, Ints >
►Cintegral_constant< Type, Val >
Cis_invocable< Fn, ArgTypes >
Cis_invocable_r< R, Fn, ArgTypes >
Cis_nothrow_constructible< T, Args >	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_signed< T >	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_unsigned< T >	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
Cuses_allocator< Type, Alloc >	If T has a member typedef allocator_type which is convertible from Alloc, the member constant value is true. Otherwise value is false
►Cintegral_constant< bool, B >
►Cis_assignable< add_lvalue_reference_t< T >, add_lvalue_reference_t< T const > >
Cis_copy_assignable< T >	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_assignable< add_lvalue_reference_t< T >, add_rvalue_reference_t< T > >
Cis_move_assignable< T >	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_floating_point< Rep >
Ctreat_as_floating_point< Rep >	The etl::chrono::treat_as_floating_point trait helps determine if a duration can be converted to another duration with a different tick period
Cis_nothrow_convertible< From, To >
►Cis_same< nullptr_t, remove_cv_t< T > >
Cis_null_pointer< T >
►Cis_same< void, remove_cv_t< T > >
Cis_void< T >	Define a member typedef only if a boolean constant is true
►Cis_trivially_assignable< add_lvalue_reference_t< T >, add_lvalue_reference_t< T const > >
Cis_trivially_copy_assignable< T >	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_assignable< add_lvalue_reference_t< T >, add_rvalue_reference_t< T > >
Cis_trivially_move_assignable< T >	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_constructible< T, add_lvalue_reference_t< add_const_t< T > > >
Cis_trivially_copy_constructible< T >	Same as copy, but uses etl::is_trivially_constructible<T, T const&>
►Cis_trivially_constructible< T >
Cis_trivially_default_constructible< T >	If etl::is_trivially_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false
►Cis_trivially_constructible< T, add_rvalue_reference_t< T > >
Cis_trivially_move_constructible< T >	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
C_swap_no_throw< T, U >
Cconjunction< B >	Forms the logical conjunction of the type traits B..., effectively performing a logical AND on the sequence of traits
►Cis_empty< T >
Cis_empty< T >	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
Cdisjunction< B >	Forms the logical disjunction of the type traits B..., effectively performing a logical OR on the sequence of traits
Chas_unique_object_representations< T >	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< T >	Https://en.cppreference.com/w/cpp/types/has_virtual_destructor
Cis_abstract< T >
Cis_aggregate< T >
Cis_arithmetic< T >	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_assignable< T, U >	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< Base, Derived >	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_builtin_integer< T >
Cis_builtin_signed_integer< T >
Cis_builtin_unsigned_integer< T >	True if T is unsigned char or unsigned short or unsigned int or unsigned long or unsigned long long
Cis_class< T >
Cis_compound< T >	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_convertible< From, To >	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_enum< T >
Cis_final< T >	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< T >	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< T >
Cis_fundamental< T >	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_integral< T >
Cis_member_object_pointer< T >	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_nothrow_assignable< T, U >
Cis_nothrow_convertible< From, To >
Cis_nothrow_swappable_with< T, U >
Cis_object< T >	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_polymorphic< T >
Cis_same< T, U >	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< T >	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< T >
Cis_standard_layout< T >	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_with< T, U >
Cis_trivial< T >	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< T, U >	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< T, Args >	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_copyable< T >	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_destructible< T >	Storage occupied by trivially destructible objects may be reused without calling the destructor
Cis_union< T >
Ccontains< Needle, list< Ts... > >
Cnegation< B >	Forms the logical negation of the type trait B
Cratio_equal< R1, R2 >	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_not_equal< R1, R2 >	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
►Cintegral_constant< bool, B >< false >
C_swappable_with_helper< T, U, void_t< decltype(swap(declval< T >(), declval< U >()))> >
►Cis_constructible_helper< void_t<>, T, Args... >
Cis_copy_constructible< T >	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< T >	If etl::is_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false
Cis_move_constructible< T >	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_empty< T >
►Cis_member_function_pointer_helper< remove_cv_t< T > >
Cis_member_function_pointer< T >	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_pointer_helper< remove_cv_t< T > >
Cis_member_pointer< T >	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_pointer< etl::remove_cv_t< T > >
Cis_pointer< T >	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_array< T[N]>
Cis_array< T[]>
Cis_bounded_array< T[N]>
Cis_const< T const >
Cis_error_condition_enum< errc >
Cis_execution_policy< etl::execution::sequenced_policy >
Cis_execution_policy< etl::execution::unsequenced_policy >
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_lvalue_reference< T & >
►Cis_nothrow_assignable< add_lvalue_reference_t< T >, add_lvalue_reference_t< T const > >
Cis_nothrow_copy_assignable< T >	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_assignable< add_lvalue_reference_t< T >, add_rvalue_reference_t< T > >
Cis_nothrow_move_assignable< T >	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_assignable< T, U >
Cis_reference< T & >
Cis_reference< T && >
Cis_reference_wrapper< reference_wrapper< U > >
Cis_rvalue_reference< T && >
Cis_scoped_enum< T >
Cis_specialized< Template, T, void_t< decltype(Template< T >{})> >
Cis_unbounded_array< T[]>
Cis_volatile< T volatile >
C_swappable_with_helper< T, U, typename >
Cis_clock< typename >	If T satisfies the Clock requirements, provides the member constant value equal true. For any other type, value is false
Cis_array< T >	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_bitmask_type< T >
Cis_bounded_array< T >	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_const< T >	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_destructible< Type[]>
Cis_destructible< void >
Cis_error_condition_enum< T >
Cis_execution_policy< T >	Checks whether T is a standard or implementation-defined execution policy type
Cis_implicit_default_constructible< T, typename, typename >
Cis_implicit_default_constructible< T, decltype(test_implicit_default_constructible< T const & >({})), false_type >
Cis_lvalue_reference< T >	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_nothrow_assignable< T, U >	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_reference< T >	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_wrapper< T >
Cis_rvalue_reference< T >	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_scoped_enum< T >
Cis_specialized< typename, typename, typename >
Cis_unbounded_array< T >	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_volatile< T >
►Cintegral_constant< bool, B >< true >
C_swappable_with_helper< T, U, void_t< decltype(swap(declval< T >(), declval< U >()))> >
Cis_array< T[N]>
Cis_array< T[]>
Cis_bounded_array< T[N]>
Cis_const< T const >
Cis_error_condition_enum< errc >
Cis_execution_policy< etl::execution::sequenced_policy >
Cis_execution_policy< etl::execution::unsequenced_policy >
Cis_implicit_default_constructible< T, decltype(test_implicit_default_constructible< T const & >({})), true_type >
Cis_lvalue_reference< T & >
Cis_nothrow_convertible< From, To >
Cis_nothrow_destructible< Type & >
Cis_nothrow_destructible< Type && >
Cis_reference< T & >
Cis_reference< T && >
Cis_reference_wrapper< reference_wrapper< U > >
Cis_rvalue_reference< T && >
Cis_specialized< Template, T, void_t< decltype(Template< T >{})> >
Cis_unbounded_array< T[]>
Cis_volatile< T volatile >
►Cintegral_constant< etl::size_t, 0 >
Cindex_of< Head, list< Head, Tail... > >
►Cintegral_constant< etl::size_t, 2 >
Ctuple_size< etl::complex< T > >
►Cintegral_constant< etl::size_t, index_of_v< T, list< Tail... > >+1 >
Cindex_of< T, list< Head, Tail... > >
►Cintegral_constant< etl::size_t, sizeof...(Ts)>
Cvariant_size< variant< Ts... > >
►Cintegral_constant< etl::size_t,(etl::is_same_v< Needle, Ts >+...+0)>
Ccount< Needle, list< Ts... > >
►Cintegral_constant< int, 0 >
Cis_placeholder< T const >
Cis_placeholder< T const volatile >
Cis_placeholder< T volatile >
Cis_placeholder< T >
Cintegral_constant< int, N >
►Cintegral_constant< size_t, 0 >
►Cextent< T, N - 1 >
Cextent< T[I], N >
Cextent< T[], N >
Cextent< T[I], 0 >
Cextent< T[I], N >
Cextent< T[], 0 >
Cextent< T[], N >
Crank< T[N]>
Crank< T[]>
Cextent< T, N >	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 >
Crank< T >	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
►Cintegral_constant< size_t, 2 >
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
►Cintegral_constant< size_t, alignof(T)>
Calignment_of< T >	Alignment_of
►Cintegral_constant< size_t, I >
Cextent< T[I], 0 >
►Cintegral_constant< size_t, N >
Ctuple_size< array< T, N > >	Provides access to the number of elements in an array as a compile-time constant expression
►Cintegral_constant< size_t, rank< T >::value+1 >
Crank< T[N]>
Crank< T[]>
►Cintegral_constant< size_t, sizeof...(Ts)>
Ctuple_size< tuple< Ts... > >
►Cintegral_constant< size_t, tuple_size< T >::value >
Ctuple_size< T const >
Ctuple_size< T const volatile >
Ctuple_size< T volatile >
►Cinvoke_result< void, F, ArgTypes... >
Cinvoke_result< F, ArgTypes >	Deduces the return type of an INVOKE expression at compile time
►Cis_destructible_safe< T, bool, bool >
Cis_destructible< Type[]>
Cis_destructible< void >
Cis_destructible< T >	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_nothrow_destructible_helper< is_destructible_v< Type >, Type >
Cis_nothrow_destructible< Type & >
Cis_nothrow_destructible< Type && >
Cis_nothrow_destructible< Type[N]>
►Cis_nothrow_destructible< Type >	Https://en.cppreference.com/w/cpp/types/is_destructible
Cis_nothrow_destructible< Type[N]>
Cis_typename< T >
Cisr
►Citerator_traits_impl< Iter, typename >
Citerator_traits< T * >
Citerator_traits< Iter >	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
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
Clayout_left
Clayout_right
Clayout_stride
Clayout_transpose< Layout >
Cldiv_t	Return type for ldiv
Cless< T >	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< T >	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 >
Clist< Ts >
Clldiv_t	Return type for lldiv
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
Clock_guard< MutexT >	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
Clogical_and< T >	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< T >	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< T >	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 >
Clower_triangle_t
►Cmake_signed< Type >
Cmake_signed< Type >	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< Type >
Cmake_unsigned< Type >	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
Clayout_left::mapping< Extents >
Clayout_right::mapping< Extents >
Clayout_stride::mapping< Extents >
Clayout_transpose< Layout >::mapping< Extents >
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
►Cmaybe_value_type< T >
Cindirectly_readable_traits< T * >
►Cmaybe_value_type< T::element_type >
►Cindirectly_readable_traits< T >
Cindirectly_readable_traits< T const >
►Cmaybe_value_type< T::value_type >
Cindirectly_readable_traits< T >
Cindirectly_readable_traits< T >
Cmdarray< ElementType, Extents, LayoutPolicy, Container >
Cmdspan< ElementType, Extents, LayoutPolicy, AccessorPolicy >
Cminus< T >	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< T >	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< T >
Cmonth	The class month represents a month in a year
Cmonth_day
Cmonth_day_last
Cmonth_weekday
Cmonth_weekday_last
Cmultiplies< T >	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 >
Cmutable_buffer
Cnegate< T >	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 >
Cnever	Runs the task loop 0 times
Cnontype_t< V >
Cnot_equal_to< T >	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< T >
Cnumeric_limits< T const >
Cnumeric_limits< T const volatile >
Cnumeric_limits< T volatile >
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< unsigned char >
Cnumeric_limits< unsigned int >
Cnumeric_limits< unsigned long >
Cnumeric_limits< unsigned long long >
Cnumeric_limits< unsigned short >
Coptional< T >	The class template optional manages an optional contained value, i.e. a value that may or may not be present
Coptional< T & >
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
Cpair< T1, T2 >	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
Cbernoulli_distribution::param_type
Cuniform_int_distribution< IntType >::param_type
Cuniform_real_distribution< RealType >::param_type
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< T >	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< PointerT, IntBits, IntType, PtrTraits, Info >	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< PointerT, IntBits, PtrTraits >
Cpointer_like_traits< T >	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< Ptr >	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
Cport
Cpush_back< T, List >
Cpush_back< T, list< Ts... > >
Cpush_front< T, List >
Cpush_front< T, list< Ts... > >
Cqueue< T, Size >	Wrapper around a FreeRTOS queue
Cratio< Num, Denom >	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
Cbasic_bitset< Bits, WordType >::reference
Creference_wrapper< T >	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< T >	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< Type >	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< T >	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< T >	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< T >	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< T >	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< T >
Cremove_reference< T & >
Cremove_reference< T && >
Cremove_volatile< Type >	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< Iter >	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
Crow_major_t
►Cscope_guard< FuncT, detail::scope_exit_impl >
Cscope_exit< FuncT >	The class template scope_exit is a general-purpose scope guard intended to call its exit function when a scope is exited
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
Csmall_ptr< Type, BaseAddress, StorageType >	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< T, Extent >	A non-owning view over a contiguous sequence of objects
Cstack< T, Container >	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< Key, Capacity, Compare >	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_storage_type
Cstatic_vector< Key, Capacity >
Cstatic_vector< T, Capacity >	Dynamically-resizable fixed-capacity vector
Cstream_buffer	Stream buffers are an RTOS task to RTOS task, and interrupt to task communication primitives
Cstrided_slice< OffsetType, ExtentType, StrideType >
Cstring_constant< CharT, Chars >
Cstrong_ordering
Csubmdspan_mapping_result< LayoutMapping >
Csuspend_always
Csuspend_never
Csystem_clock
Ctail< Ts >
Ctail< list< Head, Tail... > >
Ctime_point< Clock, Duration >	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
Ctimes< Count >	Runs the task loop Count times
Ctimespec
Ctm
Cto_chars_result	Primitive numerical output conversion
Cto_floating_point_result< Float >
Cto_integer_options
Cto_integer_result< Int >
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< Ts >
Ctuple_element< I, T >	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< T >
►Ctype
►Cis_nothrow_constructible< T, add_lvalue_reference_t< add_const_t< T > > >
Cis_nothrow_copy_constructible< T >	Same as copy, but uses etl::is_nothrow_constructible<T, T const&>
►Cis_nothrow_constructible< T >
Cis_nothrow_default_constructible< T >	If etl::is_nothrow_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false
►Cis_nothrow_constructible< T, add_rvalue_reference_t< T > >
Cis_nothrow_move_constructible< T >	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
Caligned_storage< Len, Align >::type
Caligned_union< Len, Types >::type
►Ctype
Cis_nothrow_swappable< T >	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
►Ctype
Cis_placeholder< T const >
Cis_placeholder< T const volatile >
Cis_placeholder< T volatile >
►Ctype
Cis_swappable< T >	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
►Ctype
Cvariant_size< T const >
Cvariant_size< T const volatile >
Cvariant_size< T volatile >
Ctype_identity< T >
►Cunderlying_type< T >
Cunderlying_type< T >	The underlying type of an enum
Cunexpect_t
Cunexpected< E >
Cuniform_int_distribution< IntType >
Cuniform_real_distribution< RealType >
Cuninitialized_array< T, Size >
Cuninitialized_array< T, Size >
Cuninitialized_union
Cunique_lock< Mutex >	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
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
Cunwrap_reference< T >
Cunwrap_reference< reference_wrapper< T > >
Cupper_triangle_t
Cvariadic_union< Ts >
Cvariadic_union< T, Ts... >
Cvariant< Ts >
Cvariant_alternative< I, T >	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< T >
Cvector< T, Allocator >
Cweak_ordering
Cweekday
Cweekday_indexed
Cweekday_last
Cxorshift< UInt, X, Y, Z >	Https://en.wikipedia.org/wiki/Xorshift
Cxoshiro128plus
Cxoshiro128plusplus
Cxoshiro128starstar
Cyear
Cyear_month
Cyear_month_day
Cyear_month_day_last
Cyear_month_weekday
Cyear_month_weekday_last