--- title: "type_traits" --- Reverse engineered types traits classes from C++11 plus several ETL extensions. This file is generated from `type_traits_generator.h`. See Generators Not all traits have been defined as some rely on compiler intrinsics that are not available on all compiler platforms. `integral_constant` `remove_reference` `add_reference` `remove_pointer` `add_pointer` `is_const` `remove_const` `add_const` `is_volatile` `remove_volatile` `add_volatile` `remove_cv` `add_cv` `add_volatile` `remove_cvref` `20.17.0` `is_integral` `is_signed` `is_unsigned` `is_floating_point` `is_same` `is_void` `is_arithmetic` `is_fundamental` `is_compound` `is_array` `is_pointer` `is_null_pointer` `is_scalar` `is_union` `is_empty` `is_polymorphic` `is_abstract` `is_final` `is_aggregate` `is_trivial` `is_standard_layout` `is_destructible` `is_nothrow_destructible` `has_virtual_destructor` `has_unique_object_representations` `is_bounded_array` `is_unbounded_array` `is_swappable` `is_swappable_with` `is_nothrow_swappable` `is_nothrow_swappable_with` `is_reference` `is_base_of` `make_signed` `make_unsigned` `enable_if` `conditional` `extent` `remove_extent` `remove_all_extents` `rank` `decay` `alignment_of` `conjunction` `20.14.0` `disjunction` `20.14.0` `negation` `is_lvalue_assignable` `void_t` `20.28.0` `declvar` `20.28.0` `common_type` `is_enum` `20.30.0` `underlying_type` `20.42.0`  Unless the ETL is set to use builtins, the user must specialise the template for their enumerations. The definitions will wrap those defined in C++11's `` if available. --- The following will be defined according to the C++ standard and user defined macros. `is_assignable` `is_constructible` `is_copy_constructible` `is_move_constructible` `is_trivially_constructible` `is_trivially_copy_constructible` `is_trivially_destructible` `is_trivially_copy_assignable` `is_trivially_copyable` ## Scenario 1 **Using C++11 or above and the STL.** If `ETL_CPP11_SUPPORTED and ETL_USING_STL == 1` and `!defined(ETL_USE_TYPE_TRAITS_BUILTINS)` and `!defined(ETL_USER_DEFINED_TYPE_TRAITS)` and `((!defined(ARDUINO) && ETL_NOT_USING_STLPORT)` or `defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))` The ETL's definitions wrap the STL definitions, except in the following case. if `ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED` is not defined then they will be defined as in the `ETL_USER_DEFINED_TYPE_TRAITS` option. ## Scenario 2 **Not using the STL but the compiler has type trait built-ins.** If the user has defined `ETL_USE_TYPE_TRAITS_BUILTINS` then the ETL will use the generally available compiler built-ins. This option is useful for when you are not using the STL, but are using a compatible compiler. ## Scenario 3 **Not using the STL and have the compiler has no type trait built-ins.** If the user has defined `ETL_USER_DEFINED_TYPE_TRAITS` then the ETL will define these type traits for arithmetic and pointer types only. For all other types the traits will be undefined, unless the user explicitly specialises them. ```cpp struct Copyable { Copyable() {} Copyable(const Copyable& other) {} Copyable& operator =(const Copyable& rhs) { return *this; } Copyable(Copyable&& other) = delete; Copyable& operator =(Copyable& rhs) = delete; }; using etl::is_assignable; using etl::is_constructible; using etl::is_copy_constructible; using etl::is_move_constructible; template <> struct etl::is_assignable : public etl::true_type { }; template <> struct etl::is_constructible : public etl::true_type { }; template <> struct etl::is_copy_constructible : public etl::true_type { }; template <> struct etl::is_move_constructible : public etl::false_type { }; ``` ## Scenario 4 **Not using the STL, the compiler has no type trait built-ins, and no user define specialisations are defined.** The ETL will define these type traits as `true` for arithmetic and pointer types only. For all other types the traits will have a value of `false`. ## is_one_of **ETL extension** **C++03** ```cpp template struct is_one_of ``` By default the ETL allows up the 16 types. This may be changed by running the type traits generator. **C++11 or above** ```cpp template struct is_one_of ``` ### Members `value` Set to `true` if the first template type is one of the subsequent types, otherwise `false`. If C++17 is supported then this definition available. ```cpp template constexpr bool is_one_of_v = etl::is_one_of::value; ``` **Example** ```cpp bool isOK; isOK = etl::is_one_of::value; // Sets 'isOK' to true. isOK = etl::is_one_of::value; // Sets 'isOK' to false. ``` ## are_all_same **ETL extension** C++11 or above ```cpp template struct are_all_same ``` ### Members `value` Set to `true` if all of the template types are the same, otherwise `false`. If C++17 is supported then this definition available. ```cpp template constexpr bool are_all_same_v = etl::is_one_of::value; ``` **Example** ```cpp bool isOK; isOK = etl::are_all_same::value; // Sets 'isOK' to true. isOK = etl::is_one_of::value; // Sets 'isOK' to false. ``` ## conditional_integral_constant **ETL extension** ### Members `value` Set to the constant determined by the condition. **Example** int value; value = etl::conditional_integral_constant::value; // Sets value to 1 value = etl::conditional_integral_constant::value; // Sets value to 2 ## types **ETL extension** Extracts the basic types from a template type. `type` The underlying type. --- `reference` A reference to the underlying type. --- `const_reference` A const reference to the underlying type. --- `pointer` A pointer to the underlying type. --- ```cpp const_pointer ``` A const pointer to the underlying type. --- **Example** ```cpp typedef const int* const MyType; etl::types::type int etl::types::reference int& etl::types::const_reference const int& etl::types::pointer int* etl::types::const_pointer const int* etl::types::const_pointer_const const int* const ``` ## unsigned_type **ETL extension** From: `20.29.0` ```cpp template struct unsigned_type ``` Defines one of five unsigned types that has the same size as `T`. Defines one of `unsigned char`, `unsigned short`, `unsigned int`, `unsigned long`, `unsigned long long`. --- ```cpp template using unsigned_type_t = typename unsigned_type::type; ``` C++11 ## signed_type **ETL extension** From: `20.29.0` ```cpp template struct signed_type ``` Defines one of five signed types that has the same size as `T`. Defines one of `char`, `short`, `int`, `long`, `long long`. --- ```cpp template using signed_type_t = typename signed_type::type; ``` C++11 --- ## has_duplicates **ETL extension** ```cpp template struct has_duplicates ``` From: `20.39.1` C++11 or above ### Members `value` Set to `true` if the typelist `TTypes` contains any duplicate types, otherwise `false`. --- If C++17 is supported then this definition is available ```cpp template constexpr bool has_duplicates_v = etl::has_duplicates::value; ``` ## has_duplicates_of **ETL extension** ```cpp template struct has_duplicates_of ``` From: `20.39.1` C++11 or above ### Members `value` Set to `true` if the typelist `TTypes` contains duplicates of types `T`, otherwise `false`. --- If C++17 is supported then this definition is available. ```cpp template constexpr bool has_duplicates_of_v = etl::has_duplicates_of::value; ``` ## count_of **ETL extension** ```cpp template struct count_of ``` From: `20.39.1` C++11 or above ### Members `value` The count of the occurrences of type `T` in the typelist `TTypes`. --- If C++17 is supported then this definition is available. ```cpp template constexpr bool count_of_v = etl::count_of::value; ``` ## conjunction From: `20.40.1` ```cpp template struct conjunction; ``` Forms the logical conjunction (AND) of `Types...` The result is found in the member `value`. ```cpp template inline constexpr bool conjunction_v; ``` Forms the logical conjunction (AND) of `Types...` C++17 ## disjunction From: `20.40.1` ```cpp template struct disjunction; ``` Forms the logical disjunction (OR) of `Types...` The result is found in the member `value`. ```cpp template inline constexpr bool disjunction_v; ``` Forms the logical disjunction (OR) of `Types...` C++17 ## exclusive_disjunction From: `20.40.1` ```cpp template struct exclusive_disjunction; ``` Forms the logical exclusive disjunction (XOR) of `Types...` The result is found in the member `value`. ```cpp template inline constexpr bool exclusive_disjunction_v; ``` Forms the logical exclusive disjunction (XOR) of `Types...` C++17 ## unwrap_reference, unwrap_ref_decay From: `20.40.1` ```cpp template struct unwrap_reference; ``` Unwraps any `etl::reference_wrapper`, changing `etl::reference_wrapper` to `U&`. If `T` is a specialisation of `etl::reference_wrapper`, unwraps it, otherwise `T` remains the same. ```cpp template using unwrap_reference_t; ``` C++11 --- ```cpp template struct unwrap_ref_decay; ``` Unwraps any `etl::reference_wrapper`, changing `etl::reference_wrapper` to `U&`. If decayed `T` is a specialisation of `etl::reference_wrapper`, unwraps it, otherwise `T` is decayed. ```cpp template using unwrap_ref_decay_t; ``` C++11 ## is_specialization From: `20.41.0` ```cpp template class Template> struct is_specialization ``` Checks if `T` is a specialization of template type `Template`. The result is found in the member `value`. C++11 ```cpp template class Template> inline constexpr bool is_specialization_v = etl::is_specialization::value; ``` C++17 ## is_object_pointer From: `20.49.0` ```cpp template struct is_object_pointer ``` Checks if `T` is a pointer to an object. Pointers to functions and member functions return `false`. The result is found in the member `value`. ```cpp template inline constexpr bool is_object_pointer_v = etl::is_object_pointer::value; ``` C++17 ## is_pod From: `20.49.0` ```cpp template struct is_pod ``` Checks if `T` is a POD (Plain Old Data) type. The result is found in the member `value`.  When using the STL, this is defined as `is_standard_layout && is_trivially_default_constructible && is_trivially_copyable`.  When not using the STL, this is conservatively defined as `is_fundamental || is_pointer`. ```cpp template inline constexpr bool is_pod_v = etl::is_pod::value; ``` C++17 ## is_standard_layout From: `20.49.0` ```cpp template struct is_standard_layout ``` Checks if `T` is a standard-layout type. The result is found in the member `value`. ```cpp template inline constexpr bool is_standard_layout_v = etl::is_standard_layout::value; ``` C++17 ## is_trivial From: `20.49.0` ```cpp template struct is_trivial ``` Checks if `T` is a trivial type; i.e. it is trivially copyable and has one or more default constructors, all of which are trivial. The result is found in the member `value`. ```cpp template inline constexpr bool is_trivial_v = etl::is_trivial::value; ``` C++17 **Note:** When not using the STL, this trait requires compiler support (the `__is_trivial` intrinsic). If that is not available then the trait is not defined, as there is no portable way of determining whether a type is trivial. ## is_bounded_array From: `20.49.0` ```cpp template struct is_bounded_array ``` Checks if `T` is an array type of known bound. `T[N]` returns `true`, `T[]` and all other types return `false`. The result is found in the member `value`. ```cpp template inline constexpr bool is_bounded_array_v = etl::is_bounded_array::value; ``` C++17 ## is_unbounded_array From: `20.49.0` ```cpp template struct is_unbounded_array ``` Checks if `T` is an array type of unknown bound. `T[]` returns `true`, `T[N]` and all other types return `false`. The result is found in the member `value`. ```cpp template inline constexpr bool is_unbounded_array_v = etl::is_unbounded_array::value; ``` C++17 ## is_destructible From: `20.49.0` ```cpp template struct is_destructible ``` Checks if `T` is a destructible type; that is, an object type whose destructor is not deleted and is accessible, a reference type, or an array of a destructible type. Incomplete types, `void`, function types and arrays of unknown bound are not destructible. The result is found in the member `value`.  When not using the STL, the trait is detected by checking whether `declval().~T()` is a valid expression.  Requires either compiler support or C++11. When neither is available, this trait is not defined. ```cpp template inline constexpr bool is_destructible_v = etl::is_destructible::value; ``` C++17 ## is_nothrow_destructible From: `20.49.0` ```cpp template struct is_nothrow_destructible ``` Checks if `T` is a destructible type whose destructor is known not to throw. Types that are not destructible are not nothrow destructible. The result is found in the member `value`.  When not using the STL, the trait is detected by checking `noexcept(declval().~T())` for destructible types.  Requires either compiler support or C++11. When neither is available, this trait is not defined. ```cpp template inline constexpr bool is_nothrow_destructible_v = etl::is_nothrow_destructible::value; ``` C++17 ## is_swappable From: `20.49.0` ```cpp template struct is_swappable ``` Checks if `T` is a referenceable type and lvalues of type `T` can be swapped by an unqualified call to `swap`. The result is found in the member `value`.  When using the STL and C++17, this is defined as `std::is_swappable`.  Otherwise the trait checks whether `swap(declval(), declval())` is a valid expression, where the `swap` considered is `etl::swap`, `std::swap` if it is available, and any `swap` found by argument dependent lookup.  Requires C++11. Without it there is no way of detecting the validity of an expression, so this trait is not defined.  Note that when using the STL with C++11 or C++14, the accuracy of this trait depends on `std::swap` being constrained by the standard library implementation. Standard libraries that only constrain `std::swap` from C++17 will cause this trait to report `true` for types that cannot actually be swapped. ```cpp template inline constexpr bool is_swappable_v = etl::is_swappable::value; ``` C++17 ## is_swappable_with From: `20.49.0` ```cpp template struct is_swappable_with ``` Checks if expressions of type `T` and `U` can be swapped by unqualified calls to `swap`, in both directions. The result is found in the member `value`.  When using the STL and C++17, this is defined as `std::is_swappable_with`.  Otherwise the trait checks whether both `swap(declval(), declval())` and `swap(declval(), declval())` are valid expressions, where the `swap` considered is `etl::swap`, `std::swap` if it is available, and any `swap` found by argument dependent lookup.  Note that, unlike `is_swappable`, no references are added to `T` and `U`, so the value categories of the arguments are those of `T` and `U`. `is_swappable_with::value` is `false`, whereas `is_swappable_with::value` is `true`.  Requires C++11. Without it there is no way of detecting the validity of an expression, so this trait is not defined.  Note that when using the STL with C++11 or C++14, the accuracy of this trait depends on `std::swap` being constrained by the standard library implementation. Standard libraries that only constrain `std::swap` from C++17 will cause this trait to report `true` for types that cannot actually be swapped. ```cpp template inline constexpr bool is_swappable_with_v = etl::is_swappable_with::value; ``` C++17 ## is_nothrow_swappable From: `20.49.0` ```cpp template struct is_nothrow_swappable ``` Checks if `T` is a referenceable type and lvalues of type `T` can be swapped by an unqualified call to `swap`, and that the swap cannot throw. The result is found in the member `value`.  When using the STL and C++17, this is defined as `std::is_nothrow_swappable`.  Otherwise the trait checks that `etl::is_swappable::value` is `true` and that `swap(declval(), declval())` is `noexcept`.  Requires C++11. Without it there is no way of detecting the validity of an expression, so this trait is not defined.  Note that when neither the STL nor the type traits builtins are available, `etl::is_nothrow_move_constructible` and `etl::is_nothrow_move_assignable` are conservatively `false` for class types, so `etl::swap` is not `noexcept` for them and this trait is conservatively `false` too. ```cpp template inline constexpr bool is_nothrow_swappable_v = etl::is_nothrow_swappable::value; ``` C++17 ## is_nothrow_swappable_with From: `20.49.0` ```cpp template struct is_nothrow_swappable_with ``` Checks if expressions of type `T` and `U` can be swapped by unqualified calls to `swap`, in both directions, and that neither swap can throw. The result is found in the member `value`.  When using the STL and C++17, this is defined as `std::is_nothrow_swappable_with`.  Otherwise the trait checks that `etl::is_swappable_with::value` is `true` and that both `swap(declval(), declval())` and `swap(declval(), declval())` are `noexcept`.  Note that, as for `is_swappable_with`, no references are added to `T` and `U`, so the value categories of the arguments are those of `T` and `U`. `is_nothrow_swappable_with::value` is `false`, whereas `is_nothrow_swappable_with::value` is `true`.  Requires C++11. Without it there is no way of detecting the validity of an expression, so this trait is not defined.  Note that when neither the STL nor the type traits builtins are available, `etl::is_nothrow_move_constructible` and `etl::is_nothrow_move_assignable` are conservatively `false` for class types, so `etl::swap` is not `noexcept` for them and this trait is conservatively `false` too. ```cpp template inline constexpr bool is_nothrow_swappable_with_v = etl::is_nothrow_swappable_with::value; ``` C++17 ## is_union From: `20.49.0` ```cpp template struct is_union ``` Checks if `T` is a union type. The result is found in the member `value`.  When the compiler does not provide the required intrinsic, this trait conservatively reports `false` for every type. ```cpp template inline constexpr bool is_union_v = etl::is_union::value; ``` C++17 ## is_empty From: `20.49.0` ```cpp template struct is_empty ``` Checks if `T` is an empty class type; that is, a non-union class type with no non-static data members other than zero-sized bit-fields, no virtual functions, no virtual base classes and no non-empty base classes. The result is found in the member `value`.  Requires compiler support. When the compiler does not provide the required intrinsic, this trait is not defined. ```cpp template inline constexpr bool is_empty_v = etl::is_empty::value; ``` C++17 ## is_polymorphic From: `20.49.0` ```cpp template struct is_polymorphic ``` Checks if `T` is a polymorphic class type; that is, a class that declares or inherits at least one virtual function. The result is found in the member `value`.  Requires compiler support. When the compiler does not provide the required intrinsic, this trait is not defined. ```cpp template inline constexpr bool is_polymorphic_v = etl::is_polymorphic::value; ``` C++17 ## is_abstract From: `20.49.0` ```cpp template struct is_abstract ``` Checks if `T` is an abstract class type; that is, a class that declares or inherits at least one pure virtual function. The result is found in the member `value`.  Requires compiler support. When the compiler does not provide the required intrinsic, this trait is not defined. ```cpp template inline constexpr bool is_abstract_v = etl::is_abstract::value; ``` C++17 ## is_final From: `20.49.0` ```cpp template struct is_final ``` Checks if `T` is a class or union type marked `final`, optionally cv-qualified. The result is found in the member `value`.  When using the STL, this requires C++14 or above. Otherwise it requires compiler support. When neither is available, this trait is not defined. ```cpp template inline constexpr bool is_final_v = etl::is_final::value; ``` C++17 ## is_aggregate From: `20.49.0` ```cpp template struct is_aggregate ``` Checks if `T` is an aggregate type, optionally cv-qualified. An aggregate is an array type or a class type that has no user-declared or inherited constructors, no private or protected non-static data members, no virtual functions and no virtual, private or protected base classes. The result is found in the member `value`.  When using the STL, this requires C++17 or above. Otherwise it requires compiler support. When neither is available, this trait is not defined. ```cpp template inline constexpr bool is_aggregate_v = etl::is_aggregate::value; ``` C++17 ## has_virtual_destructor From: `20.49.0` ```cpp template struct has_virtual_destructor ``` Checks if `T` is a class type with a virtual destructor, optionally cv-qualified. The result is found in the member `value`.  When not using the STL, this requires compiler support. When it is not available, this trait is not defined. ```cpp template inline constexpr bool has_virtual_destructor_v = etl::has_virtual_destructor::value; ``` C++17 ## has_unique_object_representations From: `20.49.0` ```cpp template struct has_unique_object_representations ``` Checks if `T` is trivially copyable and any two objects of type `T` with the same value have the same object representation; that is, the type has no padding bits and no two distinct object representations compare equal. Arrays and cv-qualifiers are ignored; the trait is applied to `etl::remove_all_extents::type>::type`. The result is found in the member `value`.  When using the STL, this requires C++17 or above. Otherwise it requires compiler support. When neither is available, this trait is not defined. ```cpp template inline constexpr bool has_unique_object_representations_v = etl::has_unique_object_representations::value; ``` C++17 ## is_null_pointer From: `20.49.0` ```cpp template struct is_null_pointer ``` Checks if `T` is `etl::nullptr_t`, optionally cv-qualified. The result is found in the member `value`. ```cpp template inline constexpr bool is_null_pointer_v = etl::is_null_pointer::value; ``` C++17 ## is_scalar From: `20.49.0` ```cpp template struct is_scalar ``` Checks if `T` is a scalar type; that is, an arithmetic, enumeration, pointer, pointer to member or `etl::nullptr_t` type, optionally cv-qualified. The result is found in the member `value`. ```cpp template inline constexpr bool is_scalar_v = etl::is_scalar::value; ``` C++17