32#error THIS HEADER IS A GENERATOR. DO NOT INCLUDE.
53#ifndef ETL_TYPE_TRAITS_INCLUDED
54#define ETL_TYPE_TRAITS_INCLUDED
58#include "static_assert.h"
68#if ETL_USING_STL && ETL_USING_CPP11
69 #include <type_traits>
75 template <
typename...>
79#if ETL_NOT_USING_STL || ETL_CPP11_NOT_SUPPORTED
87 template <
typename T, T VALUE>
88 struct integral_constant
90 static const T value = VALUE;
93 typedef integral_constant<T, VALUE> type;
95 operator value_type()
const
102 typedef integral_constant<bool, false>
false_type;
103 typedef integral_constant<bool, true> true_type;
105 template <
typename T, T VALUE>
106 const T integral_constant<T, VALUE>::value;
109 template <
typename T, T VALUE>
115 using bool_constant = integral_constant<bool, B>;
123 inline constexpr bool bool_constant_v = bool_constant<B>::value;
128 template <
typename T>
134 template <
typename T>
135 inline constexpr bool negation_v = negation<T>::value;
140 template <
typename T>
struct remove_reference {
typedef T type; };
147 template <
typename T>
148 using remove_reference_t =
typename remove_reference<T>::type;
153 template <
typename T>
struct remove_pointer {
typedef T type; };
164 template <
typename T>
173 template <
typename T>
174 using add_pointer_t =
typename add_pointer<T>::type;
179 template <
typename T>
struct is_const :
false_type {};
184 template <
typename T>
190 template <
typename T>
struct remove_const {
typedef T type; };
194 template <
typename T>
200 template <
typename T>
struct add_const {
typedef const T type; };
204 template <
typename T>
215 template <
typename T>
225 template <
typename T>
231 template <
typename T>
struct add_volatile {
typedef volatile T type; };
235 template <
typename T>
247 template <
typename T>
248 using remove_cv_t =
typename remove_cv<T>::type;
253 template <
typename T>
struct add_cv
255 typedef typename add_volatile<typename add_const<T>::type>::type type;
259 template <
typename T>
260 using add_cv_t =
typename add_cv<T>::type;
265 template <
typename T>
struct remove_cvref
267 typedef typename remove_cv<typename remove_reference<T>::type>::type type;
271 template <
typename T>
272 using remove_cvref_t =
typename remove_cvref<T>::type;
277 template <
typename T>
struct is_integral :
false_type {};
296 template <
typename T>
304 template <> struct is_signed<wchar_t> : public etl::bool_constant<wchar_t(-1) < wchar_t(0)> {};
305 template <> struct is_signed<signed char> : true_type {};
306 template <> struct is_signed<short> : true_type {};
307 template <> struct is_signed<int> : true_type {};
308 template <> struct is_signed<long> : true_type {};
309 template <> struct is_signed<long long> : true_type {};
310 template <> struct is_signed<float> : true_type {};
311 template <> struct is_signed<double> : true_type {};
312 template <> struct is_signed<long double> : true_type {};
313 template <typename T> struct is_signed<const T> : is_signed<T> {};
314 template <typename T> struct is_signed<volatile T> : is_signed<T> {};
315 template <typename T> struct is_signed<const volatile T> : is_signed<T> {};
318 template <typename T>
319 inline constexpr bool is_signed_v = is_signed<T>::value;
324 template <typename T> struct is_unsigned : false_type {};
325 template <> struct is_unsigned<bool> : true_type {};
326 template <> struct is_unsigned<char> : etl::bool_constant<(char(255) > 0)> {};
327 template <> struct is_unsigned<unsigned char> : true_type {};
328 template <> struct is_unsigned<wchar_t> : public etl::bool_constant<(wchar_t(-1) > wchar_t(0))> {};
330 template <>
struct is_unsigned<unsigned int> : true_type {};
331 template <>
struct is_unsigned<unsigned long> : true_type {};
332 template <>
struct is_unsigned<unsigned long long> : true_type {};
333 template <
typename T>
struct is_unsigned<const T> : is_unsigned<T> {};
334 template <
typename T>
struct is_unsigned<volatile T> : is_unsigned<T> {};
335 template <
typename T>
struct is_unsigned<const volatile T> : is_unsigned<T> {};
338 template <
typename T>
339 inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
344 template <
typename T>
struct is_floating_point :
false_type {};
345 template <>
struct is_floating_point<float> : true_type {};
346 template <>
struct is_floating_point<double> : true_type {};
347 template <>
struct is_floating_point<long double> : true_type {};
348 template <
typename T>
struct is_floating_point<const T> : is_floating_point<T> {};
349 template <
typename T>
struct is_floating_point<volatile T> : is_floating_point<T> {};
350 template <
typename T>
struct is_floating_point<const volatile T> : is_floating_point<T> {};
353 template <
typename T>
354 inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
359 template <
typename T1,
typename T2>
struct is_same :
public false_type {};
360 template <
typename T>
struct is_same<T, T> :
public true_type {};
363 template <
typename T1,
typename T2>
364 inline constexpr bool is_same_v = is_same<T1, T2>::value;
369 template<
typename T>
struct is_void :
false_type {};
370 template<>
struct is_void<void> : true_type {};
373 template <
typename T>
374 inline constexpr bool is_void_v = is_void<T>::value;
379 template<
typename T>
struct is_arithmetic :
etl::bool_constant<is_integral<T>::value || is_floating_point<T>::value> {};
382 template <
typename T>
383 inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
388 template <
typename T>
struct is_fundamental :
etl::bool_constant<is_arithmetic<T>::value || is_void<T>::value> {};
391 template <
typename T>
392 inline constexpr bool is_fundamental_v = is_fundamental<T>::value;
397 template <
typename T>
struct is_compound :
etl::bool_constant<!is_fundamental<T>::value> {};
400 template <
typename T>
401 inline constexpr bool is_compound_v = is_compound<T>::value;
406 template <
typename T>
struct is_array :
false_type {};
407 template <
typename T>
struct is_array<T[]> : true_type {};
408 template <
typename T,
size_t MAXN>
struct is_array<T[MAXN]> : true_type {};
411 template <
typename T>
412 inline constexpr bool is_array_v = is_array<T>::value;
417 template<
typename T>
struct is_pointer_helper :
false_type {};
418 template<
typename T>
struct is_pointer_helper<T*> : true_type {};
419 template<
typename T>
struct is_pointer : is_pointer_helper<typename remove_cv<T>::type> {};
422 template <
typename T>
423 inline constexpr bool is_pointer_v = is_pointer<T>::value;
428 template<
typename T>
struct is_lvalue_reference_helper :
false_type {};
429 template<
typename T>
struct is_lvalue_reference_helper<T&> : true_type {};
430 template<
typename T>
struct is_lvalue_reference : is_lvalue_reference_helper<typename remove_cv<T>::type> {};
433 template <
typename T>
440 template<
typename T>
struct is_rvalue_reference_helper :
false_type {};
441 template<
typename T>
struct is_rvalue_reference_helper<T&&> : true_type {};
442 template<
typename T>
struct is_rvalue_reference : is_rvalue_reference_helper<typename remove_cv<T>::type> {};
445 template <
typename T>
453 template<
typename T>
struct is_reference : integral_constant<bool,
454 is_lvalue_reference<T>::value
456 || is_rvalue_reference<T>::value
461 template <
typename T>
462 inline constexpr bool is_reference_v = is_reference<T>::value;
468 template <
typename T>
struct is_pod :
etl::bool_constant<etl::is_fundamental<T>::value || etl::is_pointer<T>::value> {};
471 template <
typename T>
477 template <
bool B,
typename T,
typename F>
struct conditional {
typedef T type; };
478 template <
typename T,
typename F>
struct conditional<false, T, F> {
typedef F type; };
481 template <
bool B,
typename T,
typename F>
482 using conditional_t =
typename conditional<B, T, F>::type;
487 template <
typename T>
struct make_signed {
typedef T type; };
488 template <>
struct make_signed<char> {
typedef signed char type; };
489 template <>
struct make_signed<unsigned char> {
typedef signed char type; };
491 template <>
struct make_signed<wchar_t>
497 void>::type>::type type;
500 template <>
struct make_signed<unsigned short> {
typedef short type; };
501 template <>
struct make_signed<unsigned int> {
typedef int type; };
502 template <>
struct make_signed<unsigned long> {
typedef long type; };
503 template <>
struct make_signed<unsigned long long> {
typedef long long type; };
504 template <
typename T>
struct make_signed<const T> : add_const<typename make_signed<T>::type> {};
505 template <
typename T>
struct make_signed<volatile T> : add_volatile<typename make_signed<T>::type> {};
506 template <
typename T>
struct make_signed<const volatile T> : add_const<typename add_volatile<typename make_signed<T>::type>::type> {};
509 template <
typename T>
510 using make_signed_t =
typename make_signed<T>::type;
515 template <
typename T>
struct make_unsigned {
typedef T type; };
516 template <>
struct make_unsigned<char> {
typedef unsigned char type; };
517 template <>
struct make_unsigned<signed char> {
typedef unsigned char type; };
518 template <>
struct make_unsigned<short> {
typedef unsigned short type; };
520 template <>
struct make_unsigned<wchar_t>
526 void>::type>::type type;
529 template <>
struct make_unsigned<int> {
typedef unsigned int type; };
530 template <>
struct make_unsigned<long> {
typedef unsigned long type; };
531 template <>
struct make_unsigned<long long> {
typedef unsigned long long type; };
532 template <
typename T>
struct make_unsigned<const T> : add_const<typename make_unsigned<T>::type> {};
533 template <
typename T>
struct make_unsigned<volatile T> : add_volatile<typename make_unsigned<T>::type> {};
534 template <
typename T>
struct make_unsigned<const volatile T> : add_const<typename add_volatile<typename make_unsigned<T>::type>::type> {};
537 template <
typename T>
538 using make_unsigned_t =
typename make_unsigned<T>::type;
543 template <
bool B,
typename T =
void>
struct enable_if {};
544 template <
typename T>
struct enable_if<true, T> {
typedef T type; };
547 template <
bool B,
typename T =
void>
548 using enable_if_t =
typename enable_if<B, T>::type;
553 template <
typename T,
unsigned MAXN = 0U>
554 struct extent : integral_constant<size_t, 0U> {};
556 template <
typename T>
557 struct extent<T[], 0> : integral_constant<size_t, 0U> {};
559 template <
typename T,
unsigned MAXN>
560 struct extent<T[], MAXN> : integral_constant<size_t, extent<T, MAXN - 1>::value> {};
562 template <
typename T,
unsigned MAXN>
563 struct extent<T[MAXN], 0> : integral_constant<size_t, MAXN> {};
565 template <
typename T,
unsigned I,
unsigned MAXN>
566 struct extent<T[I], MAXN> : integral_constant<size_t, extent<T, MAXN - 1>::value> {};
569 template <
typename T,
unsigned N = 0U>
570 inline constexpr size_t extent_v = extent<T, N>::value;
575 template <
typename T>
struct remove_extent {
typedef T type; };
576 template <
typename T>
struct remove_extent<T[]> {
typedef T type; };
577 template <
typename T,
size_t MAXN>
struct remove_extent<T[MAXN]> {
typedef T type; };
580 template <
typename T>
581 using remove_extent_t =
typename remove_extent<T>::type;
586 template <
typename T>
struct remove_all_extents {
typedef T type; };
587 template <
typename T>
struct remove_all_extents<T[]> {
typedef typename remove_all_extents<T>::type type; };
588 template <
typename T,
size_t MAXN>
struct remove_all_extents<T[MAXN]> {
typedef typename remove_all_extents<T>::type type; };
591 template <
typename T>
592 using remove_all_extents_t =
typename remove_all_extents<T>::type;
597 template <
typename T>
struct rank : integral_constant<size_t, 0> {};
598 template <
typename T>
struct rank<T[]> :
public integral_constant<size_t, rank<T>::value + 1> {};
599 template <
typename T,
size_t MAXN>
struct rank<T[MAXN]> :
public integral_constant<size_t, rank<T>::value + 1> {};
602 template <
typename T>
603 inline constexpr size_t rank_v = rank<T>::value;
608 template <
typename T>
618 template <
typename T>
619 using decay_t =
typename decay<T>::type;
624 template<
typename TBase,
630 static TBase* check(TBase*) {
return (TBase*)0; }
632 static char check(...) {
return 0; }
636 static const bool value = (
sizeof(check((TDerived*)0)) ==
sizeof(TBase*));
640 template<
typename TBase,
typename TDerived>
641 struct is_base_of<TBase, TDerived, true>
643 static const bool value =
false;
647 template <
typename T1,
typename T2>
648 inline constexpr bool is_base_of_v = is_base_of<T1, T2>::value;
653 namespace private_type_traits
655 template <
typename T>
char test(
int T::*);
657 struct dummy {
char c[2]; };
658 template <
typename T> dummy test(...);
661 template <
typename T>
665 template <
typename T>
666 inline constexpr bool is_class_v = is_class<T>::value;
671 template <
typename T>
struct add_lvalue_reference {
typedef T& type; };
672 template <
typename T>
struct add_lvalue_reference<T&> {
typedef T& type; };
673 template <>
struct add_lvalue_reference<void> {
typedef void type; };
674 template <>
struct add_lvalue_reference<const void> {
typedef const void type; };
675 template <>
struct add_lvalue_reference<volatile void> {
typedef volatile void type; };
676 template <>
struct add_lvalue_reference<const volatile void> {
typedef const volatile void type; };
679 template <
typename T>
686 template <
typename T>
struct add_rvalue_reference {
using type = T && ; };
687 template <
typename T>
struct add_rvalue_reference<T&> {
using type = T & ; };
688 template <>
struct add_rvalue_reference<void> {
using type = void; };
689 template <>
struct add_rvalue_reference<const void> {
using type =
const void; };
690 template <>
struct add_rvalue_reference<volatile void> {
using type =
volatile void; };
691 template <>
struct add_rvalue_reference<const volatile void> {
using type =
const volatile void; };
695 template <
typename T>
702 template <
typename T>
712 namespace private_type_traits
715 template <
typename T,
typename =
int>
722 template <
typename T>
723 struct is_convertible_to_int<T, decltype(static_cast<int>(declval<T>()))>
729 template <
typename T>
731 : integral_constant<bool, private_type_traits::is_convertible_to_int<T>::value &&
732 !is_class<T>::value &&
733 !is_arithmetic<T>::value &&
734 !is_reference<T>::value>
739 template <
typename T>
748 namespace private_type_traits
753 template <
typename T>
759 template <
typename TFrom,
typename TTo>
762 template <
typename,
typename>
766#if defined(ETL_COMPILER_ARM5)
767 template <
typename TFrom,
typename TTo>
770 template <
typename TFrom,
typename TTo>
771 struct is_convertible :
etl::bool_constant<(decltype(private_type_traits::returnable<TTo>(0))::value &&
772 decltype(private_type_traits::nonvoid_convertible<TFrom, TTo>(0))::value) ||
773 (etl::is_void<TFrom>::value && etl::is_void<TTo>::value)> {};
778 template <
typename TFrom,
typename TTo >
785#if ETL_USING_CPP11 && !defined(ETL_COMPILER_ARM5)
786 template <
typename T>
struct alignment_of : integral_constant<size_t, alignof(T)> { };
787#elif defined(ETL_COMPILER_MICROSOFT)
788 template <
typename T>
struct alignment_of : integral_constant<size_t, size_t(__alignof(T))> {};
789#elif defined(ETL_COMPILER_IAR) || defined(ETL_COMPILER_TI)
790 template <
typename T>
struct alignment_of : integral_constant<size_t, size_t(__ALIGNOF__(T))> {};
792 template <
typename T>
struct alignment_of : integral_constant<size_t, size_t(__alignof__(T))> {};
797 template <>
struct alignment_of<void> : integral_constant <size_t, 0> {};
798 template <>
struct alignment_of<const void> : integral_constant <size_t, 0> {};
801 template <
typename T>
814 template <
typename T, T VALUE>
815 struct integral_constant : std::integral_constant<T, VALUE> {};
819typedef integral_constant<bool, false>
false_type;
820typedef integral_constant<bool, true> true_type;
823 template <
typename T, T VALUE>
824 inline constexpr T integral_constant_v = std::integral_constant<T, VALUE>::value;
829 using bool_constant = std::bool_constant<B>;
832 struct bool_constant : std::integral_constant<bool, B> { };
837 inline constexpr bool bool_constant_v = bool_constant<B>::value;
844 template <
typename T>
845 using negation = std::negation<T>;
847 template <
typename T>
854 template <
typename T>
855 inline constexpr bool negation_v = std::negation_v<T>;
861 template <
typename T>
struct remove_reference : std::remove_reference<T> {};
864 template <
typename T>
865 using remove_reference_t =
typename std::remove_reference<T>::type;
871 template <
typename T>
struct remove_pointer : std::remove_pointer<T> {};
874 template <
typename T>
875 using remove_pointer_t =
typename std::remove_pointer<T>::type;
881 template <
typename T>
struct add_pointer : std::add_pointer<T> {};
884 template <
typename T>
885 using add_pointer_t =
typename std::add_pointer<T>::type;
891 template <
typename T>
struct is_const : std::is_const<T> {};
894 template <
typename T>
895 inline constexpr bool is_const_v = std::is_const_v<T>;
901 template <
typename T>
struct remove_const : std::remove_const<T> {};
904 template <
typename T>
905 using remove_const_t =
typename std::remove_const<T>::type;
911 template <
typename T>
struct add_const : std::add_const<T> {};
914 template <
typename T>
915 using add_const_t =
typename std::add_const<T>::type;
921 template <
typename T>
struct is_volatile : std::is_volatile<T> {};
924 template <
typename T>
925 inline constexpr bool is_volatile_v = std::is_volatile_v<T>;
931 template <
typename T>
struct remove_volatile : std::remove_volatile<T> {};
934 template <
typename T>
935 using remove_volatile_t =
typename std::remove_volatile<T>::type;
941 template <
typename T>
struct add_volatile : std::add_volatile<T> {};
944 template <
typename T>
945 using add_volatile_t =
typename std::add_volatile<T>::type;
951 template <
typename T>
struct remove_cv : std::remove_cv<T> {};
954 template <
typename T>
955 using remove_cv_t =
typename std::remove_cv<T>::type;
961 template <
typename T>
struct add_cv : std::add_cv<T> {};
964 template <
typename T>
965 using add_cv_t =
typename std::add_cv<T>::type;
971 template <
typename T>
struct remove_cvref
973 typedef typename std::remove_cv<typename std::remove_reference<T>::type>::type type;
977 template <
typename T>
978 using remove_cvref_t =
typename etl::remove_cvref<T>::type;
984 template <
typename T>
struct is_integral : std::is_integral<T> {};
987 template <
typename T>
988 inline constexpr bool is_integral_v = std::is_integral_v<T>;
994 template <
typename T>
struct is_signed : std::is_signed<T> {};
997 template <
typename T>
998 inline constexpr bool is_signed_v = std::is_signed_v<T>;
1004 template <
typename T>
struct is_unsigned : std::is_unsigned<T> {};
1007 template <
typename T>
1008 inline constexpr bool is_unsigned_v = std::is_unsigned_v<T>;
1014 template <
typename T>
struct is_floating_point : std::is_floating_point<T> {};
1017 template <
typename T>
1018 inline constexpr bool is_floating_point_v = std::is_floating_point_v<T>;
1024 template <
typename T1,
typename T2>
struct is_same : std::is_same<T1, T2> {};
1027 template <
typename T1,
typename T2>
1028 inline constexpr bool is_same_v = std::is_same_v<T1, T2>;
1034 template<
typename T>
struct is_void : std::is_void<T> {};
1037 template <
typename T>
1038 inline constexpr bool is_void_v = std::is_void_v<T>;
1044 template<
typename T>
struct is_arithmetic : std::is_arithmetic<T> {};
1047 template <
typename T>
1048 inline constexpr bool is_arithmetic_v = std::is_arithmetic_v<T>;
1054 template <
typename T>
struct is_fundamental : std::is_fundamental<T> {};
1057 template <
typename T>
1058 inline constexpr bool is_fundamental_v = std::is_fundamental_v<T>;
1064 template <
typename T>
struct is_compound : std::is_compound<T> {};
1067 template <
typename T>
1068 inline constexpr bool is_compound_v = std::is_compound_v<T>;
1074 template <
typename T>
struct is_array : std::is_array<T> {};
1077 template <
typename T>
1078 inline constexpr bool is_array_v = std::is_array_v<T>;
1084 template<
typename T>
struct is_pointer : std::is_pointer<T> {};
1087 template <
typename T>
1088 inline constexpr bool is_pointer_v = std::is_pointer_v<T>;
1094 template<
typename T>
struct is_reference : std::is_reference<T> {};
1097 template <
typename T>
1098 inline constexpr bool is_reference_v = std::is_reference_v<T>;
1104 template<
typename T>
struct is_lvalue_reference : std::is_lvalue_reference<T> {};
1107 template <
typename T>
1108 inline constexpr bool is_lvalue_reference_v = std::is_lvalue_reference_v<T>;
1115 template<
typename T>
struct is_rvalue_reference : std::is_rvalue_reference<T> {};
1118 template <
typename T>
1119 inline constexpr bool is_rvalue_reference_v = std::is_rvalue_reference_v<T>;
1126 template <
typename T>
1127 struct is_pod : std::integral_constant<bool, std::is_standard_layout<T>::value && std::is_trivial<T>::value> {};
1130 template <
typename T>
1131 inline constexpr bool is_pod_v = std::is_standard_layout_v<T> && std::is_trivial_v<T>;
1134#if defined(ETL_COMPILER_GCC)
1135 #if ETL_COMPILER_VERSION >= 5
1136 #define ETL_GCC_V5_TYPE_TRAITS_SUPPORTED
1143 template <
bool B,
typename T,
typename F>
struct conditional {
typedef T type; };
1144 template <
typename T,
typename F>
struct conditional<false, T, F> {
typedef F type; };
1147 template <
bool B,
typename T,
typename F>
1148 using conditional_t =
typename conditional<B, T, F>::type;
1154 template <
typename T>
struct make_signed : std::make_signed<T> {};
1157 template <
typename T>
1158 using make_signed_t =
typename std::make_signed<T>::type;
1164 template <
typename T>
struct make_unsigned : std::make_unsigned<T> {};
1167 template <
typename T>
1168 using make_unsigned_t =
typename std::make_unsigned<T>::type;
1174 template <
bool B,
typename T =
void>
struct enable_if : std::enable_if<B, T> {};
1177 template <
bool B,
typename T =
void>
1178 using enable_if_t =
typename std::enable_if<B, T>::type;
1184 template <
typename T,
unsigned MAXN = 0U>
1185 struct extent : std::extent<T, MAXN> {};
1188 template <
typename T,
unsigned MAXN = 0U>
1189 inline constexpr size_t extent_v = std::extent_v<T, MAXN>;
1195 template <
typename T>
struct remove_extent : std::remove_extent<T> { };
1198 template <
typename T>
1199 using remove_extent_t =
typename std::remove_extent<T>::type;
1205 template <
typename T>
struct remove_all_extents : std::remove_all_extents<T> { };
1208 template <
typename T>
1209 using remove_all_extents_t =
typename std::remove_all_extents<T>::type;
1215 template <
typename T>
struct rank : std::rank<T> {};
1218 template <
typename T>
1219 inline constexpr size_t rank_v = std::rank_v<T>;
1225 template <
typename T>
struct decay : std::decay<T> {};
1228 template <
typename T>
1229 using decay_t =
typename std::decay<T>::type;
1235 template<
typename TBase,
typename TDerived>
struct is_base_of : std::is_base_of<TBase, TDerived> {};
1238 template <
typename TBase,
typename TDerived>
1239 inline constexpr bool is_base_of_v = std::is_base_of_v<TBase, TDerived>;
1244 template <
typename T>
struct is_class : std::is_class<T>{};
1247 template <
typename T>
1248 inline constexpr bool is_class_v = is_class<T>::value;
1253 template <
typename T>
struct add_lvalue_reference : std::add_lvalue_reference<T> {};
1256 template <
typename T>
1257 using add_lvalue_reference_t =
typename std::add_lvalue_reference<T>::type;
1263 template <
typename T>
struct add_rvalue_reference : std::add_rvalue_reference<T> {};
1267 template <
typename T>
1268 using add_rvalue_reference_t =
typename std::add_rvalue_reference<T>::type;
1274 template <
typename T>
1275 typename std::add_rvalue_reference<T>::type declval() ETL_NOEXCEPT;
1282 template <
typename T>
1283 struct is_enum : std::is_enum<T>
1288 template <
typename T>
1298 template <
typename TFrom,
typename TTo>
1299 struct is_convertible : std::is_convertible<TFrom, TTo> {};
1303 template <
typename TFrom,
typename TTo>
1304 inline constexpr bool is_convertible_v = std::is_convertible_v<TFrom, TTo>;
1310 template <
typename T>
struct alignment_of : std::alignment_of<T> {};
1311 template <>
struct alignment_of<void> : std::integral_constant<size_t, 0> {};
1312 template <>
struct alignment_of<const void> : std::integral_constant <size_t, 0> {};
1315 template <
typename T>
1316 inline constexpr size_t alignment_of_v = std::alignment_of_v<T>;
1328 template <
bool B,
typename T, T TRUE_VALUE, T FALSE_VALUE>
1329 struct conditional_integral_constant;
1331 template <
typename T, T TRUE_VALUE, T FALSE_VALUE>
1332 struct conditional_integral_constant<true, T, TRUE_VALUE, FALSE_VALUE>
1335 static const T value = TRUE_VALUE;
1338 template <
typename T, T TRUE_VALUE, T FALSE_VALUE>
1339 struct conditional_integral_constant<false, T, TRUE_VALUE, FALSE_VALUE>
1342 static const T value = FALSE_VALUE;
1349 template <
typename T,
typename T1,
typename... TRest>
1356 template <
typename T,
typename T1>
1357 struct is_one_of<T, T1>
1365 template <
typename T,
1366 typename T1,
typename T2 = void,
typename T3 = void,
typename T4 = void,
1367 typename T5 = void,
typename T6 = void,
typename T7 = void,
typename T8 = void,
1368 typename T9 = void,
typename T10 = void,
typename T11 = void,
typename T12 = void,
1369 typename T13 = void,
typename T14 = void,
typename T15 = void,
typename T16 =
void>
1372 static const bool value =
1393 template <
typename T,
typename... TRest>
1394 inline constexpr bool is_one_of_v =
etl::is_one_of<T, TRest...>::value;
1401 template <
typename T,
typename T1,
typename... TRest>
1402 struct is_base_of_all
1408 template <
typename T,
typename T1>
1409 struct is_base_of_all<T, T1>
1416 template <
typename T,
typename... TRest>
1424 template <
typename T,
typename T1,
typename... TRest>
1425 struct is_base_of_any
1431 template <
typename T,
typename T1>
1432 struct is_base_of_any<T, T1>
1439 template <
typename T,
typename... TRest>
1448 template <
typename T>
1457 typedef type_t type;
1458 typedef type_t& reference;
1459 typedef const type_t& const_reference;
1460 typedef type_t* pointer;
1461 typedef const type_t* const_pointer;
1462 typedef const type_t*
const const_pointer_const;
1465 typedef type_t&& rvalue_reference;
1470 template <
typename T>
1479 typedef type_t type;
1480 typedef type_t& reference;
1481 typedef const type_t& const_reference;
1482 typedef type_t* pointer;
1483 typedef const type_t* const_pointer;
1484 typedef const type_t*
const const_pointer_const;
1487 typedef type_t&& rvalue_reference;
1492 template <
typename T>
1493 struct types<T*
const>
1501 typedef type_t type;
1502 typedef type_t& reference;
1503 typedef const type_t& const_reference;
1504 typedef type_t* pointer;
1505 typedef const type_t* const_pointer;
1506 typedef const type_t*
const const_pointer_const;
1509 typedef type_t&& rvalue_reference;
1514 template <
typename T>
1523 typedef type_t type;
1524 typedef type_t& reference;
1525 typedef const type_t& const_reference;
1526 typedef type_t* pointer;
1527 typedef const type_t* const_pointer;
1528 typedef const type_t*
const const_pointer_const;
1531 typedef type_t&& rvalue_reference;
1537 template <
typename T>
1546 typedef type_t type;
1547 typedef type_t& reference;
1548 typedef const type_t& const_reference;
1549 typedef type_t* pointer;
1550 typedef const type_t* const_pointer;
1551 typedef const type_t*
const const_pointer_const;
1554 typedef type_t&& rvalue_reference;
1560 template <
typename T>
1561 using types_t =
typename types<T>::type;
1563 template <
typename T>
1564 using types_r =
typename types<T>::reference;
1566 template <
typename T>
1567 using types_cr =
typename types<T>::const_reference;
1569 template <
typename T>
1570 using types_rr =
typename types<T>::rvalue_reference;
1572 template <
typename T>
1573 using types_p =
typename types<T>::pointer;
1575 template <
typename T>
1576 using types_cp =
typename types<T>::const_pointer;
1578 template <
typename T>
1579 using types_cpc =
typename types<T>::const_pointer_const;
1589 template <
typename T>
1596 template <
typename T,
typename T1,
typename... TRest>
1603 template <
typename T,
typename T1>
1604 struct are_all_same<T, T1>
1611 template <
typename T,
typename T1,
typename... TRest>
1612 inline constexpr bool are_all_same_v = are_all_same<T, T1, TRest...>::value;
1618 template <
typename...>
1623 template <
typename T1,
typename... Tn>
1624 struct conjunction<T1, Tn...> :
public etl::conditional_t<bool(T1::value), etl::conjunction<Tn...>, T1>
1628 template <
typename T>
1629 struct conjunction<T> :
public T
1635 template <
typename... T>
1636 inline constexpr bool conjunction_v = conjunction<T...>::value;
1642 template <
typename...>
1647 template <
typename T1,
typename... Tn>
1648 struct disjunction<T1, Tn...> :
public etl::conditional_t<bool(T1::value), T1, disjunction<Tn...>>
1652 template <
typename T1>
struct disjunction<T1> :
public T1
1658 template <
typename... T>
1663#if ETL_USING_STL && ETL_USING_CPP11 && !defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS) && ((!defined(ARDUINO) && ETL_NOT_USING_STLPORT) || defined(ETL_GCC_V5_TYPE_TRAITS_SUPPORTED))
1671 template<
typename T1,
typename T2>
1672 using is_assignable = std::is_assignable<T1, T2>;
1676 template<
typename T,
typename... TArgs>
1677 using is_constructible = std::is_constructible<T, TArgs...>;
1681 template <
typename T>
1682 using is_copy_constructible = std::is_copy_constructible<T>;
1686 template <
typename T>
1687 using is_move_constructible = std::is_move_constructible<T>;
1691#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1692 template <
typename T>
1693 using is_trivially_constructible = std::is_trivially_constructible<T>;
1695 template <
typename T>
1701#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1702 template <
typename T>
1703 using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
1705 template <
typename T>
1711#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1712 template <
typename T>
1713 using is_trivially_destructible = std::is_trivially_destructible<T>;
1715 template <
typename T>
1721#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1722 template <
typename T>
1723 using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
1725 template <
typename T>
1731#if ETL_CPP11_TYPE_TRAITS_IS_TRIVIAL_SUPPORTED
1732 template <
typename T>
1733 using is_trivially_copyable = std::is_trivially_copyable<T>;
1735 template <
typename T>
1739#elif defined(ETL_USE_TYPE_TRAITS_BUILTINS) && !defined(ETL_USER_DEFINED_TYPE_TRAITS)
1747 template<
typename T1,
typename T2>
1748 struct is_assignable
1750 static ETL_CONSTANT
bool value = __is_assignable(T1, T2);
1756 template<
typename T,
typename... TArgs>
1757 struct is_constructible
1764 template<
typename T,
typename TArgs =
void>
1765 struct is_constructible
1772 template<
typename T>
1773 struct is_constructible<T, void>
1781 template <
typename T>
1782 struct is_copy_constructible :
public etl::is_constructible<T, typename etl::add_lvalue_reference<const T>::type>
1788 template <
typename T>
1796 template <
typename T,
typename... TArgs>
1797 struct is_trivially_constructible
1799#if defined(ETL_COMPILER_GCC)
1800 static ETL_CONSTANT
bool value = __has_trivial_constructor(T);
1802 static ETL_CONSTANT
bool value = __is_trivially_constructible(T, TArgs...);
1808 template <
typename T,
typename TArgs =
void>
1809 struct is_trivially_constructible
1811#if defined(ETL_COMPILER_GCC)
1812 static ETL_CONSTANT
bool value = __has_trivial_constructor(T);
1814 static ETL_CONSTANT
bool value = __is_trivially_constructible(T, TArgs);
1820 template <
typename T>
1821 struct is_trivially_constructible<T, void>
1823#if defined(ETL_COMPILER_GCC)
1824 static ETL_CONSTANT
bool value = __has_trivial_constructor(T);
1826 static ETL_CONSTANT
bool value = __is_trivially_constructible(T);
1833 template <
typename T>
1834 struct is_trivially_copy_constructible :
public is_trivially_constructible<T, typename add_lvalue_reference<const T>::type>
1840 template <
typename T>
1841 struct is_trivially_destructible
1843#if defined(ETL_COMPILER_GCC)
1844 static ETL_CONSTANT
bool value = __has_trivial_destructor(T);
1846 static ETL_CONSTANT
bool value = __is_trivially_destructible(T);
1852 template <
typename T>
1853 struct is_trivially_copy_assignable
1855#if defined(ETL_COMPILER_GCC)
1856 static ETL_CONSTANT
bool value = __has_trivial_copy(T);
1858 static ETL_CONSTANT
bool value = __is_trivially_copyable(T);
1864 template <
typename T>
1865 struct is_trivially_copyable
1867#if defined(ETL_COMPILER_GCC)
1868 static ETL_CONSTANT
bool value = __has_trivial_copy(T);
1870 static ETL_CONSTANT
bool value = __is_trivially_copyable(T);
1874#elif defined(ETL_USER_DEFINED_TYPE_TRAITS) && !defined(ETL_USE_TYPE_TRAITS_BUILTINS)
1883 template <
typename T1,
1886 struct is_assignable;
1888 template <
typename T1,
typename T2>
1893 template <
typename T1,
typename T2>
1894 struct is_assignable<T1, T2, false>;
1899 template <
typename T,
bool B,
typename... TArgs>
1900 struct is_constructible_helper;
1902 template <
typename T,
typename... TArgs>
1903 struct is_constructible_helper<T, true, TArgs...> :
public etl::true_type
1907 template <
typename T,
typename... TArgs>
1908 struct is_constructible_helper<T, false, TArgs...>;
1910 template <
typename T,
typename... TArgs>
1911 struct is_constructible :
public is_constructible_helper<T, etl::is_arithmetic<T>::value || etl::is_pointer<T>::value, TArgs...>
1919 struct is_copy_constructible;
1921 template <
typename T>
1926 template <
typename T>
1927 struct is_copy_constructible<T, false>;
1932 struct is_move_constructible;
1934 template <
typename T>
1939 template <
typename T>
1940 struct is_move_constructible<T, false>;
1945 struct is_trivially_constructible;
1947 template <
typename T>
1948 struct is_trivially_constructible<T, true> :
public etl::true_type
1952 template <
typename T>
1953 struct is_trivially_constructible<T, false>;
1958 struct is_trivially_copy_constructible;
1960 template <
typename T>
1961 struct is_trivially_copy_constructible<T, true> :
public etl::true_type
1965 template <
typename T>
1966 struct is_trivially_copy_constructible<T, false>;
1971 struct is_trivially_destructible;
1973 template <
typename T>
1974 struct is_trivially_destructible<T, true> :
public etl::true_type
1978 template <
typename T>
1979 struct is_trivially_destructible<T, false>;
1984 struct is_trivially_copy_assignable;
1986 template <
typename T>
1987 struct is_trivially_copy_assignable<T, true> :
public etl::true_type
1991 template <
typename T>
1992 struct is_trivially_copy_assignable<T, false>;
1997 struct is_trivially_copyable;
1999 template <
typename T>
2004 template <
typename T>
2005 struct is_trivially_copyable<T, false>;
2016 template <
typename T1,
typename T2>
2017 struct is_assignable :
public etl::bool_constant<(etl::is_arithmetic<T1>::value || etl::is_pointer<T1>::value) && (etl::is_arithmetic<T2>::value || etl::is_pointer<T2>::value)>
2024 namespace private_type_traits
2026 template <
class,
class T,
class...
Args>
2029 template <
class T,
class...
Args>
2035 template <
class T,
class... Args>
2036 using is_constructible = private_type_traits::is_constructible_<void_t<>, T, Args...>;
2040 template <
class T>
struct is_copy_constructible :
public is_constructible<T, typename etl::add_lvalue_reference<typename etl::add_const<T>::type>::type>{};
2041 template <>
struct is_copy_constructible<void> :
public false_type{};
2042 template <>
struct is_copy_constructible<void const> :
public false_type{};
2043 template <>
struct is_copy_constructible<void volatile> :
public false_type{};
2044 template <>
struct is_copy_constructible<void const volatile> :
public false_type{};
2048 template <
typename T>
struct is_move_constructible:
public is_constructible<T, typename etl::add_rvalue_reference<T>::type>{};
2049 template <>
struct is_move_constructible<void> :
public false_type{};
2050 template <>
struct is_move_constructible<void const> :
public false_type{};
2051 template <>
struct is_move_constructible<void volatile> :
public false_type{};
2052 template <>
struct is_move_constructible<void const volatile> :
public false_type{};
2058 template <
typename T>
2059 struct is_copy_constructible :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2065 template <
typename T>
2066 struct is_move_constructible :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2073 template <
typename T>
2074 struct is_trivially_constructible :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2080 template <
typename T>
2081 struct is_trivially_copy_constructible :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2087 template <
typename T>
2088 struct is_trivially_destructible :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2094 template <
typename T>
2095 struct is_trivially_copy_assignable :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2101 template <
typename T>
2102 struct is_trivially_copyable :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2108 template <
typename T1,
typename T2>
2109 struct is_lvalue_assignable :
public etl::is_assignable<typename etl::add_lvalue_reference<T1>::type,
2110 typename etl::add_lvalue_reference<typename etl::add_const<T2>::type>::type>
2117 template<
typename T,
typename =
void>
2120 template<
typename T>
2121 struct is_default_constructible<T,
etl::void_t<decltype(T())>> :
etl::true_type { };
2123 template <
typename T>
2124 struct is_default_constructible :
public etl::bool_constant<etl::is_arithmetic<T>::value || etl::is_pointer<T>::value>
2131 template <
typename T1,
typename T2>
2134 template <
typename T1,
typename T2>
2137 template<
typename T,
typename... TArgs>
2140 template<
typename T,
typename... TArgs>
2143 template<
typename T>
2146 template<
typename T>
2149 template <
typename T>
2152 template <
typename T>
2155 template <
typename T>
2158 template <
typename T>
2161 template <
typename T>
2174 template<
typename...>
2181 template <
typename T>
2182 struct common_type<T> : common_type<T, T>
2186 namespace private_common_type
2188 template <
typename T1,
typename T2>
2189 using conditional_result_t =
decltype(
false ? declval<T1>() : declval<T2>());
2191 template <
typename,
typename,
typename =
void>
2192 struct decay_conditional_result
2196 template <
typename T1,
typename T2>
2197 struct decay_conditional_result<T1, T2, void_t<conditional_result_t<T1, T2>>>
2202 template <
typename T1,
typename T2,
typename =
void>
2203 struct common_type_2_impl : decay_conditional_result<const T1&, const T2&>
2207 template <
typename T1,
typename T2>
2208 struct common_type_2_impl<T1, T2, void_t<conditional_result_t<T1, T2>>>
2209 : decay_conditional_result<T1, T2>
2216 template <
typename T1,
typename T2>
2217 struct common_type<T1, T2>
2218 :
etl::conditional<etl::is_same<T1, typename etl::decay<T1>::type>::value&& etl::is_same<T2, typename etl::decay<T2>::type>::value,
2219 private_common_type::common_type_2_impl<T1, T2>,
2220 common_type<typename etl::decay<T2>::type,
2221 typename etl::decay<T2>::type>>::type
2227 namespace private_common_type
2234 template <
typename T1,
typename T2,
typename...
TRest>
2236 :
common_type<typename common_type<T1, T2>::type, TRest...>
2241 template<
typename T1,
typename T2,
typename... TRest>
2242 struct common_type<T1, T2, TRest...>
2243 : private_common_type::common_type_multi_impl<void, T1, T2, TRest...>
2247 template <
typename... T>
2248 using common_type_t =
typename common_type<T...>::type;
2254 template <
typename T>
2255 struct unsigned_type
2257 typedef typename etl::conditional<
sizeof(T) ==
sizeof(
unsigned char),
unsigned char,
2258 typename etl::conditional<
sizeof(T) ==
sizeof(
unsigned short),
unsigned short,
2260 typename etl::conditional<
sizeof(T) ==
sizeof(
unsigned long),
unsigned long,
2261 unsigned long long>::type>::type>::type>::type type;
2265 template <
typename T>
2266 using unsigned_type_t =
typename unsigned_type<T>::type;
2272 template <
typename T>
2279 long long>::type>::type>::type>::type type;
2283 template <
typename T>
2284 using signed_type_t =
typename signed_type<T>::type;
2290 template <
typename T>
2291 struct type_identity {
typedef T type; };
2294 template <
typename T>
2295 using type_identity_t =
typename type_identity<T>::type;
2301 template <
typename... TTypes>
2302 struct has_duplicates;
2304 template <
typename TFirst,
typename... TRest>
2305 struct has_duplicates<TFirst, TRest...> :
etl::conditional_t<etl::is_one_of<TFirst, TRest...>::value,
2307 has_duplicates<TRest...>> {};
2309 template <
typename T>
2317 template <
typename... TTypes>
2324 template <
typename T,
typename... TTypes>
2327 template <
typename T,
typename U,
typename... URest>
2329 etl::is_same<T, U>::value +
2330 count_of<T, URest...>::value> {};
2332 template <
typename T>
2337 template <
typename T,
typename... TTypes>
2338 inline constexpr size_t count_of_v =
etl::count_of<T, TTypes...>::value;
2344 template <
typename T,
typename... TTypes>
2345 struct has_duplicates_of :
etl::bool_constant<(etl::count_of<T, TTypes...>::value > 1U)> {};
2349 template <
typename T,
typename... TTypes>
2355#define ETL_IS_CHAR_TYPE(type) (etl::is_same<char, type>::value || etl::is_same<signed char, type>::value || etl::is_same<unsigned char, type>::value)
2356#define ETL_IS_NOT_CHAR_TYPE(type) (!ETL_IS_CHAR_TYPE(type))
2358#define ETL_IS_POINTER_TYPE(type) (etl::is_pointer<type>::value)
2359#define ETL_IS_NOT_POINTER_TYPE(type) (!ETL_IS_POINTER_TYPE(type))
2361#define ETL_TARGET_IS_TRIVIALLY_COPYABLE(type) (etl::is_trivially_copyable<typename etl::iterator_traits<type>::value_type>::value)
2362#define ETL_TARGET_IS_NOT_TRIVIALLY_COPYABLE(type) (!ETL_TARGET_IS_TRIVIALLY_COPYABLE(type))
integral_constant< bool, false > false_type
integral_constant specialisations
Definition type_traits_generator.h:831
add_const
Definition type_traits_generator.h:923
add_pointer
Definition type_traits_generator.h:893
add_volatile
Definition type_traits_generator.h:953
add_rvalue_reference
Definition type_traits_generator.h:1322
conditional
Definition type_traits_generator.h:1155
integral_constant
Definition type_traits_generator.h:827
is_arithmetic
Definition type_traits_generator.h:1056
is_array
Definition type_traits_generator.h:1086
is_base_of
Definition type_traits_generator.h:1247
is_const
Definition type_traits_generator.h:903
is_fundamental
Definition type_traits_generator.h:1066
is_integral
Definition type_traits_generator.h:996
is_lvalue_reference
Definition type_traits_generator.h:1116
is_rvalue_reference
Definition type_traits_generator.h:1139
is_pointer
Definition type_traits_generator.h:1096
is_same
Definition type_traits_generator.h:1036
is_signed
Definition type_traits_generator.h:1006
is_unsigned
Definition type_traits_generator.h:1016
is_volatile
Definition type_traits_generator.h:933
remove_const
Definition type_traits_generator.h:913
remove_cv
Definition type_traits_generator.h:963
remove_extent
Definition type_traits_generator.h:1207
remove_pointer
Definition type_traits_generator.h:883
remove_reference
Definition type_traits_generator.h:873
remove_volatile
Definition type_traits_generator.h:943
bitset_ext
Definition absolute.h:38
add_lvalue_reference
Definition type_traits_generator.h:1265
Definition type_traits_generator.h:844
conjunction
Definition type_traits_generator.h:2025
Definition type_traits_generator.h:2067
Definition type_traits_generator.h:2132
Definition type_traits_generator.h:2118
Definition type_traits_generator.h:2074
Definition type_traits_generator.h:2082
Definition type_traits_generator.h:2103
Definition type_traits_generator.h:2089
Definition type_traits_generator.h:2110
Definition type_traits_generator.h:2096
pair holds two objects of arbitrary type
Definition utility.h:164
ETL_CONSTEXPR pair()
Default constructor.
Definition utility.h:176
size_of
Definition type_traits_generator.h:1592
void add_pointer(const volatile void *value, TIString &str, const etl::basic_format_spec< TIString > &format, const bool append)
Helper function for pointers.
Definition to_string_helper.h:443