29 #ifndef _GLIBCXX_TYPE_TRAITS
30 #define _GLIBCXX_TYPE_TRAITS 1
32 #pragma GCC system_header
34 #if __cplusplus < 201103L
40 namespace std _GLIBCXX_VISIBILITY(default)
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 template<
typename... _Elements>
47 template<
typename _Tp>
48 class reference_wrapper;
64 template<
typename _Tp, _Tp __v>
67 static constexpr _Tp value = __v;
68 typedef _Tp value_type;
70 constexpr
operator value_type()
const noexcept {
return value; }
71 #if __cplusplus > 201103L
73 #define __cpp_lib_integral_constant_callable 201304
75 constexpr value_type operator()()
const noexcept {
return value; }
79 template<
typename _Tp, _Tp __v>
94 #if __cplusplus >= 201703L
95 # define __cpp_lib_bool_constant 201505
104 template<
bool,
typename,
typename>
108 template <
typename _Type>
109 struct __type_identity
110 {
using type = _Type; };
112 template<
typename _Tp>
113 using __type_identity_t =
typename __type_identity<_Tp>::type;
115 template<
typename...>
123 template<
typename _B1>
128 template<
typename _B1,
typename _B2>
129 struct __or_<_B1, _B2>
130 :
public conditional<_B1::value, _B1, _B2>::type
133 template<
typename _B1,
typename _B2,
typename _B3,
typename... _Bn>
134 struct __or_<_B1, _B2, _B3, _Bn...>
135 :
public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
138 template<
typename...>
146 template<
typename _B1>
151 template<
typename _B1,
typename _B2>
152 struct __and_<_B1, _B2>
153 :
public conditional<_B1::value, _B2, _B1>::type
156 template<
typename _B1,
typename _B2,
typename _B3,
typename... _Bn>
157 struct __and_<_B1, _B2, _B3, _Bn...>
158 :
public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
161 template<
typename _Pp>
163 :
public __bool_constant<!bool(_Pp::value)>
167 #if __cplusplus >= 201703L
170 template<
typename... _Bn>
171 inline constexpr
bool __or_v = __or_<_Bn...>::value;
172 template<
typename... _Bn>
173 inline constexpr
bool __and_v = __and_<_Bn...>::value;
176 #define __cpp_lib_logical_traits 201510
178 template<
typename... _Bn>
183 template<
typename... _Bn>
188 template<
typename _Pp>
196 template<
typename... _Bn>
197 inline constexpr
bool conjunction_v = conjunction<_Bn...>::value;
199 template<
typename... _Bn>
200 inline constexpr
bool disjunction_v = disjunction<_Bn...>::value;
202 template<
typename _Pp>
203 inline constexpr
bool negation_v = negation<_Pp>::value;
222 struct __is_array_unknown_bounds;
227 template <
typename _Tp,
size_t = sizeof(_Tp)>
228 constexpr
true_type __is_complete_or_unbounded(__type_identity<_Tp>)
231 template <
typename _TypeIdentity,
232 typename _NestedType =
typename _TypeIdentity::type>
233 constexpr
typename __or_<
234 is_reference<_NestedType>,
235 is_function<_NestedType>,
236 is_void<_NestedType>,
237 __is_array_unknown_bounds<_NestedType>
238 >::type __is_complete_or_unbounded(_TypeIdentity)
246 template<
typename _Tp>
247 struct __success_type
248 {
typedef _Tp type; };
250 struct __failure_type
254 template<
typename _Tp>
255 using __remove_cv_t =
typename remove_cv<_Tp>::type;
260 struct __is_void_helper
264 struct __is_void_helper<void>
269 template<
typename _Tp>
271 :
public __is_void_helper<__remove_cv_t<_Tp>>::type
276 struct __is_integral_helper
280 struct __is_integral_helper<bool>
284 struct __is_integral_helper<char>
288 struct __is_integral_helper<signed char>
292 struct __is_integral_helper<unsigned char>
298 #ifdef __WCHAR_TYPE__
300 struct __is_integral_helper<wchar_t>
304 #ifdef _GLIBCXX_USE_CHAR8_T
306 struct __is_integral_helper<char8_t>
311 struct __is_integral_helper<char16_t>
315 struct __is_integral_helper<char32_t>
319 struct __is_integral_helper<short>
323 struct __is_integral_helper<unsigned short>
327 struct __is_integral_helper<int>
331 struct __is_integral_helper<unsigned int>
335 struct __is_integral_helper<long>
339 struct __is_integral_helper<unsigned long>
343 struct __is_integral_helper<long long>
347 struct __is_integral_helper<unsigned long long>
352 #if defined(__GLIBCXX_TYPE_INT_N_0)
354 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0>
358 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0>
361 #if defined(__GLIBCXX_TYPE_INT_N_1)
363 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1>
367 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1>
370 #if defined(__GLIBCXX_TYPE_INT_N_2)
372 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2>
376 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2>
379 #if defined(__GLIBCXX_TYPE_INT_N_3)
381 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3>
385 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3>
391 template<
typename _Tp>
393 :
public __is_integral_helper<__remove_cv_t<_Tp>>::type
398 struct __is_floating_point_helper
402 struct __is_floating_point_helper<float>
406 struct __is_floating_point_helper<double>
410 struct __is_floating_point_helper<long double>
413 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128) && !defined(__CUDACC__)
415 struct __is_floating_point_helper<__float128>
421 template<
typename _Tp>
423 :
public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
431 template<
typename _Tp, std::
size_t _Size>
435 template<
typename _Tp>
436 struct is_array<_Tp[]>
440 struct __is_pointer_helper
443 template<
typename _Tp>
444 struct __is_pointer_helper<_Tp*>
448 template<
typename _Tp>
450 :
public __is_pointer_helper<__remove_cv_t<_Tp>>
::type
458 template<
typename _Tp>
467 template<
typename _Tp>
472 struct __is_member_object_pointer_helper
475 template<
typename _Tp,
typename _Cp>
476 struct __is_member_object_pointer_helper<_Tp _Cp::*>
477 :
public __not_<is_function<_Tp>>::type { };
480 template<
typename _Tp>
482 :
public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>
::type
486 struct __is_member_function_pointer_helper
489 template<
typename _Tp,
typename _Cp>
490 struct __is_member_function_pointer_helper<_Tp _Cp::*>
491 :
public is_function<_Tp>::type { };
494 template<
typename _Tp>
496 :
public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>
::type
500 template<
typename _Tp>
506 template<
typename _Tp>
512 template<
typename _Tp>
518 template<
typename _Tp>
520 :
public __bool_constant<!is_const<const _Tp>::value> { };
522 template<
typename _Tp>
526 template<
typename _Tp>
527 struct is_function<_Tp&&>
530 #define __cpp_lib_is_null_pointer 201309
533 struct __is_null_pointer_helper
537 struct __is_null_pointer_helper<
std::nullptr_t>
541 template<
typename _Tp>
543 :
public __is_null_pointer_helper<__remove_cv_t<_Tp>>
::type
548 template<
typename _Tp>
551 { } _GLIBCXX_DEPRECATED_SUGGEST(
"std::is_null_pointer");
556 template<
typename _Tp>
558 :
public __or_<is_lvalue_reference<_Tp>,
559 is_rvalue_reference<_Tp>>::type
563 template<
typename _Tp>
565 :
public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
569 template<
typename _Tp>
571 :
public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
572 is_null_pointer<_Tp>>::type
576 template<
typename _Tp>
578 :
public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
586 template<
typename _Tp>
588 :
public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
589 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
593 template<
typename _Tp>
595 :
public __not_<is_fundamental<_Tp>>::type { };
598 template<
typename _Tp>
599 struct __is_member_pointer_helper
602 template<
typename _Tp,
typename _Cp>
603 struct __is_member_pointer_helper<_Tp _Cp::*>
608 template<
typename _Tp>
610 :
public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
613 template<
typename,
typename>
617 template<
typename _Tp,
typename... _Types>
618 using __is_one_of = __or_<is_same<_Tp, _Types>...>;
621 template<
typename _Tp>
622 using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
623 signed char,
signed short,
signed int,
signed long,
625 #if defined(__GLIBCXX_TYPE_INT_N_0)
626 ,
signed __GLIBCXX_TYPE_INT_N_0
628 #if defined(__GLIBCXX_TYPE_INT_N_1)
629 ,
signed __GLIBCXX_TYPE_INT_N_1
631 #if defined(__GLIBCXX_TYPE_INT_N_2)
632 ,
signed __GLIBCXX_TYPE_INT_N_2
634 #if defined(__GLIBCXX_TYPE_INT_N_3)
635 ,
signed __GLIBCXX_TYPE_INT_N_3
640 template<
typename _Tp>
641 using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
642 unsigned char,
unsigned short,
unsigned int,
unsigned long,
644 #if defined(__GLIBCXX_TYPE_INT_N_0)
645 ,
unsigned __GLIBCXX_TYPE_INT_N_0
647 #if defined(__GLIBCXX_TYPE_INT_N_1)
648 ,
unsigned __GLIBCXX_TYPE_INT_N_1
650 #if defined(__GLIBCXX_TYPE_INT_N_2)
651 ,
unsigned __GLIBCXX_TYPE_INT_N_2
653 #if defined(__GLIBCXX_TYPE_INT_N_3)
654 ,
unsigned __GLIBCXX_TYPE_INT_N_3
659 template<
typename _Tp>
660 using __is_standard_integer
661 = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
664 template<
typename...>
using __void_t = void;
668 template<
typename _Tp,
typename =
void>
669 struct __is_referenceable
673 template<
typename _Tp>
674 struct __is_referenceable<_Tp, __void_t<_Tp&>>
686 template<
typename _Tp>
695 template<
typename _Tp>
700 template<
typename _Tp>
704 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
705 "template argument must be a complete class or an unbounded array");
709 template<
typename _Tp>
713 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
714 "template argument must be a complete class or an unbounded array");
718 template<
typename _Tp>
722 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
723 "template argument must be a complete class or an unbounded array");
730 template<
typename _Tp>
732 _GLIBCXX20_DEPRECATED(
"use is_standard_layout && is_trivial instead")
736 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
737 "template argument must be a complete class or an unbounded array");
743 template<
typename _Tp>
745 _GLIBCXX17_DEPRECATED
749 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
750 "template argument must be a complete class or an unbounded array");
754 template<
typename _Tp>
760 template<
typename _Tp>
765 #if __cplusplus >= 201402L
766 #define __cpp_lib_is_final 201402L
769 template<
typename _Tp>
776 template<
typename _Tp>
782 template<
typename _Tp,
784 struct __is_signed_helper
787 template<
typename _Tp>
788 struct __is_signed_helper<_Tp, true>
789 :
public integral_constant<bool, _Tp(-1) < _Tp(0)>
794 template<typename _Tp>
796 : public __is_signed_helper<_Tp>::type
800 template<typename _Tp>
802 : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
806 template<typename _Tp, typename _Up = _Tp&&>
810 template<typename _Tp>
815 template<typename _Tp>
816 auto declval() noexcept -> decltype(__declval<_Tp>(0));
818 template<typename, unsigned = 0>
825 template<typename _Tp>
826 struct __is_array_known_bounds
830 template<
typename _Tp>
831 struct __is_array_unknown_bounds
832 :
public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
842 struct __do_is_destructible_impl
844 template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
851 template<
typename _Tp>
852 struct __is_destructible_impl
853 :
public __do_is_destructible_impl
855 typedef decltype(__test<_Tp>(0)) type;
858 template<typename _Tp,
859 bool = __or_<is_void<_Tp>,
860 __is_array_unknown_bounds<_Tp>,
861 is_function<_Tp>>::value,
862 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
863 struct __is_destructible_safe;
865 template<typename _Tp>
866 struct __is_destructible_safe<_Tp, false, false>
867 : public __is_destructible_impl<typename
868 remove_all_extents<_Tp>::type>::type
871 template<
typename _Tp>
872 struct __is_destructible_safe<_Tp, true, false>
875 template<
typename _Tp>
876 struct __is_destructible_safe<_Tp, false, true>
881 template<
typename _Tp>
883 :
public __is_destructible_safe<_Tp>::type
885 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
886 "template argument must be a complete class or an unbounded array");
895 struct __do_is_nt_destructible_impl
897 template<
typename _Tp>
898 static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
905 template<
typename _Tp>
906 struct __is_nt_destructible_impl
907 :
public __do_is_nt_destructible_impl
909 typedef decltype(__test<_Tp>(0)) type;
912 template<typename _Tp,
913 bool = __or_<is_void<_Tp>,
914 __is_array_unknown_bounds<_Tp>,
915 is_function<_Tp>>::value,
916 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
917 struct __is_nt_destructible_safe;
919 template<typename _Tp>
920 struct __is_nt_destructible_safe<_Tp, false, false>
921 : public __is_nt_destructible_impl<typename
922 remove_all_extents<_Tp>::type>::type
925 template<
typename _Tp>
926 struct __is_nt_destructible_safe<_Tp, true, false>
929 template<
typename _Tp>
930 struct __is_nt_destructible_safe<_Tp, false, true>
935 template<
typename _Tp>
937 :
public __is_nt_destructible_safe<_Tp>::type
939 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
940 "template argument must be a complete class or an unbounded array");
944 template<
typename _Tp,
typename... _Args>
945 struct __is_constructible_impl
946 :
public __bool_constant<__is_constructible(_Tp, _Args...)>
951 template<
typename _Tp,
typename... _Args>
953 :
public __is_constructible_impl<_Tp, _Args...>
955 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
956 "template argument must be a complete class or an unbounded array");
960 template<
typename _Tp>
962 :
public __is_constructible_impl<_Tp>::type
964 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
965 "template argument must be a complete class or an unbounded array");
969 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
970 struct __is_copy_constructible_impl;
972 template<
typename _Tp>
973 struct __is_copy_constructible_impl<_Tp, false>
976 template<
typename _Tp>
977 struct __is_copy_constructible_impl<_Tp, true>
978 :
public __is_constructible_impl<_Tp, const _Tp&>
983 template<
typename _Tp>
985 :
public __is_copy_constructible_impl<_Tp>
987 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
988 "template argument must be a complete class or an unbounded array");
992 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
993 struct __is_move_constructible_impl;
995 template<
typename _Tp>
996 struct __is_move_constructible_impl<_Tp, false>
999 template<
typename _Tp>
1000 struct __is_move_constructible_impl<_Tp, true>
1001 :
public __is_constructible_impl<_Tp, _Tp&&>
1006 template<
typename _Tp>
1008 :
public __is_move_constructible_impl<_Tp>
1010 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1011 "template argument must be a complete class or an unbounded array");
1015 template<
typename _Tp,
typename... _Args>
1016 using __is_nothrow_constructible_impl
1017 = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>;
1021 template<
typename _Tp,
typename... _Args>
1023 :
public __is_nothrow_constructible_impl<_Tp, _Args...>::type
1025 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1026 "template argument must be a complete class or an unbounded array");
1030 template<
typename _Tp>
1032 :
public __bool_constant<__is_nothrow_constructible(_Tp)>
1034 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1035 "template argument must be a complete class or an unbounded array");
1039 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1040 struct __is_nothrow_copy_constructible_impl;
1042 template<
typename _Tp>
1043 struct __is_nothrow_copy_constructible_impl<_Tp, false>
1046 template<
typename _Tp>
1047 struct __is_nothrow_copy_constructible_impl<_Tp, true>
1048 :
public __is_nothrow_constructible_impl<_Tp, const _Tp&>
1053 template<
typename _Tp>
1055 :
public __is_nothrow_copy_constructible_impl<_Tp>::type
1057 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1058 "template argument must be a complete class or an unbounded array");
1062 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1063 struct __is_nothrow_move_constructible_impl;
1065 template<
typename _Tp>
1066 struct __is_nothrow_move_constructible_impl<_Tp, false>
1069 template<
typename _Tp>
1070 struct __is_nothrow_move_constructible_impl<_Tp, true>
1071 :
public __is_nothrow_constructible_impl<_Tp, _Tp&&>
1076 template<
typename _Tp>
1078 :
public __is_nothrow_move_constructible_impl<_Tp>::type
1080 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1081 "template argument must be a complete class or an unbounded array");
1085 template<
typename _Tp,
typename _Up>
1087 :
public __bool_constant<__is_assignable(_Tp, _Up)>
1089 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1090 "template argument must be a complete class or an unbounded array");
1093 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1094 struct __is_copy_assignable_impl;
1096 template<
typename _Tp>
1097 struct __is_copy_assignable_impl<_Tp, false>
1100 template<
typename _Tp>
1101 struct __is_copy_assignable_impl<_Tp, true>
1102 :
public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
1106 template<
typename _Tp>
1108 :
public __is_copy_assignable_impl<_Tp>::type
1110 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1111 "template argument must be a complete class or an unbounded array");
1114 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1115 struct __is_move_assignable_impl;
1117 template<
typename _Tp>
1118 struct __is_move_assignable_impl<_Tp, false>
1121 template<
typename _Tp>
1122 struct __is_move_assignable_impl<_Tp, true>
1123 :
public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
1127 template<
typename _Tp>
1129 :
public __is_move_assignable_impl<_Tp>::type
1131 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1132 "template argument must be a complete class or an unbounded array");
1135 template<
typename _Tp,
typename _Up>
1136 using __is_nothrow_assignable_impl
1137 = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;
1140 template<
typename _Tp,
typename _Up>
1142 :
public __is_nothrow_assignable_impl<_Tp, _Up>
1144 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1145 "template argument must be a complete class or an unbounded array");
1148 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1149 struct __is_nt_copy_assignable_impl;
1151 template<
typename _Tp>
1152 struct __is_nt_copy_assignable_impl<_Tp, false>
1155 template<
typename _Tp>
1156 struct __is_nt_copy_assignable_impl<_Tp, true>
1157 :
public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
1161 template<
typename _Tp>
1163 :
public __is_nt_copy_assignable_impl<_Tp>
1165 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1166 "template argument must be a complete class or an unbounded array");
1169 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1170 struct __is_nt_move_assignable_impl;
1172 template<
typename _Tp>
1173 struct __is_nt_move_assignable_impl<_Tp, false>
1176 template<
typename _Tp>
1177 struct __is_nt_move_assignable_impl<_Tp, true>
1178 :
public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
1182 template<
typename _Tp>
1184 :
public __is_nt_move_assignable_impl<_Tp>
1186 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1187 "template argument must be a complete class or an unbounded array");
1191 template<
typename _Tp,
typename... _Args>
1193 :
public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
1195 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1196 "template argument must be a complete class or an unbounded array");
1200 template<
typename _Tp>
1202 :
public __bool_constant<__is_trivially_constructible(_Tp)>
1204 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1205 "template argument must be a complete class or an unbounded array");
1208 struct __do_is_implicitly_default_constructible_impl
1210 template <
typename _Tp>
1211 static void __helper(
const _Tp&);
1213 template <
typename _Tp>
1215 decltype(__helper<const _Tp&>({}))* = 0);
1220 template<
typename _Tp>
1221 struct __is_implicitly_default_constructible_impl
1222 :
public __do_is_implicitly_default_constructible_impl
1224 typedef decltype(__test(declval<_Tp>())) type;
1227 template<typename _Tp>
1228 struct __is_implicitly_default_constructible_safe
1229 : public __is_implicitly_default_constructible_impl<_Tp>::type
1232 template <
typename _Tp>
1233 struct __is_implicitly_default_constructible
1234 :
public __and_<__is_constructible_impl<_Tp>,
1235 __is_implicitly_default_constructible_safe<_Tp>>
1238 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1239 struct __is_trivially_copy_constructible_impl;
1241 template<
typename _Tp>
1242 struct __is_trivially_copy_constructible_impl<_Tp, false>
1245 template<
typename _Tp>
1246 struct __is_trivially_copy_constructible_impl<_Tp, true>
1247 :
public __and_<__is_copy_constructible_impl<_Tp>,
1248 integral_constant<bool,
1249 __is_trivially_constructible(_Tp, const _Tp&)>>
1253 template<
typename _Tp>
1255 :
public __is_trivially_copy_constructible_impl<_Tp>
1257 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1258 "template argument must be a complete class or an unbounded array");
1261 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1262 struct __is_trivially_move_constructible_impl;
1264 template<
typename _Tp>
1265 struct __is_trivially_move_constructible_impl<_Tp, false>
1268 template<
typename _Tp>
1269 struct __is_trivially_move_constructible_impl<_Tp, true>
1270 :
public __and_<__is_move_constructible_impl<_Tp>,
1271 integral_constant<bool,
1272 __is_trivially_constructible(_Tp, _Tp&&)>>
1276 template<
typename _Tp>
1278 :
public __is_trivially_move_constructible_impl<_Tp>
1280 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1281 "template argument must be a complete class or an unbounded array");
1285 template<
typename _Tp,
typename _Up>
1287 :
public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
1289 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1290 "template argument must be a complete class or an unbounded array");
1293 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1294 struct __is_trivially_copy_assignable_impl;
1296 template<
typename _Tp>
1297 struct __is_trivially_copy_assignable_impl<_Tp, false>
1300 template<
typename _Tp>
1301 struct __is_trivially_copy_assignable_impl<_Tp, true>
1302 :
public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
1306 template<
typename _Tp>
1308 :
public __is_trivially_copy_assignable_impl<_Tp>
1310 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1311 "template argument must be a complete class or an unbounded array");
1314 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1315 struct __is_trivially_move_assignable_impl;
1317 template<
typename _Tp>
1318 struct __is_trivially_move_assignable_impl<_Tp, false>
1321 template<
typename _Tp>
1322 struct __is_trivially_move_assignable_impl<_Tp, true>
1323 :
public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
1327 template<
typename _Tp>
1329 :
public __is_trivially_move_assignable_impl<_Tp>
1331 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1332 "template argument must be a complete class or an unbounded array");
1336 template<
typename _Tp>
1338 :
public __and_<__is_destructible_safe<_Tp>,
1339 __bool_constant<__has_trivial_destructor(_Tp)>>
1341 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1342 "template argument must be a complete class or an unbounded array");
1347 template<
typename _Tp>
1351 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1352 "template argument must be a complete class or an unbounded array");
1359 template<
typename _Tp>
1363 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1364 "template argument must be a complete class or an unbounded array");
1372 template<
typename _Tp, std::
size_t _Size>
1373 struct rank<_Tp[_Size]>
1376 template<
typename _Tp>
1378 :
public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1381 template<
typename,
unsigned _U
int>
1385 template<
typename _Tp,
unsigned _U
int, std::
size_t _Size>
1386 struct extent<_Tp[_Size], _Uint>
1388 _Uint == 0 ? _Size : extent<_Tp,
1392 template<
typename _Tp,
unsigned _U
int>
1393 struct extent<_Tp[], _Uint>
1394 :
public integral_constant<std::size_t,
1395 _Uint == 0 ? 0 : extent<_Tp,
1403 template<
typename _Tp,
typename _Up>
1405 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME
1412 #ifndef _GLIBCXX_HAVE_BUILTIN_IS_SAME
1413 template<
typename _Tp>
1420 template<
typename _Base,
typename _Derived>
1425 template<
typename _From,
typename _To,
1428 struct __is_convertible_helper
1433 #pragma GCC diagnostic push
1434 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
1435 template<
typename _From,
typename _To>
1436 class __is_convertible_helper<_From, _To, false>
1438 template<
typename _To1>
1439 static void __test_aux(_To1) noexcept;
1441 template<
typename _From1,
typename _To1,
1442 typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
1446 template<
typename,
typename>
1451 typedef decltype(__test<_From, _To>(0)) type;
1453 #pragma GCC diagnostic pop
1456 template<
typename _From,
typename _To>
1458 :
public __is_convertible_helper<_From, _To>::type
1462 template<
typename _ToElementType,
typename _FromElementType>
1466 template<
typename _From,
typename _To,
1469 struct __is_nt_convertible_helper
1473 #pragma GCC diagnostic push
1474 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
1475 template<
typename _From,
typename _To>
1476 class __is_nt_convertible_helper<_From, _To, false>
1478 template<
typename _To1>
1479 static void __test_aux(_To1) noexcept;
1481 template<
typename _From1,
typename _To1>
1483 __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
1486 template<
typename,
typename>
1491 using type = decltype(__test<_From, _To>(0));
1493 #pragma GCC diagnostic pop
1496 template<
typename _From,
typename _To>
1497 struct __is_nothrow_convertible
1498 :
public __is_nt_convertible_helper<_From, _To>::type
1501 #if __cplusplus > 201703L
1502 #define __cpp_lib_is_nothrow_convertible 201806L
1504 template<
typename _From,
typename _To>
1505 struct is_nothrow_convertible
1506 :
public __is_nt_convertible_helper<_From, _To>::type
1510 template<
typename _From,
typename _To>
1511 inline constexpr
bool is_nothrow_convertible_v
1512 = is_nothrow_convertible<_From, _To>::value;
1518 template<
typename _Tp>
1520 {
typedef _Tp type; };
1522 template<
typename _Tp>
1524 {
typedef _Tp type; };
1527 template<
typename _Tp>
1529 {
typedef _Tp type; };
1531 template<
typename _Tp>
1533 {
typedef _Tp type; };
1536 template<
typename _Tp>
1538 {
using type = _Tp; };
1540 template<
typename _Tp>
1542 {
using type = _Tp; };
1544 template<
typename _Tp>
1545 struct remove_cv<volatile _Tp>
1546 {
using type = _Tp; };
1548 template<
typename _Tp>
1549 struct remove_cv<const volatile _Tp>
1550 {
using type = _Tp; };
1553 template<
typename _Tp>
1555 {
typedef _Tp
const type; };
1558 template<
typename _Tp>
1560 {
typedef _Tp
volatile type; };
1563 template<
typename _Tp>
1570 #if __cplusplus > 201103L
1572 #define __cpp_lib_transformation_trait_aliases 201304
1575 template<
typename _Tp>
1579 template<
typename _Tp>
1583 template<
typename _Tp>
1587 template<
typename _Tp>
1591 template<
typename _Tp>
1595 template<
typename _Tp>
1602 template<
typename _Tp>
1604 {
typedef _Tp type; };
1606 template<
typename _Tp>
1608 {
typedef _Tp type; };
1610 template<
typename _Tp>
1611 struct remove_reference<_Tp&&>
1612 {
typedef _Tp type; };
1614 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1615 struct __add_lvalue_reference_helper
1616 {
typedef _Tp type; };
1618 template<
typename _Tp>
1619 struct __add_lvalue_reference_helper<_Tp, true>
1620 {
typedef _Tp& type; };
1623 template<
typename _Tp>
1625 :
public __add_lvalue_reference_helper<_Tp>
1628 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1629 struct __add_rvalue_reference_helper
1630 {
typedef _Tp type; };
1632 template<
typename _Tp>
1633 struct __add_rvalue_reference_helper<_Tp, true>
1634 {
typedef _Tp&& type; };
1637 template<
typename _Tp>
1639 :
public __add_rvalue_reference_helper<_Tp>
1642 #if __cplusplus > 201103L
1644 template<
typename _Tp>
1648 template<
typename _Tp>
1652 template<
typename _Tp>
1661 template<
typename _Unqualified,
bool _IsConst,
bool _IsVol>
1662 struct __cv_selector;
1664 template<
typename _Unqualified>
1665 struct __cv_selector<_Unqualified, false, false>
1666 {
typedef _Unqualified __type; };
1668 template<
typename _Unqualified>
1669 struct __cv_selector<_Unqualified, false, true>
1670 {
typedef volatile _Unqualified __type; };
1672 template<
typename _Unqualified>
1673 struct __cv_selector<_Unqualified, true, false>
1674 {
typedef const _Unqualified __type; };
1676 template<
typename _Unqualified>
1677 struct __cv_selector<_Unqualified, true, true>
1678 {
typedef const volatile _Unqualified __type; };
1680 template<
typename _Qualified,
typename _Unqualified,
1681 bool _IsConst = is_const<_Qualified>::value,
1682 bool _IsVol = is_volatile<_Qualified>::value>
1683 class __match_cv_qualifiers
1685 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
1688 typedef typename __match::__type __type;
1692 template<
typename _Tp>
1693 struct __make_unsigned
1694 {
typedef _Tp __type; };
1697 struct __make_unsigned<char>
1698 {
typedef unsigned char __type; };
1701 struct __make_unsigned<signed char>
1702 {
typedef unsigned char __type; };
1705 struct __make_unsigned<short>
1706 {
typedef unsigned short __type; };
1709 struct __make_unsigned<int>
1710 {
typedef unsigned int __type; };
1713 struct __make_unsigned<long>
1714 {
typedef unsigned long __type; };
1717 struct __make_unsigned<long long>
1718 {
typedef unsigned long long __type; };
1720 #if defined(__GLIBCXX_TYPE_INT_N_0)
1722 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0>
1723 {
typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; };
1725 #if defined(__GLIBCXX_TYPE_INT_N_1)
1727 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1>
1728 {
typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; };
1730 #if defined(__GLIBCXX_TYPE_INT_N_2)
1732 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2>
1733 {
typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; };
1735 #if defined(__GLIBCXX_TYPE_INT_N_3)
1737 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3>
1738 {
typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; };
1742 template<
typename _Tp,
1743 bool _IsInt = is_integral<_Tp>::value,
1744 bool _IsEnum = is_enum<_Tp>::value>
1745 class __make_unsigned_selector;
1747 template<
typename _Tp>
1748 class __make_unsigned_selector<_Tp, true, false>
1750 using __unsigned_type
1751 =
typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
1755 =
typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1758 class __make_unsigned_selector_base
1761 template<
typename...>
struct _List { };
1763 template<
typename _Tp,
typename... _Up>
1764 struct _List<_Tp, _Up...> : _List<_Up...>
1765 {
static constexpr
size_t __size =
sizeof(_Tp); };
1767 template<
size_t _Sz,
typename _Tp,
bool = (_Sz <= _Tp::__size)>
1770 template<
size_t _Sz,
typename _U
int,
typename... _UInts>
1771 struct __select<_Sz, _List<_Uint, _UInts...>,
true>
1772 {
using __type = _Uint; };
1774 template<
size_t _Sz,
typename _Uint,
typename... _UInts>
1775 struct __select<_Sz, _List<_Uint, _UInts...>, false>
1776 : __select<_Sz, _List<_UInts...>>
1781 template<
typename _Tp>
1782 class __make_unsigned_selector<_Tp, false, true>
1783 : __make_unsigned_selector_base
1786 using _UInts = _List<
unsigned char,
unsigned short,
unsigned int,
1787 unsigned long,
unsigned long long>;
1789 using __unsigned_type =
typename __select<
sizeof(_Tp), _UInts>::__type;
1793 =
typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1800 #ifdef __WCHAR_TYPE__
1802 struct __make_unsigned<wchar_t>
1805 =
typename __make_unsigned_selector<wchar_t, false, true>::__type;
1809 #ifdef _GLIBCXX_USE_CHAR8_T
1811 struct __make_unsigned<char8_t>
1814 =
typename __make_unsigned_selector<char8_t, false, true>::__type;
1819 struct __make_unsigned<char16_t>
1822 =
typename __make_unsigned_selector<char16_t, false, true>::__type;
1826 struct __make_unsigned<char32_t>
1829 =
typename __make_unsigned_selector<char32_t, false, true>::__type;
1837 template<
typename _Tp>
1839 {
typedef typename __make_unsigned_selector<_Tp>::__type type; };
1848 template<
typename _Tp>
1849 struct __make_signed
1850 {
typedef _Tp __type; };
1853 struct __make_signed<char>
1854 {
typedef signed char __type; };
1857 struct __make_signed<unsigned char>
1858 {
typedef signed char __type; };
1861 struct __make_signed<unsigned short>
1862 {
typedef signed short __type; };
1865 struct __make_signed<unsigned int>
1866 {
typedef signed int __type; };
1869 struct __make_signed<unsigned long>
1870 {
typedef signed long __type; };
1873 struct __make_signed<unsigned long long>
1874 {
typedef signed long long __type; };
1876 #if defined(__GLIBCXX_TYPE_INT_N_0)
1878 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0>
1879 {
typedef __GLIBCXX_TYPE_INT_N_0 __type; };
1881 #if defined(__GLIBCXX_TYPE_INT_N_1)
1883 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1>
1884 {
typedef __GLIBCXX_TYPE_INT_N_1 __type; };
1886 #if defined(__GLIBCXX_TYPE_INT_N_2)
1888 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2>
1889 {
typedef __GLIBCXX_TYPE_INT_N_2 __type; };
1891 #if defined(__GLIBCXX_TYPE_INT_N_3)
1893 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3>
1894 {
typedef __GLIBCXX_TYPE_INT_N_3 __type; };
1898 template<
typename _Tp,
1899 bool _IsInt = is_integral<_Tp>::value,
1900 bool _IsEnum = is_enum<_Tp>::value>
1901 class __make_signed_selector;
1903 template<
typename _Tp>
1904 class __make_signed_selector<_Tp, true, false>
1907 =
typename __make_signed<__remove_cv_t<_Tp>>::__type;
1911 =
typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
1915 template<
typename _Tp>
1916 class __make_signed_selector<_Tp, false, true>
1918 typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
1921 typedef typename __make_signed_selector<__unsigned_type>::__type __type;
1928 #if defined(__WCHAR_TYPE__)
1930 struct __make_signed<wchar_t>
1933 =
typename __make_signed_selector<wchar_t, false, true>::__type;
1937 #if defined(_GLIBCXX_USE_CHAR8_T)
1939 struct __make_signed<char8_t>
1942 =
typename __make_signed_selector<char8_t, false, true>::__type;
1947 struct __make_signed<char16_t>
1950 =
typename __make_signed_selector<char16_t, false, true>::__type;
1954 struct __make_signed<char32_t>
1957 =
typename __make_signed_selector<char32_t, false, true>::__type;
1965 template<
typename _Tp>
1967 {
typedef typename __make_signed_selector<_Tp>::__type type; };
1973 #if __cplusplus > 201103L
1975 template<
typename _Tp>
1979 template<
typename _Tp>
1986 template<
typename _Tp>
1988 {
typedef _Tp type; };
1990 template<
typename _Tp, std::
size_t _Size>
1992 {
typedef _Tp type; };
1994 template<
typename _Tp>
1995 struct remove_extent<_Tp[]>
1996 {
typedef _Tp type; };
1999 template<
typename _Tp>
2001 {
typedef _Tp type; };
2003 template<
typename _Tp, std::
size_t _Size>
2005 {
typedef typename remove_all_extents<_Tp>::type type; };
2007 template<
typename _Tp>
2008 struct remove_all_extents<_Tp[]>
2009 {
typedef typename remove_all_extents<_Tp>::type type; };
2011 #if __cplusplus > 201103L
2013 template<
typename _Tp>
2017 template<
typename _Tp>
2023 template<
typename _Tp,
typename>
2024 struct __remove_pointer_helper
2025 {
typedef _Tp type; };
2027 template<
typename _Tp,
typename _Up>
2028 struct __remove_pointer_helper<_Tp, _Up*>
2029 {
typedef _Up type; };
2032 template<
typename _Tp>
2034 :
public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
2037 template<
typename _Tp,
bool = __or_<__is_referenceable<_Tp>,
2038 is_
void<_Tp>>::value>
2039 struct __add_pointer_helper
2040 {
typedef _Tp type; };
2042 template<
typename _Tp>
2043 struct __add_pointer_helper<_Tp, true>
2044 {
typedef typename remove_reference<_Tp>::type* type; };
2047 template<
typename _Tp>
2049 :
public __add_pointer_helper<_Tp>
2052 #if __cplusplus > 201103L
2054 template<
typename _Tp>
2058 template<
typename _Tp>
2062 template<std::
size_t _Len>
2063 struct __aligned_storage_msa
2067 unsigned char __data[_Len];
2068 struct __attribute__((__aligned__)) { } __align;
2082 template<std::size_t _Len, std::size_t _Align =
2083 __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
2088 unsigned char __data[_Len];
2089 struct __attribute__((__aligned__((_Align)))) { } __align;
2093 template <
typename... _Types>
2094 struct __strictest_alignment
2096 static const size_t _S_alignment = 0;
2097 static const size_t _S_size = 0;
2100 template <
typename _Tp,
typename... _Types>
2101 struct __strictest_alignment<_Tp, _Types...>
2103 static const size_t _S_alignment =
2104 alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
2105 ?
alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
2106 static const size_t _S_size =
2107 sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
2108 ?
sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
2121 template <
size_t _Len,
typename... _Types>
2125 static_assert(
sizeof...(_Types) != 0,
"At least one type is required");
2127 using __strictest = __strictest_alignment<_Types...>;
2128 static const size_t _S_len = _Len > __strictest::_S_size
2129 ? _Len : __strictest::_S_size;
2132 static const size_t alignment_value = __strictest::_S_alignment;
2137 template <
size_t _Len,
typename... _Types>
2138 const size_t aligned_union<_Len, _Types...>::alignment_value;
2144 template<
typename _Up,
2147 struct __decay_selector;
2150 template<
typename _Up>
2151 struct __decay_selector<_Up, false, false>
2152 {
typedef __remove_cv_t<_Up> __type; };
2154 template<
typename _Up>
2155 struct __decay_selector<_Up, true, false>
2156 {
typedef typename remove_extent<_Up>::type* __type; };
2158 template<
typename _Up>
2159 struct __decay_selector<_Up, false, true>
2160 {
typedef typename add_pointer<_Up>::type __type; };
2164 template<
typename _Tp>
2167 typedef typename remove_reference<_Tp>::type __remove_type;
2170 typedef typename __decay_selector<__remove_type>::__type type;
2176 template<
typename _Tp>
2177 struct __strip_reference_wrapper
2182 template<
typename _Tp>
2183 struct __strip_reference_wrapper<reference_wrapper<_Tp> >
2185 typedef _Tp& __type;
2189 template<
typename _Tp>
2190 using __decay_t =
typename decay<_Tp>::type;
2192 template<
typename _Tp>
2193 using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
2198 template<
bool,
typename _Tp =
void>
2203 template<
typename _Tp>
2205 {
typedef _Tp type; };
2210 template<
bool _Cond,
typename _Tp =
void>
2211 using __enable_if_t =
typename enable_if<_Cond, _Tp>::type;
2214 template<
typename... _Cond>
2215 using _Require = __enable_if_t<__and_<_Cond...>::value>;
2218 template<
typename _Tp>
2219 using __remove_cvref_t
2220 =
typename remove_cv<typename remove_reference<_Tp>::type>::type;
2225 template<
bool _Cond,
typename _Iftrue,
typename _Iffalse>
2227 {
typedef _Iftrue type; };
2230 template<
typename _Iftrue,
typename _Iffalse>
2232 {
typedef _Iffalse type; };
2235 template<
typename... _Tp>
2241 struct __do_common_type_impl
2243 template<
typename _Tp,
typename _Up>
2245 = decltype(
true ? std::declval<_Tp>() : std::declval<_Up>());
2249 template<
typename _Tp,
typename _Up>
2250 static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
2253 #if __cplusplus > 201703L
2256 template<
typename _Tp,
typename _Up>
2257 static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>>
2261 template<
typename,
typename>
2262 static __failure_type
2265 template<
typename _Tp,
typename _Up>
2266 static decltype(_S_test_2<_Tp, _Up>(0))
2276 template<
typename _Tp0>
2282 template<
typename _Tp1,
typename _Tp2,
2283 typename _Dp1 = __decay_t<_Tp1>,
typename _Dp2 = __decay_t<_Tp2>>
2284 struct __common_type_impl
2288 using type = common_type<_Dp1, _Dp2>;
2291 template<
typename _Tp1,
typename _Tp2>
2292 struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
2293 :
private __do_common_type_impl
2297 using type = decltype(_S_test<_Tp1, _Tp2>(0));
2301 template<
typename _Tp1,
typename _Tp2>
2302 struct common_type<_Tp1, _Tp2>
2303 :
public __common_type_impl<_Tp1, _Tp2>::type
2306 template<
typename...>
2307 struct __common_type_pack
2310 template<
typename,
typename,
typename =
void>
2311 struct __common_type_fold;
2314 template<
typename _Tp1,
typename _Tp2,
typename... _Rp>
2315 struct common_type<_Tp1, _Tp2, _Rp...>
2316 :
public __common_type_fold<common_type<_Tp1, _Tp2>,
2317 __common_type_pack<_Rp...>>
2323 template<
typename _CTp,
typename... _Rp>
2324 struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
2325 __void_t<typename _CTp::type>>
2326 :
public common_type<typename _CTp::type, _Rp...>
2330 template<
typename _CTp,
typename _Rp>
2331 struct __common_type_fold<_CTp, _Rp, void>
2334 template<typename _Tp, bool = is_enum<_Tp>::value>
2335 struct __underlying_type_impl
2337 using type = __underlying_type(_Tp);
2340 template<
typename _Tp>
2341 struct __underlying_type_impl<_Tp, false>
2346 template<
typename _Tp>
2348 :
public __underlying_type_impl<_Tp>
2352 template<
typename _Tp>
2353 struct __declval_protector
2355 static const bool __stop =
false;
2363 template<
typename _Tp>
2364 auto declval() noexcept -> decltype(__declval<_Tp>(0))
2366 static_assert(__declval_protector<_Tp>::__stop,
2367 "declval() must not be used!");
2368 return __declval<_Tp>(0);
2372 template<
typename _Signature>
2377 #define __cpp_lib_result_of_sfinae 201210
2380 struct __invoke_memfun_ref { };
2381 struct __invoke_memfun_deref { };
2382 struct __invoke_memobj_ref { };
2383 struct __invoke_memobj_deref { };
2384 struct __invoke_other { };
2387 template<
typename _Tp,
typename _Tag>
2388 struct __result_of_success : __success_type<_Tp>
2389 {
using __invoke_type = _Tag; };
2392 struct __result_of_memfun_ref_impl
2394 template<
typename _Fp,
typename _Tp1,
typename... _Args>
2395 static __result_of_success<decltype(
2396 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
2397 ), __invoke_memfun_ref> _S_test(
int);
2399 template<
typename...>
2400 static __failure_type _S_test(...);
2403 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2404 struct __result_of_memfun_ref
2405 :
private __result_of_memfun_ref_impl
2407 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2411 struct __result_of_memfun_deref_impl
2413 template<
typename _Fp,
typename _Tp1,
typename... _Args>
2414 static __result_of_success<decltype(
2415 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
2416 ), __invoke_memfun_deref> _S_test(
int);
2418 template<
typename...>
2419 static __failure_type _S_test(...);
2422 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2423 struct __result_of_memfun_deref
2424 :
private __result_of_memfun_deref_impl
2426 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2430 struct __result_of_memobj_ref_impl
2432 template<
typename _Fp,
typename _Tp1>
2433 static __result_of_success<decltype(
2434 std::declval<_Tp1>().*std::declval<_Fp>()
2435 ), __invoke_memobj_ref> _S_test(
int);
2437 template<
typename,
typename>
2438 static __failure_type _S_test(...);
2441 template<
typename _MemPtr,
typename _Arg>
2442 struct __result_of_memobj_ref
2443 :
private __result_of_memobj_ref_impl
2445 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2449 struct __result_of_memobj_deref_impl
2451 template<
typename _Fp,
typename _Tp1>
2452 static __result_of_success<decltype(
2453 (*std::declval<_Tp1>()).*std::declval<_Fp>()
2454 ), __invoke_memobj_deref> _S_test(
int);
2456 template<
typename,
typename>
2457 static __failure_type _S_test(...);
2460 template<
typename _MemPtr,
typename _Arg>
2461 struct __result_of_memobj_deref
2462 :
private __result_of_memobj_deref_impl
2464 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2467 template<typename _MemPtr, typename _Arg>
2468 struct __result_of_memobj;
2470 template<typename _Res, typename _Class, typename _Arg>
2471 struct __result_of_memobj<_Res _Class::*, _Arg>
2473 typedef __remove_cvref_t<_Arg> _Argval;
2474 typedef _Res _Class::* _MemPtr;
2475 typedef typename conditional<__or_<is_same<_Argval, _Class>,
2476 is_base_of<_Class, _Argval>>::value,
2477 __result_of_memobj_ref<_MemPtr, _Arg>,
2478 __result_of_memobj_deref<_MemPtr, _Arg>
2482 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2483 struct __result_of_memfun;
2485 template<
typename _Res,
typename _Class,
typename _Arg,
typename... _Args>
2486 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
2488 typedef typename remove_reference<_Arg>::type _Argval;
2489 typedef _Res _Class::* _MemPtr;
2490 typedef typename conditional<is_base_of<_Class, _Argval>::value,
2491 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
2492 __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
2501 template<
typename _Tp,
typename _Up = __remove_cvref_t<_Tp>>
2507 template<
typename _Tp,
typename _Up>
2508 struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
2513 template<bool, bool,
typename _Functor,
typename... _ArgTypes>
2514 struct __result_of_impl
2516 typedef __failure_type type;
2519 template<
typename _MemPtr,
typename _Arg>
2520 struct __result_of_impl<true, false, _MemPtr, _Arg>
2521 :
public __result_of_memobj<__decay_t<_MemPtr>,
2522 typename __inv_unwrap<_Arg>::type>
2525 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2526 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
2527 :
public __result_of_memfun<__decay_t<_MemPtr>,
2528 typename __inv_unwrap<_Arg>::type, _Args...>
2532 struct __result_of_other_impl
2534 template<
typename _Fn,
typename... _Args>
2535 static __result_of_success<decltype(
2536 std::declval<_Fn>()(std::declval<_Args>()...)
2537 ), __invoke_other> _S_test(
int);
2539 template<
typename...>
2540 static __failure_type _S_test(...);
2543 template<
typename _Functor,
typename... _ArgTypes>
2544 struct __result_of_impl<false, false, _Functor, _ArgTypes...>
2545 :
private __result_of_other_impl
2547 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2551 template<typename _Functor, typename... _ArgTypes>
2552 struct __invoke_result
2553 : public __result_of_impl<
2554 is_member_object_pointer<
2555 typename remove_reference<_Functor>::type
2557 is_member_function_pointer<
2558 typename remove_reference<_Functor>::type
2560 _Functor, _ArgTypes...
2565 template<
typename _Functor,
typename... _ArgTypes>
2566 struct result_of<_Functor(_ArgTypes...)>
2567 :
public __invoke_result<_Functor, _ArgTypes...>
2570 #if __cplusplus >= 201402L
2572 template<
size_t _Len,
size_t _Align =
2573 __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
2576 template <
size_t _Len,
typename... _Types>
2577 using aligned_union_t =
typename aligned_union<_Len, _Types...>::type;
2580 template<
typename _Tp>
2584 template<
bool _Cond,
typename _Tp =
void>
2588 template<
bool _Cond,
typename _Iftrue,
typename _Iffalse>
2592 template<
typename... _Tp>
2596 template<
typename _Tp>
2600 template<
typename _Tp>
2604 #if __cplusplus >= 201703L || !defined(__STRICT_ANSI__)
2605 #define __cpp_lib_void_t 201411
2613 template<
typename _Default,
typename _AlwaysVoid,
2614 template<
typename...>
class _Op,
typename... _Args>
2618 using type = _Default;
2622 template<
typename _Default,
template<
typename...>
class _Op,
2624 struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
2627 using type = _Op<_Args...>;
2631 template<
typename _Default,
template<
typename...>
class _Op,
2633 using __detected_or = __detector<_Default, void, _Op, _Args...>;
2636 template<
typename _Default,
template<
typename...>
class _Op,
2638 using __detected_or_t
2639 =
typename __detected_or<_Default, _Op, _Args...>::type;
2645 #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \
2646 template<typename _Tp, typename = __void_t<>> \
2647 struct __has_##_NTYPE \
2650 template<typename _Tp> \
2651 struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> \
2655 template <
typename _Tp>
2656 struct __is_swappable;
2658 template <
typename _Tp>
2659 struct __is_nothrow_swappable;
2665 template<
typename... _Tps>
2666 struct __is_tuple_like_impl<tuple<_Tps...>> :
true_type
2670 template<
typename _Tp>
2671 struct __is_tuple_like
2672 :
public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
2676 template<
typename _Tp>
2677 _GLIBCXX20_CONSTEXPR
2679 _Require<__not_<__is_tuple_like<_Tp>>,
2680 is_move_constructible<_Tp>,
2681 is_move_assignable<_Tp>>
2683 noexcept(__and_<is_nothrow_move_constructible<_Tp>,
2684 is_nothrow_move_assignable<_Tp>>::value);
2686 template<
typename _Tp,
size_t _Nm>
2687 _GLIBCXX20_CONSTEXPR
2689 __enable_if_t<__is_swappable<_Tp>::value>
2690 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
2691 noexcept(__is_nothrow_swappable<_Tp>::value);
2694 namespace __swappable_details {
2697 struct __do_is_swappable_impl
2699 template<
typename _Tp,
typename
2700 = decltype(
swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
2707 struct __do_is_nothrow_swappable_impl
2709 template<
typename _Tp>
2710 static __bool_constant<
2711 noexcept(
swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2720 template<
typename _Tp>
2721 struct __is_swappable_impl
2722 :
public __swappable_details::__do_is_swappable_impl
2724 typedef decltype(__test<_Tp>(0)) type;
2727 template<typename _Tp>
2728 struct __is_nothrow_swappable_impl
2729 : public __swappable_details::__do_is_nothrow_swappable_impl
2731 typedef decltype(__test<_Tp>(0)) type;
2734 template<typename _Tp>
2735 struct __is_swappable
2736 : public __is_swappable_impl<_Tp>::type
2739 template<
typename _Tp>
2740 struct __is_nothrow_swappable
2741 :
public __is_nothrow_swappable_impl<_Tp>::type
2745 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__)
2746 #define __cpp_lib_is_swappable 201603
2750 template<
typename _Tp>
2752 :
public __is_swappable_impl<_Tp>::type
2754 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2755 "template argument must be a complete class or an unbounded array");
2759 template<
typename _Tp>
2761 :
public __is_nothrow_swappable_impl<_Tp>::type
2763 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2764 "template argument must be a complete class or an unbounded array");
2767 #if __cplusplus >= 201402L
2769 template<
typename _Tp>
2774 template<
typename _Tp>
2780 namespace __swappable_with_details {
2783 struct __do_is_swappable_with_impl
2785 template<
typename _Tp,
typename _Up,
typename
2786 = decltype(
swap(std::declval<_Tp>(), std::declval<_Up>())),
2788 = decltype(
swap(std::declval<_Up>(), std::declval<_Tp>()))>
2791 template<
typename,
typename>
2795 struct __do_is_nothrow_swappable_with_impl
2797 template<
typename _Tp,
typename _Up>
2798 static __bool_constant<
2799 noexcept(
swap(std::declval<_Tp>(), std::declval<_Up>()))
2801 noexcept(
swap(std::declval<_Up>(), std::declval<_Tp>()))
2804 template<
typename,
typename>
2810 template<
typename _Tp,
typename _Up>
2811 struct __is_swappable_with_impl
2812 :
public __swappable_with_details::__do_is_swappable_with_impl
2814 typedef decltype(__test<_Tp, _Up>(0)) type;
2818 template<typename _Tp>
2819 struct __is_swappable_with_impl<_Tp&, _Tp&>
2820 : public __swappable_details::__do_is_swappable_impl
2822 typedef decltype(__test<_Tp&>(0)) type;
2825 template<typename _Tp, typename _Up>
2826 struct __is_nothrow_swappable_with_impl
2827 : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
2829 typedef decltype(__test<_Tp, _Up>(0)) type;
2833 template<typename _Tp>
2834 struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
2835 : public __swappable_details::__do_is_nothrow_swappable_impl
2837 typedef decltype(__test<_Tp&>(0)) type;
2842 template<typename _Tp, typename _Up>
2844 : public __is_swappable_with_impl<_Tp, _Up>::type
2846 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2847 "first template argument must be a complete class or an unbounded array");
2848 static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}),
2849 "second template argument must be a complete class or an unbounded array");
2853 template<
typename _Tp,
typename _Up>
2855 :
public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
2857 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2858 "first template argument must be a complete class or an unbounded array");
2859 static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}),
2860 "second template argument must be a complete class or an unbounded array");
2863 #if __cplusplus >= 201402L
2865 template<
typename _Tp,
typename _Up>
2870 template<
typename _Tp,
typename _Up>
2882 template<
typename _Result,
typename _Ret,
2887 template<
typename _Result,
typename _Ret>
2888 struct __is_invocable_impl<_Result, _Ret,
2890 __void_t<typename _Result::type>>
2894 #pragma GCC diagnostic push
2895 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
2897 template<
typename _Result,
typename _Ret>
2898 struct __is_invocable_impl<_Result, _Ret,
2900 __void_t<typename _Result::type>>
2905 static typename _Result::type _S_get();
2907 template<
typename _Tp>
2908 static void _S_conv(_Tp);
2911 template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
2915 template<
typename _Tp>
2920 using type = decltype(_S_test<_Ret>(1));
2922 #pragma GCC diagnostic pop
2924 template<
typename _Fn,
typename... _ArgTypes>
2925 struct __is_invocable
2926 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2929 template<
typename _Fn,
typename _Tp,
typename... _Args>
2930 constexpr
bool __call_is_nt(__invoke_memfun_ref)
2932 using _Up =
typename __inv_unwrap<_Tp>::type;
2933 return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
2934 std::declval<_Args>()...));
2937 template<
typename _Fn,
typename _Tp,
typename... _Args>
2938 constexpr
bool __call_is_nt(__invoke_memfun_deref)
2940 return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
2941 std::declval<_Args>()...));
2944 template<
typename _Fn,
typename _Tp>
2945 constexpr
bool __call_is_nt(__invoke_memobj_ref)
2947 using _Up =
typename __inv_unwrap<_Tp>::type;
2948 return noexcept(std::declval<_Up>().*std::declval<_Fn>());
2951 template<
typename _Fn,
typename _Tp>
2952 constexpr
bool __call_is_nt(__invoke_memobj_deref)
2954 return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
2957 template<
typename _Fn,
typename... _Args>
2958 constexpr
bool __call_is_nt(__invoke_other)
2960 return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
2963 template<
typename _Result,
typename _Fn,
typename... _Args>
2964 struct __call_is_nothrow
2966 std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
2970 template<
typename _Fn,
typename... _Args>
2971 using __call_is_nothrow_
2972 = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
2975 template<
typename _Fn,
typename... _Args>
2976 struct __is_nothrow_invocable
2977 : __and_<__is_invocable<_Fn, _Args...>,
2978 __call_is_nothrow_<_Fn, _Args...>>::type
2981 #pragma GCC diagnostic push
2982 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
2983 struct __nonesuchbase {};
2984 struct __nonesuch :
private __nonesuchbase {
2985 ~__nonesuch() =
delete;
2986 __nonesuch(__nonesuch
const&) =
delete;
2987 void operator=(__nonesuch
const&) =
delete;
2989 #pragma GCC diagnostic pop
2992 #if __cplusplus >= 201703L
2993 # define __cpp_lib_is_invocable 201703
2996 template<
typename _Functor,
typename... _ArgTypes>
2998 :
public __invoke_result<_Functor, _ArgTypes...>
3000 static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}),
3001 "_Functor must be a complete class or an unbounded array");
3002 static_assert((std::__is_complete_or_unbounded(
3003 __type_identity<_ArgTypes>{}) && ...),
3004 "each argument type must be a complete class or an unbounded array");
3008 template<
typename _Fn,
typename... _Args>
3012 template<
typename _Fn,
typename... _ArgTypes>
3014 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
3016 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3017 "_Fn must be a complete class or an unbounded array");
3018 static_assert((std::__is_complete_or_unbounded(
3019 __type_identity<_ArgTypes>{}) && ...),
3020 "each argument type must be a complete class or an unbounded array");
3024 template<
typename _Ret,
typename _Fn,
typename... _ArgTypes>
3026 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
3028 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3029 "_Fn must be a complete class or an unbounded array");
3030 static_assert((std::__is_complete_or_unbounded(
3031 __type_identity<_ArgTypes>{}) && ...),
3032 "each argument type must be a complete class or an unbounded array");
3033 static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
3034 "_Ret must be a complete class or an unbounded array");
3038 template<
typename _Fn,
typename... _ArgTypes>
3040 : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
3041 __call_is_nothrow_<_Fn, _ArgTypes...>>::type
3043 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3044 "_Fn must be a complete class or an unbounded array");
3045 static_assert((std::__is_complete_or_unbounded(
3046 __type_identity<_ArgTypes>{}) && ...),
3047 "each argument type must be a complete class or an unbounded array");
3051 template<
typename _Result,
typename _Ret,
typename =
void>
3052 struct __is_nt_invocable_impl :
false_type { };
3054 template<
typename _Result,
typename _Ret>
3055 struct __is_nt_invocable_impl<_Result, _Ret,
3056 __void_t<typename _Result::type>>
3057 : __or_<is_void<_Ret>,
3058 __is_nothrow_convertible<typename _Result::type, _Ret>>
3063 template<
typename _Ret,
typename _Fn,
typename... _ArgTypes>
3065 : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
3066 __call_is_nothrow_<_Fn, _ArgTypes...>>::type
3068 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3069 "_Fn must be a complete class or an unbounded array");
3070 static_assert((std::__is_complete_or_unbounded(
3071 __type_identity<_ArgTypes>{}) && ...),
3072 "each argument type must be a complete class or an unbounded array");
3073 static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
3074 "_Ret must be a complete class or an unbounded array");
3078 #if __cplusplus >= 201703L
3079 # define __cpp_lib_type_trait_variable_templates 201510L
3093 template <
typename _Tp>
3095 template <
typename _Tp>
3097 template <
typename _Tp>
3099 template <
typename _Tp>
3101 template <
typename _Tp>
3103 template <
typename _Tp>
3105 template <
typename _Tp>
3106 inline constexpr
bool is_lvalue_reference_v =
3108 template <
typename _Tp>
3109 inline constexpr
bool is_rvalue_reference_v =
3111 template <
typename _Tp>
3112 inline constexpr
bool is_member_object_pointer_v =
3114 template <
typename _Tp>
3115 inline constexpr
bool is_member_function_pointer_v =
3117 template <
typename _Tp>
3119 template <
typename _Tp>
3121 template <
typename _Tp>
3123 template <
typename _Tp>
3125 template <
typename _Tp>
3127 template <
typename _Tp>
3129 template <
typename _Tp>
3131 template <
typename _Tp>
3133 template <
typename _Tp>
3135 template <
typename _Tp>
3137 template <
typename _Tp>
3139 template <
typename _Tp>
3141 template <
typename _Tp>
3143 template <
typename _Tp>
3145 template <
typename _Tp>
3146 inline constexpr
bool is_trivially_copyable_v =
3148 template <
typename _Tp>
3150 #pragma GCC diagnostic push
3151 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3152 template <
typename _Tp>
3153 _GLIBCXX20_DEPRECATED(
"use is_standard_layout_v && is_trivial_v instead")
3154 inline constexpr
bool is_pod_v =
is_pod<_Tp>::value;
3155 template <typename _Tp>
3156 _GLIBCXX17_DEPRECATED
3157 inline constexpr
bool is_literal_type_v =
is_literal_type<_Tp>::value;
3158 #pragma GCC diagnostic pop
3159 template <
typename _Tp>
3161 template <
typename _Tp>
3163 template <
typename _Tp>
3165 template <
typename _Tp>
3167 template <
typename _Tp>
3169 template <
typename _Tp>
3171 template <
typename _Tp,
typename... _Args>
3172 inline constexpr
bool is_constructible_v =
3174 template <
typename _Tp>
3175 inline constexpr
bool is_default_constructible_v =
3177 template <
typename _Tp>
3178 inline constexpr
bool is_copy_constructible_v =
3180 template <
typename _Tp>
3181 inline constexpr
bool is_move_constructible_v =
3183 template <
typename _Tp,
typename _Up>
3185 template <
typename _Tp>
3187 template <
typename _Tp>
3189 template <
typename _Tp>
3191 template <
typename _Tp,
typename... _Args>
3192 inline constexpr
bool is_trivially_constructible_v =
3194 template <
typename _Tp>
3195 inline constexpr
bool is_trivially_default_constructible_v =
3197 template <
typename _Tp>
3198 inline constexpr
bool is_trivially_copy_constructible_v =
3200 template <
typename _Tp>
3201 inline constexpr
bool is_trivially_move_constructible_v =
3203 template <
typename _Tp,
typename _Up>
3204 inline constexpr
bool is_trivially_assignable_v =
3206 template <
typename _Tp>
3207 inline constexpr
bool is_trivially_copy_assignable_v =
3209 template <
typename _Tp>
3210 inline constexpr
bool is_trivially_move_assignable_v =
3212 template <
typename _Tp>
3213 inline constexpr
bool is_trivially_destructible_v =
3215 template <
typename _Tp,
typename... _Args>
3216 inline constexpr
bool is_nothrow_constructible_v =
3218 template <
typename _Tp>
3219 inline constexpr
bool is_nothrow_default_constructible_v =
3221 template <
typename _Tp>
3222 inline constexpr
bool is_nothrow_copy_constructible_v =
3224 template <
typename _Tp>
3225 inline constexpr
bool is_nothrow_move_constructible_v =
3227 template <
typename _Tp,
typename _Up>
3228 inline constexpr
bool is_nothrow_assignable_v =
3230 template <
typename _Tp>
3231 inline constexpr
bool is_nothrow_copy_assignable_v =
3233 template <
typename _Tp>
3234 inline constexpr
bool is_nothrow_move_assignable_v =
3236 template <
typename _Tp>
3237 inline constexpr
bool is_nothrow_destructible_v =
3239 template <
typename _Tp>
3240 inline constexpr
bool has_virtual_destructor_v =
3242 template <
typename _Tp>
3244 template <
typename _Tp>
3246 template <
typename _Tp,
unsigned _Idx = 0>
3248 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME
3249 template <
typename _Tp,
typename _Up>
3250 inline constexpr
bool is_same_v = __is_same(_Tp, _Up);
3252 template <
typename _Tp,
typename _Up>
3255 template <
typename _Base,
typename _Derived>
3257 template <
typename _From,
typename _To>
3259 template<
typename _Fn,
typename... _Args>
3260 inline constexpr
bool is_invocable_v =
is_invocable<_Fn, _Args...>::value;
3261 template<
typename _Fn,
typename... _Args>
3262 inline constexpr
bool is_nothrow_invocable_v
3264 template<
typename _Ret,
typename _Fn,
typename... _Args>
3265 inline constexpr
bool is_invocable_r_v
3267 template<
typename _Ret,
typename _Fn,
typename... _Args>
3268 inline constexpr
bool is_nothrow_invocable_r_v
3272 #ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
3273 # define __cpp_lib_has_unique_object_representations 201606
3275 template<
typename _Tp>
3276 struct has_unique_object_representations
3278 remove_cv_t<remove_all_extents_t<_Tp>>
3281 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
3282 "template argument must be a complete class or an unbounded array");
3286 template<
typename _Tp>
3287 inline constexpr
bool has_unique_object_representations_v
3288 = has_unique_object_representations<_Tp>::value;
3291 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
3292 # define __cpp_lib_is_aggregate 201703
3294 template<
typename _Tp>
3300 template<
typename _Tp>
3301 inline constexpr
bool is_aggregate_v = is_aggregate<_Tp>::value;
3305 #if __cplusplus > 201703L
3306 #define __cpp_lib_remove_cvref 201711L
3309 template<
typename _Tp>
3314 template<
typename _Tp>
3315 struct remove_cvref<_Tp&>
3319 template<
typename _Tp>
3320 struct remove_cvref<_Tp&&>
3324 template<
typename _Tp>
3325 using remove_cvref_t =
typename remove_cvref<_Tp>::type;
3327 #define __cpp_lib_type_identity 201806L
3329 template<
typename _Tp>
3330 struct type_identity {
using type = _Tp; };
3332 template<
typename _Tp>
3333 using type_identity_t =
typename type_identity<_Tp>::type;
3335 #define __cpp_lib_unwrap_ref 201811L
3338 template<
typename _Tp>
3339 struct unwrap_reference {
using type = _Tp; };
3341 template<
typename _Tp>
3342 struct unwrap_reference<reference_wrapper<_Tp>> {
using type = _Tp&; };
3344 template<
typename _Tp>
3345 using unwrap_reference_t =
typename unwrap_reference<_Tp>::type;
3348 template<
typename _Tp>
3349 struct unwrap_ref_decay {
using type = unwrap_reference_t<decay_t<_Tp>>; };
3351 template<
typename _Tp>
3352 using unwrap_ref_decay_t =
typename unwrap_ref_decay<_Tp>::type;
3354 #define __cpp_lib_bounded_array_traits 201902L
3357 template<
typename _Tp>
3358 struct is_bounded_array
3359 :
public __is_array_known_bounds<_Tp>
3363 template<
typename _Tp>
3364 struct is_unbounded_array
3365 :
public __is_array_unknown_bounds<_Tp>
3369 template<
typename _Tp>
3370 inline constexpr
bool is_bounded_array_v
3371 = is_bounded_array<_Tp>::value;
3374 template<
typename _Tp>
3375 inline constexpr
bool is_unbounded_array_v
3376 = is_unbounded_array<_Tp>::value;
3378 #if __cplusplus > 202002L
3379 #define __cpp_lib_is_scoped_enum 202011L
3384 template<
typename _Tp>
3385 struct is_scoped_enum
3389 template<
typename _Tp>
3390 requires __is_enum(_Tp)
3391 && requires(_Tp __t) { __t = __t; }
3392 struct is_scoped_enum<_Tp>
3393 :
bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
3398 template<
typename _Tp>
3399 requires __is_enum(_Tp)
3400 && requires(_Tp __t) { __t = __t; }
3401 struct is_scoped_enum<const _Tp>
3402 :
bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
3408 template<
typename _Tp>
3409 inline constexpr
bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
3412 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
3414 #define __cpp_lib_is_constant_evaluated 201811L
3417 constexpr
inline bool
3418 is_constant_evaluated() noexcept
3419 {
return __builtin_is_constant_evaluated(); }
3424 template<
typename _From,
typename _To>
3425 using __copy_cv =
typename __match_cv_qualifiers<_From, _To>::__type;
3427 template<
typename _Xp,
typename _Yp>
3429 = decltype(
false ?
declval<_Xp(&)()>()() :
declval<_Yp(&)()>()());
3431 template<
typename _Ap,
typename _Bp,
typename =
void>
3432 struct __common_ref_impl
3436 template<
typename _Ap,
typename _Bp>
3437 using __common_ref =
typename __common_ref_impl<_Ap, _Bp>::type;
3440 template<
typename _Xp,
typename _Yp>
3441 using __condres_cvref
3442 = __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>;
3445 template<
typename _Xp,
typename _Yp>
3446 struct __common_ref_impl<_Xp&, _Yp&, __void_t<__condres_cvref<_Xp, _Yp>>>
3447 : enable_if<is_reference_v<__condres_cvref<_Xp, _Yp>>,
3448 __condres_cvref<_Xp, _Yp>>
3452 template<
typename _Xp,
typename _Yp>
3453 using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&;
3456 template<
typename _Xp,
typename _Yp>
3457 struct __common_ref_impl<_Xp&&, _Yp&&,
3458 _Require<is_convertible<_Xp&&, __common_ref_C<_Xp, _Yp>>,
3459 is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>>
3460 {
using type = __common_ref_C<_Xp, _Yp>; };
3463 template<
typename _Xp,
typename _Yp>
3464 using __common_ref_D = __common_ref<const _Xp&, _Yp&>;
3467 template<
typename _Xp,
typename _Yp>
3468 struct __common_ref_impl<_Xp&&, _Yp&,
3469 _Require<is_convertible<_Xp&&, __common_ref_D<_Xp, _Yp>>>>
3470 {
using type = __common_ref_D<_Xp, _Yp>; };
3473 template<
typename _Xp,
typename _Yp>
3474 struct __common_ref_impl<_Xp&, _Yp&&>
3475 : __common_ref_impl<_Yp&&, _Xp&>
3479 template<
typename _Tp,
typename _Up,
3480 template<
typename>
class _TQual,
template<
typename>
class _UQual>
3481 struct basic_common_reference
3485 template<
typename _Tp>
3487 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>; };
3489 template<
typename _Tp>
3491 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>&; };
3493 template<
typename _Tp>
3494 struct __xref<_Tp&&>
3495 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>&&; };
3497 template<
typename _Tp1,
typename _Tp2>
3498 using __basic_common_ref
3499 =
typename basic_common_reference<remove_cvref_t<_Tp1>,
3500 remove_cvref_t<_Tp2>,
3501 __xref<_Tp1>::template __type,
3502 __xref<_Tp2>::template __type>::type;
3505 template<
typename... _Tp>
3506 struct common_reference;
3508 template<
typename... _Tp>
3509 using common_reference_t =
typename common_reference<_Tp...>::type;
3513 struct common_reference<>
3517 template<
typename _Tp0>
3518 struct common_reference<_Tp0>
3519 {
using type = _Tp0; };
3522 template<
typename _Tp1,
typename _Tp2,
int _Bullet = 1,
typename =
void>
3523 struct __common_reference_impl
3524 : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
3528 template<
typename _Tp1,
typename _Tp2>
3529 struct common_reference<_Tp1, _Tp2>
3530 : __common_reference_impl<_Tp1, _Tp2>
3534 template<
typename _Tp1,
typename _Tp2>
3535 struct __common_reference_impl<_Tp1&, _Tp2&, 1,
3536 void_t<__common_ref<_Tp1&, _Tp2&>>>
3537 {
using type = __common_ref<_Tp1&, _Tp2&>; };
3539 template<
typename _Tp1,
typename _Tp2>
3540 struct __common_reference_impl<_Tp1&&, _Tp2&&, 1,
3541 void_t<__common_ref<_Tp1&&, _Tp2&&>>>
3542 {
using type = __common_ref<_Tp1&&, _Tp2&&>; };
3544 template<
typename _Tp1,
typename _Tp2>
3545 struct __common_reference_impl<_Tp1&, _Tp2&&, 1,
3546 void_t<__common_ref<_Tp1&, _Tp2&&>>>
3547 {
using type = __common_ref<_Tp1&, _Tp2&&>; };
3549 template<
typename _Tp1,
typename _Tp2>
3550 struct __common_reference_impl<_Tp1&&, _Tp2&, 1,
3551 void_t<__common_ref<_Tp1&&, _Tp2&>>>
3552 {
using type = __common_ref<_Tp1&&, _Tp2&>; };
3555 template<
typename _Tp1,
typename _Tp2>
3556 struct __common_reference_impl<_Tp1, _Tp2, 2,
3557 void_t<__basic_common_ref<_Tp1, _Tp2>>>
3558 {
using type = __basic_common_ref<_Tp1, _Tp2>; };
3561 template<
typename _Tp1,
typename _Tp2>
3562 struct __common_reference_impl<_Tp1, _Tp2, 3,
3563 void_t<__cond_res<_Tp1, _Tp2>>>
3564 {
using type = __cond_res<_Tp1, _Tp2>; };
3567 template<
typename _Tp1,
typename _Tp2>
3568 struct __common_reference_impl<_Tp1, _Tp2, 4,
3570 {
using type = common_type_t<_Tp1, _Tp2>; };
3573 template<
typename _Tp1,
typename _Tp2>
3574 struct __common_reference_impl<_Tp1, _Tp2, 5, void>
3578 template<
typename _Tp1,
typename _Tp2,
typename... _Rest>
3579 struct common_reference<_Tp1, _Tp2, _Rest...>
3580 : __common_type_fold<common_reference<_Tp1, _Tp2>,
3581 __common_type_pack<_Rest...>>
3585 template<
typename _Tp1,
typename _Tp2,
typename... _Rest>
3586 struct __common_type_fold<common_reference<_Tp1, _Tp2>,
3587 __common_type_pack<_Rest...>,
3588 void_t<common_reference_t<_Tp1, _Tp2>>>
3589 :
public common_reference<common_reference_t<_Tp1, _Tp2>, _Rest...>
3597 _GLIBCXX_END_NAMESPACE_VERSION
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
typename result_of< _Tp >::type result_of_t
Alias template for result_of.
constexpr bool is_nothrow_swappable_v
is_nothrow_swappable_v
typename add_rvalue_reference< _Tp >::type add_rvalue_reference_t
Alias template for add_rvalue_reference.
integral_constant< bool, __v > bool_constant
Alias template for compile-time boolean constant types.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
void void_t
A metafunction that always yields void, used for detecting valid types.
constexpr bool is_swappable_v
is_swappable_v
typename aligned_storage< _Len, _Align >::type aligned_storage_t
Alias template for aligned_storage.
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
typename remove_cv< _Tp >::type remove_cv_t
Alias template for remove_cv.
typename remove_all_extents< _Tp >::type remove_all_extents_t
Alias template for remove_all_extents.
typename common_type< _Tp... >::type common_type_t
Alias template for common_type.
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
typename add_const< _Tp >::type add_const_t
Alias template for add_const.
typename remove_pointer< _Tp >::type remove_pointer_t
Alias template for remove_pointer.
typename add_cv< _Tp >::type add_cv_t
Alias template for add_cv.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
constexpr bool is_swappable_with_v
is_swappable_with_v
typename add_volatile< _Tp >::type add_volatile_t
Alias template for add_volatile.
typename remove_volatile< _Tp >::type remove_volatile_t
Alias template for remove_volatile.
typename add_lvalue_reference< _Tp >::type add_lvalue_reference_t
Alias template for add_lvalue_reference.
typename add_pointer< _Tp >::type add_pointer_t
Alias template for add_pointer.
typename remove_extent< _Tp >::type remove_extent_t
Alias template for remove_extent.
typename underlying_type< _Tp >::type underlying_type_t
Alias template for underlying_type.
typename decay< _Tp >::type decay_t
Alias template for decay.
typename make_signed< _Tp >::type make_signed_t
Alias template for make_signed.
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
typename invoke_result< _Fn, _Args... >::type invoke_result_t
std::invoke_result_t
constexpr bool is_nothrow_swappable_with_v
is_nothrow_swappable_with_v
auto declval() noexcept -> decltype(__declval< _Tp >(0))
void swap(any &__x, any &__y) noexcept
Exchange the states of two any objects.
ISO C++ entities toplevel namespace is std.
Define a member typedef type to one of two argument types.
is_member_function_pointer
is_null_pointer (LWG 2247).
__is_nullptr_t (deprecated extension).
is_nothrow_default_constructible
is_nothrow_copy_constructible
is_nothrow_move_constructible
is_nothrow_copy_assignable
is_nothrow_move_assignable
is_trivially_constructible
is_trivially_default_constructible
is_trivially_copy_constructible
is_trivially_move_constructible
is_trivially_copy_assignable
is_trivially_move_assignable
is_trivially_destructible
Provide aligned storage for types.
aligned_storage< _S_len, alignment_value >::type type
The storage.
Define a member typedef type only if a boolean constant is true.
The underlying type of an enum.
Metafunctions used for detecting swappable types: p0185r1.
is_nothrow_swappable_with
std::is_nothrow_invocable
std::is_nothrow_invocable_r