Compile-time type information. More...

Classes
struct	add_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. More...

struct	add_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. More...

struct	add_lvalue_reference< T >
	Creates a lvalue reference type of T. More...

struct	add_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. More...

struct	add_rvalue_reference< T >
	Creates a rvalue reference type of T. More...

struct	add_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. More...

struct	aligned_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. More...

struct	aligned_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. More...

struct	alignment_of< T >
	alignment_of More...

struct	basic_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. More...

struct	conditional< 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. More...

struct	conjunction< B >
	Forms the logical conjunction of the type traits B..., effectively performing a logical AND on the sequence of traits. More...

struct	copy_cv< From, T0 >

struct	decay< 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. More...

struct	disjunction< B >
	Forms the logical disjunction of the type traits B..., effectively performing a logical OR on the sequence of traits. More...

struct	enable_if< bool, Type >
	Define a member typedef only if a boolean constant is true. More...

struct	extent< 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. More...

struct	has_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. More...

struct	has_virtual_destructor< T >
	https://en.cppreference.com/w/cpp/types/has_virtual_destructor More...

struct	integral_constant< Type, Val >

struct	invoke_result< F, ArgTypes >
	Deduces the return type of an INVOKE expression at compile time. More...

struct	is_abstract< T >

struct	is_aggregate< T >

struct	is_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. More...

struct	is_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. More...

struct	is_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. More...

struct	is_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. More...

struct	is_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. More...

struct	is_builtin_integer< T >

struct	is_builtin_signed_integer< T >

struct	is_builtin_unsigned_integer< T >
	True if T is `unsigned char` or `unsigned short` or `unsigned int` or `unsigned long` or `unsigned long long` More...

struct	is_class< T >

struct	is_nothrow_swappable_with< T, U >

struct	is_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. More...

struct	is_same< T, T >

struct	make_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. More...

struct	remove_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. More...

struct	remove_reference< T >

struct	remove_reference< T & >

struct	remove_reference< T && >

struct	remove_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. More...

struct	smallest_size< N >
	Smallest unsigned integer type that can represent values in the range [0, N]. More...

struct	type_identity< T >

struct	underlying_type< T >
	The underlying type of an enum. More...

Typedefs
template<typename T >
using	add_const_t = typename add_const< T >::type

template<typename T >
using	add_cv_t = typename add_cv< T >::type

template<typename T >
using	add_lvalue_reference_t = typename add_lvalue_reference< T >::type

template<typename T >
using	add_pointer_t = typename add_pointer< T >::type

template<typename T >
using	add_rvalue_reference_t = typename add_rvalue_reference< T >::type

template<typename T >
using	add_volatile_t = typename add_volatile< T >::type

template<size_t Len, size_t Align = alignof(detail::aligned_storage_impl<Len>)>
using	aligned_storage_t = typename aligned_storage< Len, Align >::type

template<size_t Len, typename... Types>
using	aligned_union_t = typename aligned_union< Len, Types... >::type

template<bool B>
using	bool_constant = integral_constant< bool, B >

template<bool B, typename T , typename F >
using	conditional_t = typename conditional< B, T, F >::type

template<typename From , typename To >
using	copy_cv_t = typename copy_cv< From, To >::type

template<typename T >
using	decay_t = typename etl::decay< T >::type

template<bool B, typename T = void>
using	enable_if_t = typename enable_if< B, T >::type

using	false_type = bool_constant< false >

template<size_t I>
using	index_constant = integral_constant< size_t, I >

template<typename F , typename... ArgTypes>
using	invoke_result_t = typename invoke_result< F, ArgTypes... >::type

template<typename T >
using	remove_reference_t = typename remove_reference< T >::type

template<typename T >
using	remove_volatile_t = typename remove_volatile< T >::type

template<unsigned long long N>
using	smallest_size_t = typename smallest_size< N >::type

using	true_type = bool_constant< true >

template<typename T >
using	type_identity_t = typename type_identity< T >::type

template<typename T >
using	underlying_type_t = typename underlying_type< T >::type

template<typename... >
using	void_t = void

Functions
template<typename T >
auto	declval () noexcept -> add_rvalue_reference_t< T >

template<typename Rhs , Rhs R, typename Lhs , Lhs L>
constexpr auto	operator!= (integral_constant< Rhs, R >, integral_constant< Lhs, L >) -> integral_constant< bool, L !=R >

template<typename Rhs , Rhs R, typename Lhs , Lhs L>
constexpr auto	operator+ (integral_constant< Rhs, R >, integral_constant< Lhs, L >) -> integral_constant< decltype(L+R), L+R >

template<typename Rhs , Rhs R, typename Lhs , Lhs L>
constexpr auto	operator== (integral_constant< Rhs, R >, integral_constant< Lhs, L >) -> integral_constant< bool, L==R >

Variables
template<typename T >
constexpr size_t	alignment_of_v = alignment_of<T>::value

template<typename... T>
constexpr bool	always_false = false

template<typename... B>
constexpr bool	conjunction_v = conjunction<B...>::value

template<typename... B>
constexpr bool	disjunction_v = disjunction<B...>::value

template<typename T , unsigned N = 0>
constexpr auto	extent_v = static_cast<size_t>(extent<T, N>::value)

template<typename T >
constexpr bool	has_unique_object_representations_v = has_unique_object_representations<T>::value

template<typename T >
constexpr auto	has_virtual_destructor_v = __has_virtual_destructor(T)

template<size_t I>
constexpr auto	index_v = index_constant<I>{}

template<typename T >
constexpr bool	is_abstract_v = __is_abstract(T)

template<typename T >
constexpr bool	is_aggregate_v = __is_aggregate(remove_cv_t<T>)

template<typename T >
constexpr bool	is_arithmetic_v = is_integral_v<T> or is_floating_point_v<T>

template<typename T >
constexpr bool	is_array_v = is_array<T>::value

template<typename T , typename U >
constexpr bool	is_assignable_v = __is_assignable(T, U)

template<typename Base , typename Derived >
constexpr bool	is_base_of_v = is_base_of<Base, Derived>::value

template<typename T >
constexpr bool	is_bounded_array_v = is_bounded_array<T>::value

template<typename T >
constexpr auto	is_builtin_integer_v = is_builtin_integer<T>::value

template<typename T >
constexpr auto	is_builtin_signed_integer_v = is_builtin_signed_integer<T>::value

template<typename T >
constexpr auto	is_builtin_unsigned_integer_v = is_builtin_unsigned_integer<T>::value

template<typename T >
constexpr bool	is_class_v = __is_class(T)

template<typename T , typename U >
constexpr bool	is_nothrow_swappable_with_v = is_nothrow_swappable_with<T, U>::value

template<typename T , typename U >
constexpr bool	is_same_v = is_same<T, U>::value