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
56 template<
typename _Tp, _Tp __v>
59 static constexpr _Tp value = __v;
60 typedef _Tp value_type;
62 constexpr
operator value_type()
const noexcept {
return value; }
63 #if __cplusplus > 201103L
65 #define __cpp_lib_integral_constant_callable 201304
67 constexpr value_type operator()()
const noexcept {
return value; }
71 template<
typename _Tp, _Tp __v>
83 #if __cplusplus > 201402L
84 # define __cpp_lib_bool_constant 201505
91 template<
bool,
typename,
typename>
94 template <
typename _Type>
95 struct __type_identity
96 {
using type = _Type; };
98 template<
typename _Tp>
99 using __type_identity_t =
typename __type_identity<_Tp>::type;
101 template<
typename...>
109 template<
typename _B1>
114 template<
typename _B1,
typename _B2>
115 struct __or_<_B1, _B2>
116 :
public conditional<_B1::value, _B1, _B2>::type
119 template<
typename _B1,
typename _B2,
typename _B3,
typename... _Bn>
120 struct __or_<_B1, _B2, _B3, _Bn...>
121 :
public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
124 template<
typename...>
132 template<
typename _B1>
137 template<
typename _B1,
typename _B2>
138 struct __and_<_B1, _B2>
139 :
public conditional<_B1::value, _B2, _B1>::type
142 template<
typename _B1,
typename _B2,
typename _B3,
typename... _Bn>
143 struct __and_<_B1, _B2, _B3, _Bn...>
144 :
public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
147 template<
typename _Pp>
149 :
public __bool_constant<!bool(_Pp::value)>
152 #if __cplusplus >= 201703L
154 template<
typename... _Bn>
155 inline constexpr
bool __or_v = __or_<_Bn...>::value;
156 template<
typename... _Bn>
157 inline constexpr
bool __and_v = __and_<_Bn...>::value;
159 #define __cpp_lib_logical_traits 201510
161 template<
typename... _Bn>
166 template<
typename... _Bn>
171 template<
typename _Pp>
176 template<
typename... _Bn>
177 inline constexpr
bool conjunction_v = conjunction<_Bn...>::value;
179 template<
typename... _Bn>
180 inline constexpr
bool disjunction_v = disjunction<_Bn...>::value;
182 template<
typename _Pp>
183 inline constexpr
bool negation_v = negation<_Pp>::value;
195 struct __is_array_unknown_bounds;
200 template <
typename _Tp,
size_t = sizeof(_Tp)>
201 constexpr
true_type __is_complete_or_unbounded(__type_identity<_Tp>)
204 template <
typename _TypeIdentity,
205 typename _NestedType =
typename _TypeIdentity::type>
206 constexpr
typename __or_<
207 is_reference<_NestedType>,
208 is_function<_NestedType>,
209 is_void<_NestedType>,
210 __is_array_unknown_bounds<_NestedType>
211 >::type __is_complete_or_unbounded(_TypeIdentity)
219 template<
typename _Tp>
220 struct __success_type
221 {
typedef _Tp type; };
223 struct __failure_type
230 template<
typename _Tp>
231 using __remove_cv_t =
typename remove_cv<_Tp>::type;
239 struct __is_void_helper
243 struct __is_void_helper<void>
247 template<
typename _Tp>
249 :
public __is_void_helper<__remove_cv_t<_Tp>>::type
253 struct __is_integral_helper
257 struct __is_integral_helper<bool>
261 struct __is_integral_helper<char>
265 struct __is_integral_helper<signed char>
269 struct __is_integral_helper<unsigned char>
272 #ifdef _GLIBCXX_USE_WCHAR_T
274 struct __is_integral_helper<wchar_t>
278 #ifdef _GLIBCXX_USE_CHAR8_T
280 struct __is_integral_helper<char8_t>
285 struct __is_integral_helper<char16_t>
289 struct __is_integral_helper<char32_t>
293 struct __is_integral_helper<short>
297 struct __is_integral_helper<unsigned short>
301 struct __is_integral_helper<int>
305 struct __is_integral_helper<unsigned int>
309 struct __is_integral_helper<long>
313 struct __is_integral_helper<unsigned long>
317 struct __is_integral_helper<long long>
321 struct __is_integral_helper<unsigned long long>
326 #if defined(__GLIBCXX_TYPE_INT_N_0)
328 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0>
332 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0>
335 #if defined(__GLIBCXX_TYPE_INT_N_1)
337 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1>
341 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1>
344 #if defined(__GLIBCXX_TYPE_INT_N_2)
346 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2>
350 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2>
353 #if defined(__GLIBCXX_TYPE_INT_N_3)
355 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3>
359 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3>
364 template<
typename _Tp>
366 :
public __is_integral_helper<__remove_cv_t<_Tp>>
::type
370 struct __is_floating_point_helper
374 struct __is_floating_point_helper<float>
378 struct __is_floating_point_helper<double>
382 struct __is_floating_point_helper<long double>
385 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
387 struct __is_floating_point_helper<__float128>
392 template<
typename _Tp>
394 :
public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
402 template<
typename _Tp, std::
size_t _Size>
406 template<
typename _Tp>
407 struct is_array<_Tp[]>
411 struct __is_pointer_helper
414 template<
typename _Tp>
415 struct __is_pointer_helper<_Tp*>
419 template<
typename _Tp>
421 :
public __is_pointer_helper<__remove_cv_t<_Tp>>::type
429 template<
typename _Tp>
438 template<
typename _Tp>
443 struct __is_member_object_pointer_helper
446 template<
typename _Tp,
typename _Cp>
447 struct __is_member_object_pointer_helper<_Tp _Cp::*>
448 :
public __not_<is_function<_Tp>>::type { };
451 template<
typename _Tp>
453 :
public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type
457 struct __is_member_function_pointer_helper
460 template<
typename _Tp,
typename _Cp>
461 struct __is_member_function_pointer_helper<_Tp _Cp::*>
462 :
public is_function<_Tp>::type { };
465 template<
typename _Tp>
467 :
public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>
::type
471 template<
typename _Tp>
477 template<
typename _Tp>
483 template<
typename _Tp>
489 template<
typename _Tp>
493 template<
typename _Tp>
494 struct is_function<_Tp&>
497 template<
typename _Tp>
498 struct is_function<_Tp&&>
501 #define __cpp_lib_is_null_pointer 201309
504 struct __is_null_pointer_helper
508 struct __is_null_pointer_helper<std::nullptr_t>
512 template<
typename _Tp>
514 :
public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type
518 template<
typename _Tp>
521 { } _GLIBCXX_DEPRECATED_SUGGEST(
"std::is_null_pointer");
526 template<
typename _Tp>
528 :
public __or_<is_lvalue_reference<_Tp>,
529 is_rvalue_reference<_Tp>>::type
533 template<
typename _Tp>
535 :
public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
539 template<
typename _Tp>
541 :
public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
542 is_null_pointer<_Tp>>::type
546 template<
typename _Tp>
548 :
public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
556 template<
typename _Tp>
558 :
public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
559 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
563 template<
typename _Tp>
565 :
public __not_<is_fundamental<_Tp>>
::type { };
567 template<
typename _Tp>
568 struct __is_member_pointer_helper
571 template<
typename _Tp,
typename _Cp>
572 struct __is_member_pointer_helper<_Tp _Cp::*>
576 template<
typename _Tp>
577 struct is_member_pointer
578 :
public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
581 template<
typename,
typename>
584 template<
typename _Tp,
typename... _Types>
585 using __is_one_of = __or_<is_same<_Tp, _Types>...>;
588 template<
typename _Tp>
589 using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
590 signed char,
signed short,
signed int,
signed long,
592 #if defined(__GLIBCXX_TYPE_INT_N_0)
593 ,
signed __GLIBCXX_TYPE_INT_N_0
595 #if defined(__GLIBCXX_TYPE_INT_N_1)
596 ,
signed __GLIBCXX_TYPE_INT_N_1
598 #if defined(__GLIBCXX_TYPE_INT_N_2)
599 ,
signed __GLIBCXX_TYPE_INT_N_2
601 #if defined(__GLIBCXX_TYPE_INT_N_3)
602 ,
signed __GLIBCXX_TYPE_INT_N_3
607 template<
typename _Tp>
608 using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
609 unsigned char,
unsigned short,
unsigned int,
unsigned long,
611 #if defined(__GLIBCXX_TYPE_INT_N_0)
612 ,
unsigned __GLIBCXX_TYPE_INT_N_0
614 #if defined(__GLIBCXX_TYPE_INT_N_1)
615 ,
unsigned __GLIBCXX_TYPE_INT_N_1
617 #if defined(__GLIBCXX_TYPE_INT_N_2)
618 ,
unsigned __GLIBCXX_TYPE_INT_N_2
620 #if defined(__GLIBCXX_TYPE_INT_N_3)
621 ,
unsigned __GLIBCXX_TYPE_INT_N_3
626 template<
typename _Tp>
627 using __is_standard_integer
628 = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
631 template<
typename...>
using __void_t = void;
635 template<
typename _Tp,
typename =
void>
636 struct __is_referenceable
640 template<
typename _Tp>
641 struct __is_referenceable<_Tp, __void_t<_Tp&>>
652 template<
typename _Tp>
653 struct is_const<_Tp const>
661 template<
typename _Tp>
666 template<
typename _Tp>
670 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
671 "template argument must be a complete class or an unbounded array");
675 template<
typename _Tp>
676 struct is_trivially_copyable
679 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
680 "template argument must be a complete class or an unbounded array");
684 template<
typename _Tp>
688 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
689 "template argument must be a complete class or an unbounded array");
694 template<
typename _Tp>
696 _GLIBCXX20_DEPRECATED(
"use is_standard_layout && is_trivial instead")
700 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
701 "template argument must be a complete class or an unbounded array");
705 template<
typename _Tp>
709 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
710 "template argument must be a complete class or an unbounded array");
714 template<
typename _Tp>
720 template<
typename _Tp>
725 #if __cplusplus >= 201402L
726 #define __cpp_lib_is_final 201402L
728 template<
typename _Tp>
735 template<
typename _Tp>
740 template<
typename _Tp,
742 struct __is_signed_helper
745 template<
typename _Tp>
746 struct __is_signed_helper<_Tp, true>
747 :
public integral_constant<bool, _Tp(-1) < _Tp(0)>
751 template<typename _Tp>
753 : public __is_signed_helper<_Tp>::type
757 template<typename _Tp>
759 : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
770 template<typename _Tp, typename _Up = _Tp&&>
774 template<typename _Tp>
778 template<typename _Tp>
779 auto declval() noexcept -> decltype(__declval<_Tp>(0));
781 template<typename, unsigned = 0>
787 template<typename _Tp>
788 struct __is_array_known_bounds
792 template<
typename _Tp>
793 struct __is_array_unknown_bounds
794 :
public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
802 struct __do_is_destructible_impl
804 template<
typename _Tp,
typename = decltype(declval<_Tp&>().~_Tp())>
811 template<
typename _Tp>
812 struct __is_destructible_impl
813 :
public __do_is_destructible_impl
815 typedef decltype(__test<_Tp>(0)) type;
818 template<typename _Tp,
819 bool = __or_<is_void<_Tp>,
820 __is_array_unknown_bounds<_Tp>,
821 is_function<_Tp>>::value,
822 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
823 struct __is_destructible_safe;
825 template<typename _Tp>
826 struct __is_destructible_safe<_Tp, false, false>
827 : public __is_destructible_impl<typename
828 remove_all_extents<_Tp>::type>::type
831 template<
typename _Tp>
832 struct __is_destructible_safe<_Tp, true, false>
835 template<
typename _Tp>
836 struct __is_destructible_safe<_Tp, false, true>
840 template<
typename _Tp>
842 :
public __is_destructible_safe<_Tp>::type
844 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
845 "template argument must be a complete class or an unbounded array");
852 struct __do_is_nt_destructible_impl
854 template<
typename _Tp>
862 template<
typename _Tp>
863 struct __is_nt_destructible_impl
864 :
public __do_is_nt_destructible_impl
866 typedef decltype(__test<_Tp>(0)) type;
869 template<typename _Tp,
870 bool = __or_<is_void<_Tp>,
871 __is_array_unknown_bounds<_Tp>,
872 is_function<_Tp>>::value,
873 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
874 struct __is_nt_destructible_safe;
876 template<typename _Tp>
877 struct __is_nt_destructible_safe<_Tp, false, false>
878 : public __is_nt_destructible_impl<typename
879 remove_all_extents<_Tp>::type>::type
882 template<
typename _Tp>
883 struct __is_nt_destructible_safe<_Tp, true, false>
886 template<
typename _Tp>
887 struct __is_nt_destructible_safe<_Tp, false, true>
891 template<
typename _Tp>
893 :
public __is_nt_destructible_safe<_Tp>::type
895 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
896 "template argument must be a complete class or an unbounded array");
899 template<
typename _Tp,
typename... _Args>
900 struct __is_constructible_impl
905 template<
typename _Tp,
typename... _Args>
907 :
public __is_constructible_impl<_Tp, _Args...>
909 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
910 "template argument must be a complete class or an unbounded array");
914 template<
typename _Tp>
916 :
public __is_constructible_impl<_Tp>::type
918 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
919 "template argument must be a complete class or an unbounded array");
922 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
923 struct __is_copy_constructible_impl;
925 template<
typename _Tp>
926 struct __is_copy_constructible_impl<_Tp, false>
929 template<
typename _Tp>
930 struct __is_copy_constructible_impl<_Tp, true>
931 :
public __is_constructible_impl<_Tp, const _Tp&>
935 template<
typename _Tp>
937 :
public __is_copy_constructible_impl<_Tp>
939 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
940 "template argument must be a complete class or an unbounded array");
943 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
944 struct __is_move_constructible_impl;
946 template<
typename _Tp>
947 struct __is_move_constructible_impl<_Tp, false>
950 template<
typename _Tp>
951 struct __is_move_constructible_impl<_Tp, true>
952 :
public __is_constructible_impl<_Tp, _Tp&&>
956 template<
typename _Tp>
958 :
public __is_move_constructible_impl<_Tp>
960 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
961 "template argument must be a complete class or an unbounded array");
964 template<bool,
typename _Tp,
typename... _Args>
965 struct __is_nt_constructible_impl
969 template<
typename _Tp,
typename... _Args>
970 struct __is_nt_constructible_impl<true, _Tp, _Args...>
971 :
public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
974 template<
typename _Tp,
typename _Arg>
975 struct __is_nt_constructible_impl<true, _Tp, _Arg>
976 :
public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
979 template<
typename _Tp>
980 struct __is_nt_constructible_impl<true, _Tp>
981 :
public __bool_constant<noexcept(_Tp())>
984 template<
typename _Tp,
size_t _Num>
985 struct __is_nt_constructible_impl<true, _Tp[_Num]>
986 :
public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
989 #if __cpp_aggregate_paren_init
990 template<
typename _Tp,
size_t _Num,
typename _Arg>
991 struct __is_nt_constructible_impl<true, _Tp[_Num], _Arg>
992 :
public __is_nt_constructible_impl<true, _Tp, _Arg>
995 template<
typename _Tp,
size_t _Num,
typename... _Args>
996 struct __is_nt_constructible_impl<true, _Tp[_Num], _Args...>
997 :
public __and_<__is_nt_constructible_impl<true, _Tp, _Args>...>
1001 template<
typename _Tp,
typename... _Args>
1002 using __is_nothrow_constructible_impl
1003 = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
1007 template<
typename _Tp,
typename... _Args>
1009 :
public __is_nothrow_constructible_impl<_Tp, _Args...>
::type
1011 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1012 "template argument must be a complete class or an unbounded array");
1016 template<
typename _Tp>
1018 :
public __is_nothrow_constructible_impl<_Tp>
::type
1020 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1021 "template argument must be a complete class or an unbounded array");
1025 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1026 struct __is_nothrow_copy_constructible_impl;
1028 template<
typename _Tp>
1029 struct __is_nothrow_copy_constructible_impl<_Tp, false>
1032 template<
typename _Tp>
1033 struct __is_nothrow_copy_constructible_impl<_Tp, true>
1034 :
public __is_nothrow_constructible_impl<_Tp, const _Tp&>
1038 template<
typename _Tp>
1040 :
public __is_nothrow_copy_constructible_impl<_Tp>::type
1042 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1043 "template argument must be a complete class or an unbounded array");
1046 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1047 struct __is_nothrow_move_constructible_impl;
1049 template<
typename _Tp>
1050 struct __is_nothrow_move_constructible_impl<_Tp, false>
1053 template<
typename _Tp>
1054 struct __is_nothrow_move_constructible_impl<_Tp, true>
1055 :
public __is_nothrow_constructible_impl<_Tp, _Tp&&>
1059 template<
typename _Tp>
1061 :
public __is_nothrow_move_constructible_impl<_Tp>::type
1063 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1064 "template argument must be a complete class or an unbounded array");
1068 template<
typename _Tp,
typename _Up>
1072 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1073 "template argument must be a complete class or an unbounded array");
1076 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1077 struct __is_copy_assignable_impl;
1079 template<
typename _Tp>
1080 struct __is_copy_assignable_impl<_Tp, false>
1083 template<
typename _Tp>
1084 struct __is_copy_assignable_impl<_Tp, true>
1085 :
public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
1089 template<
typename _Tp>
1091 :
public __is_copy_assignable_impl<_Tp>::type
1093 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1094 "template argument must be a complete class or an unbounded array");
1097 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1098 struct __is_move_assignable_impl;
1100 template<
typename _Tp>
1101 struct __is_move_assignable_impl<_Tp, false>
1104 template<
typename _Tp>
1105 struct __is_move_assignable_impl<_Tp, true>
1106 :
public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
1110 template<
typename _Tp>
1112 :
public __is_move_assignable_impl<_Tp>::type
1114 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1115 "template argument must be a complete class or an unbounded array");
1118 template<
typename _Tp,
typename _Up>
1119 struct __is_nt_assignable_impl
1123 template<
typename _Tp,
typename _Up>
1124 struct __is_nothrow_assignable_impl
1125 :
public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
1126 __is_nt_assignable_impl<_Tp, _Up>>
1130 template<
typename _Tp,
typename _Up>
1132 :
public __is_nothrow_assignable_impl<_Tp, _Up>
1134 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1135 "template argument must be a complete class or an unbounded array");
1138 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1139 struct __is_nt_copy_assignable_impl;
1141 template<
typename _Tp>
1142 struct __is_nt_copy_assignable_impl<_Tp, false>
1145 template<
typename _Tp>
1146 struct __is_nt_copy_assignable_impl<_Tp, true>
1147 :
public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
1151 template<
typename _Tp>
1153 :
public __is_nt_copy_assignable_impl<_Tp>
1155 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1156 "template argument must be a complete class or an unbounded array");
1159 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1160 struct __is_nt_move_assignable_impl;
1162 template<
typename _Tp>
1163 struct __is_nt_move_assignable_impl<_Tp, false>
1166 template<
typename _Tp>
1167 struct __is_nt_move_assignable_impl<_Tp, true>
1168 :
public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
1172 template<
typename _Tp>
1174 :
public __is_nt_move_assignable_impl<_Tp>
1176 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1177 "template argument must be a complete class or an unbounded array");
1181 template<
typename _Tp,
typename... _Args>
1185 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1186 "template argument must be a complete class or an unbounded array");
1190 template<
typename _Tp>
1194 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1195 "template argument must be a complete class or an unbounded array");
1198 struct __do_is_implicitly_default_constructible_impl
1200 template <
typename _Tp>
1201 static void __helper(
const _Tp&);
1203 template <
typename _Tp>
1205 decltype(__helper<const _Tp&>({}))* = 0);
1210 template<
typename _Tp>
1211 struct __is_implicitly_default_constructible_impl
1212 :
public __do_is_implicitly_default_constructible_impl
1214 typedef decltype(__test(declval<_Tp>())) type;
1217 template<typename _Tp>
1218 struct __is_implicitly_default_constructible_safe
1219 : public __is_implicitly_default_constructible_impl<_Tp>::type
1222 template <
typename _Tp>
1223 struct __is_implicitly_default_constructible
1224 :
public __and_<__is_constructible_impl<_Tp>,
1225 __is_implicitly_default_constructible_safe<_Tp>>
1228 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1229 struct __is_trivially_copy_constructible_impl;
1231 template<
typename _Tp>
1232 struct __is_trivially_copy_constructible_impl<_Tp, false>
1235 template<
typename _Tp>
1236 struct __is_trivially_copy_constructible_impl<_Tp, true>
1237 :
public __and_<__is_copy_constructible_impl<_Tp>,
1238 integral_constant<bool,
1239 __is_trivially_constructible(_Tp, const _Tp&)>>
1243 template<
typename _Tp>
1245 :
public __is_trivially_copy_constructible_impl<_Tp>
1247 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1248 "template argument must be a complete class or an unbounded array");
1251 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1252 struct __is_trivially_move_constructible_impl;
1254 template<
typename _Tp>
1255 struct __is_trivially_move_constructible_impl<_Tp, false>
1258 template<
typename _Tp>
1259 struct __is_trivially_move_constructible_impl<_Tp, true>
1260 :
public __and_<__is_move_constructible_impl<_Tp>,
1261 integral_constant<bool,
1262 __is_trivially_constructible(_Tp, _Tp&&)>>
1266 template<
typename _Tp>
1268 :
public __is_trivially_move_constructible_impl<_Tp>
1270 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1271 "template argument must be a complete class or an unbounded array");
1275 template<
typename _Tp,
typename _Up>
1279 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1280 "template argument must be a complete class or an unbounded array");
1283 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1284 struct __is_trivially_copy_assignable_impl;
1286 template<
typename _Tp>
1287 struct __is_trivially_copy_assignable_impl<_Tp, false>
1290 template<
typename _Tp>
1291 struct __is_trivially_copy_assignable_impl<_Tp, true>
1292 :
public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
1296 template<
typename _Tp>
1298 :
public __is_trivially_copy_assignable_impl<_Tp>
1300 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1301 "template argument must be a complete class or an unbounded array");
1304 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1305 struct __is_trivially_move_assignable_impl;
1307 template<
typename _Tp>
1308 struct __is_trivially_move_assignable_impl<_Tp, false>
1311 template<
typename _Tp>
1312 struct __is_trivially_move_assignable_impl<_Tp, true>
1313 :
public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
1317 template<
typename _Tp>
1319 :
public __is_trivially_move_assignable_impl<_Tp>
1321 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1322 "template argument must be a complete class or an unbounded array");
1326 template<
typename _Tp>
1328 :
public __and_<__is_destructible_safe<_Tp>,
1329 __bool_constant<__has_trivial_destructor(_Tp)>>
1331 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1332 "template argument must be a complete class or an unbounded array");
1337 template<
typename _Tp>
1341 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1342 "template argument must be a complete class or an unbounded array");
1349 template<
typename _Tp>
1353 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1354 "template argument must be a complete class or an unbounded array");
1362 template<
typename _Tp, std::
size_t _Size>
1363 struct rank<_Tp[_Size]>
1366 template<
typename _Tp>
1368 :
public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1371 template<
typename,
unsigned _U
int>
1373 :
public integral_constant<std::size_t, 0> { };
1375 template<
typename _Tp,
unsigned _U
int, std::
size_t _Size>
1376 struct extent<_Tp[_Size], _Uint>
1377 :
public integral_constant<std::size_t,
1378 _Uint == 0 ? _Size : extent<_Tp,
1382 template<
typename _Tp,
unsigned _U
int>
1383 struct extent<_Tp[], _Uint>
1384 :
public integral_constant<std::size_t,
1385 _Uint == 0 ? 0 : extent<_Tp,
1393 template<
typename _Tp,
typename _Up>
1395 #ifdef _GLIBCXX_BUILTIN_IS_SAME_AS
1396 :
public integral_constant<bool, _GLIBCXX_BUILTIN_IS_SAME_AS(_Tp, _Up)>
1402 #ifndef _GLIBCXX_BUILTIN_IS_SAME_AS
1403 template<
typename _Tp>
1404 struct is_same<_Tp, _Tp>
1410 template<
typename _Base,
typename _Derived>
1415 template<
typename _From,
typename _To,
1418 struct __is_convertible_helper
1423 #pragma GCC diagnostic push
1424 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
1425 template<
typename _From,
typename _To>
1426 class __is_convertible_helper<_From, _To, false>
1428 template<
typename _To1>
1429 static void __test_aux(_To1) noexcept;
1431 template<typename _From1, typename _To1,
1432 typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
1436 template<typename, typename>
1441 typedef decltype(__test<_From, _To>(0)) type;
1443 #pragma GCC diagnostic pop
1446 template<
typename _From,
typename _To>
1448 :
public __is_convertible_helper<_From, _To>::type
1452 template<
typename _ToElementType,
typename _FromElementType>
1456 template<
typename _From,
typename _To,
1459 struct __is_nt_convertible_helper
1463 #pragma GCC diagnostic push
1464 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
1465 template<
typename _From,
typename _To>
1466 class __is_nt_convertible_helper<_From, _To, false>
1468 template<
typename _To1>
1469 static void __test_aux(_To1) noexcept;
1471 template<typename _From1, typename _To1>
1473 __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
1476 template<typename, typename>
1481 using type = decltype(__test<_From, _To>(0));
1483 #pragma GCC diagnostic pop
1486 template<
typename _From,
typename _To>
1487 struct __is_nothrow_convertible
1488 :
public __is_nt_convertible_helper<_From, _To>::type
1491 #if __cplusplus > 201703L
1492 #define __cpp_lib_is_nothrow_convertible 201806L
1494 template<
typename _From,
typename _To>
1495 struct is_nothrow_convertible
1496 :
public __is_nt_convertible_helper<_From, _To>::type
1500 template<
typename _From,
typename _To>
1501 inline constexpr
bool is_nothrow_convertible_v
1502 = is_nothrow_convertible<_From, _To>::value;
1508 template<
typename _Tp>
1510 {
typedef _Tp type; };
1512 template<
typename _Tp>
1514 {
typedef _Tp type; };
1517 template<
typename _Tp>
1519 {
typedef _Tp type; };
1521 template<
typename _Tp>
1523 {
typedef _Tp type; };
1526 template<
typename _Tp>
1528 {
using type = _Tp; };
1530 template<
typename _Tp>
1531 struct remove_cv<const _Tp>
1532 {
using type = _Tp; };
1534 template<
typename _Tp>
1535 struct remove_cv<volatile _Tp>
1536 {
using type = _Tp; };
1538 template<
typename _Tp>
1539 struct remove_cv<const volatile _Tp>
1540 {
using type = _Tp; };
1543 template<
typename _Tp>
1545 {
typedef _Tp
const type; };
1548 template<
typename _Tp>
1550 {
typedef _Tp
volatile type; };
1553 template<
typename _Tp>
1560 #if __cplusplus > 201103L
1562 #define __cpp_lib_transformation_trait_aliases 201304
1565 template<
typename _Tp>
1569 template<
typename _Tp>
1573 template<
typename _Tp>
1577 template<
typename _Tp>
1581 template<
typename _Tp>
1585 template<
typename _Tp>
1592 template<
typename _Tp>
1594 {
typedef _Tp type; };
1596 template<
typename _Tp>
1598 {
typedef _Tp type; };
1600 template<
typename _Tp>
1601 struct remove_reference<_Tp&&>
1602 {
typedef _Tp type; };
1604 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1605 struct __add_lvalue_reference_helper
1606 {
typedef _Tp type; };
1608 template<
typename _Tp>
1609 struct __add_lvalue_reference_helper<_Tp, true>
1610 {
typedef _Tp& type; };
1613 template<
typename _Tp>
1615 :
public __add_lvalue_reference_helper<_Tp>
1618 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1619 struct __add_rvalue_reference_helper
1620 {
typedef _Tp type; };
1622 template<
typename _Tp>
1623 struct __add_rvalue_reference_helper<_Tp, true>
1624 {
typedef _Tp&& type; };
1627 template<
typename _Tp>
1629 :
public __add_rvalue_reference_helper<_Tp>
1632 #if __cplusplus > 201103L
1634 template<
typename _Tp>
1638 template<
typename _Tp>
1642 template<
typename _Tp>
1649 template<
typename _Unqualified,
bool _IsConst,
bool _IsVol>
1650 struct __cv_selector;
1652 template<
typename _Unqualified>
1653 struct __cv_selector<_Unqualified, false, false>
1654 {
typedef _Unqualified __type; };
1656 template<
typename _Unqualified>
1657 struct __cv_selector<_Unqualified, false, true>
1658 {
typedef volatile _Unqualified __type; };
1660 template<
typename _Unqualified>
1661 struct __cv_selector<_Unqualified, true, false>
1662 {
typedef const _Unqualified __type; };
1664 template<
typename _Unqualified>
1665 struct __cv_selector<_Unqualified, true, true>
1666 {
typedef const volatile _Unqualified __type; };
1668 template<
typename _Qualified,
typename _Unqualified,
1669 bool _IsConst = is_const<_Qualified>::value,
1670 bool _IsVol = is_volatile<_Qualified>::value>
1671 class __match_cv_qualifiers
1673 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
1676 typedef typename __match::__type __type;
1680 template<
typename _Tp>
1681 struct __make_unsigned
1682 {
typedef _Tp __type; };
1685 struct __make_unsigned<char>
1686 {
typedef unsigned char __type; };
1689 struct __make_unsigned<signed char>
1690 {
typedef unsigned char __type; };
1693 struct __make_unsigned<short>
1694 {
typedef unsigned short __type; };
1697 struct __make_unsigned<int>
1698 {
typedef unsigned int __type; };
1701 struct __make_unsigned<long>
1702 {
typedef unsigned long __type; };
1705 struct __make_unsigned<long long>
1706 {
typedef unsigned long long __type; };
1708 #if defined(__GLIBCXX_TYPE_INT_N_0)
1710 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0>
1711 {
typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; };
1713 #if defined(__GLIBCXX_TYPE_INT_N_1)
1715 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1>
1716 {
typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; };
1718 #if defined(__GLIBCXX_TYPE_INT_N_2)
1720 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2>
1721 {
typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; };
1723 #if defined(__GLIBCXX_TYPE_INT_N_3)
1725 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3>
1726 {
typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; };
1730 template<
typename _Tp,
1731 bool _IsInt = is_integral<_Tp>::value,
1732 bool _IsEnum = is_enum<_Tp>::value>
1733 class __make_unsigned_selector;
1735 template<
typename _Tp>
1736 class __make_unsigned_selector<_Tp, true, false>
1738 using __unsigned_type
1739 =
typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
1743 =
typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1746 class __make_unsigned_selector_base
1749 template<
typename...>
struct _List { };
1751 template<
typename _Tp,
typename... _Up>
1752 struct _List<_Tp, _Up...> : _List<_Up...>
1753 {
static constexpr
size_t __size =
sizeof(_Tp); };
1755 template<
size_t _Sz,
typename _Tp,
bool = (_Sz <= _Tp::__size)>
1758 template<
size_t _Sz,
typename _U
int,
typename... _UInts>
1759 struct __select<_Sz, _List<_Uint, _UInts...>,
true>
1760 {
using __type = _Uint; };
1762 template<
size_t _Sz,
typename _Uint,
typename... _UInts>
1763 struct __select<_Sz, _List<_Uint, _UInts...>, false>
1764 : __select<_Sz, _List<_UInts...>>
1769 template<
typename _Tp>
1770 class __make_unsigned_selector<_Tp, false, true>
1771 : __make_unsigned_selector_base
1774 using _UInts = _List<
unsigned char,
unsigned short,
unsigned int,
1775 unsigned long,
unsigned long long>;
1777 using __unsigned_type =
typename __select<sizeof(_Tp), _UInts>::__type;
1781 =
typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1788 #if defined(_GLIBCXX_USE_WCHAR_T)
1790 struct __make_unsigned<wchar_t>
1793 =
typename __make_unsigned_selector<wchar_t, false, true>::__type;
1797 #ifdef _GLIBCXX_USE_CHAR8_T
1799 struct __make_unsigned<char8_t>
1802 =
typename __make_unsigned_selector<char8_t, false, true>::__type;
1807 struct __make_unsigned<char16_t>
1810 =
typename __make_unsigned_selector<char16_t, false, true>::__type;
1814 struct __make_unsigned<char32_t>
1817 =
typename __make_unsigned_selector<char32_t, false, true>::__type;
1824 template<
typename _Tp>
1826 {
typedef typename __make_unsigned_selector<_Tp>::__type type; };
1834 template<
typename _Tp>
1835 struct __make_signed
1836 {
typedef _Tp __type; };
1839 struct __make_signed<char>
1840 {
typedef signed char __type; };
1843 struct __make_signed<unsigned char>
1844 {
typedef signed char __type; };
1847 struct __make_signed<unsigned short>
1848 {
typedef signed short __type; };
1851 struct __make_signed<unsigned int>
1852 {
typedef signed int __type; };
1855 struct __make_signed<unsigned long>
1856 {
typedef signed long __type; };
1859 struct __make_signed<unsigned long long>
1860 {
typedef signed long long __type; };
1862 #if defined(__GLIBCXX_TYPE_INT_N_0)
1864 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0>
1865 {
typedef __GLIBCXX_TYPE_INT_N_0 __type; };
1867 #if defined(__GLIBCXX_TYPE_INT_N_1)
1869 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1>
1870 {
typedef __GLIBCXX_TYPE_INT_N_1 __type; };
1872 #if defined(__GLIBCXX_TYPE_INT_N_2)
1874 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2>
1875 {
typedef __GLIBCXX_TYPE_INT_N_2 __type; };
1877 #if defined(__GLIBCXX_TYPE_INT_N_3)
1879 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3>
1880 {
typedef __GLIBCXX_TYPE_INT_N_3 __type; };
1884 template<
typename _Tp,
1885 bool _IsInt = is_integral<_Tp>::value,
1886 bool _IsEnum = is_enum<_Tp>::value>
1887 class __make_signed_selector;
1889 template<
typename _Tp>
1890 class __make_signed_selector<_Tp, true, false>
1893 =
typename __make_signed<__remove_cv_t<_Tp>>::__type;
1897 =
typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
1901 template<
typename _Tp>
1902 class __make_signed_selector<_Tp, false, true>
1904 typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
1907 typedef typename __make_signed_selector<__unsigned_type>::__type __type;
1914 #if defined(_GLIBCXX_USE_WCHAR_T)
1916 struct __make_signed<wchar_t>
1919 =
typename __make_signed_selector<wchar_t, false, true>::__type;
1923 #if defined(_GLIBCXX_USE_CHAR8_T)
1925 struct __make_signed<char8_t>
1928 =
typename __make_signed_selector<char8_t, false, true>::__type;
1933 struct __make_signed<char16_t>
1936 =
typename __make_signed_selector<char16_t, false, true>::__type;
1940 struct __make_signed<char32_t>
1943 =
typename __make_signed_selector<char32_t, false, true>::__type;
1950 template<
typename _Tp>
1952 {
typedef typename __make_signed_selector<_Tp>::__type type; };
1958 #if __cplusplus > 201103L
1960 template<
typename _Tp>
1964 template<
typename _Tp>
1971 template<
typename _Tp>
1973 {
typedef _Tp type; };
1975 template<
typename _Tp, std::
size_t _Size>
1977 {
typedef _Tp type; };
1979 template<
typename _Tp>
1980 struct remove_extent<_Tp[]>
1981 {
typedef _Tp type; };
1984 template<
typename _Tp>
1985 struct remove_all_extents
1986 {
typedef _Tp type; };
1988 template<
typename _Tp, std::
size_t _Size>
1989 struct remove_all_extents<_Tp[_Size]>
1990 {
typedef typename remove_all_extents<_Tp>::type type; };
1992 template<
typename _Tp>
1993 struct remove_all_extents<_Tp[]>
1994 {
typedef typename remove_all_extents<_Tp>::type type; };
1996 #if __cplusplus > 201103L
1998 template<
typename _Tp>
2002 template<
typename _Tp>
2008 template<
typename _Tp,
typename>
2009 struct __remove_pointer_helper
2010 {
typedef _Tp type; };
2012 template<
typename _Tp,
typename _Up>
2013 struct __remove_pointer_helper<_Tp, _Up*>
2014 {
typedef _Up type; };
2017 template<
typename _Tp>
2019 :
public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
2023 template<
typename _Tp,
bool = __or_<__is_referenceable<_Tp>,
2024 is_
void<_Tp>>::value>
2026 {
typedef _Tp type; };
2028 template<
typename _Tp>
2030 {
typedef typename remove_reference<_Tp>::type* type; };
2032 template<
typename _Tp>
2034 :
public __add_pointer_helper<_Tp>
2037 #if __cplusplus > 201103L
2039 template<
typename _Tp>
2043 template<
typename _Tp>
2047 template<std::
size_t _Len>
2048 struct __aligned_storage_msa
2052 unsigned char __data[_Len];
2053 struct __attribute__((__aligned__)) { } __align;
2067 template<std::size_t _Len, std::size_t _Align =
2068 __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
2073 unsigned char __data[_Len];
2074 struct __attribute__((__aligned__((_Align)))) { } __align;
2078 template <
typename... _Types>
2079 struct __strictest_alignment
2081 static const size_t _S_alignment = 0;
2082 static const size_t _S_size = 0;
2085 template <
typename _Tp,
typename... _Types>
2086 struct __strictest_alignment<_Tp, _Types...>
2088 static const size_t _S_alignment =
2089 alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
2090 ?
alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
2091 static const size_t _S_size =
2092 sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
2093 ?
sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
2106 template <
size_t _Len,
typename... _Types>
2110 static_assert(
sizeof...(_Types) != 0,
"At least one type is required");
2112 using __strictest = __strictest_alignment<_Types...>;
2113 static const size_t _S_len = _Len > __strictest::_S_size
2114 ? _Len : __strictest::_S_size;
2117 static const size_t alignment_value = __strictest::_S_alignment;
2122 template <
size_t _Len,
typename... _Types>
2123 const size_t aligned_union<_Len, _Types...>::alignment_value;
2127 template<
typename _Up,
2130 struct __decay_selector;
2133 template<
typename _Up>
2134 struct __decay_selector<_Up, false, false>
2135 {
typedef __remove_cv_t<_Up> __type; };
2137 template<
typename _Up>
2138 struct __decay_selector<_Up, true, false>
2139 {
typedef typename remove_extent<_Up>::type* __type; };
2141 template<
typename _Up>
2142 struct __decay_selector<_Up, false, true>
2143 {
typedef typename add_pointer<_Up>::type __type; };
2146 template<
typename _Tp>
2149 typedef typename remove_reference<_Tp>::type __remove_type;
2152 typedef typename __decay_selector<__remove_type>::__type type;
2156 template<
typename _Tp>
2157 using __decay_t =
typename decay<_Tp>::type;
2159 template<
typename _Tp>
2163 template<
typename _Tp>
2164 struct __strip_reference_wrapper
2169 template<
typename _Tp>
2172 typedef _Tp& __type;
2175 template<
typename _Tp>
2176 using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
2181 template<
bool,
typename _Tp =
void>
2186 template<
typename _Tp>
2188 {
typedef _Tp type; };
2191 template<
bool _Cond,
typename _Tp =
void>
2192 using __enable_if_t =
typename enable_if<_Cond, _Tp>::type;
2194 template<
typename... _Cond>
2195 using _Require = __enable_if_t<__and_<_Cond...>::value>;
2199 template<
bool _Cond,
typename _Iftrue,
typename _Iffalse>
2201 {
typedef _Iftrue type; };
2204 template<
typename _Iftrue,
typename _Iffalse>
2205 struct conditional<false, _Iftrue, _Iffalse>
2206 {
typedef _Iffalse type; };
2209 template<
typename _Tp>
2210 using __remove_cvref_t
2211 =
typename remove_cv<typename remove_reference<_Tp>::type>::type;
2214 template<
typename... _Tp>
2219 struct __do_common_type_impl
2221 template<
typename _Tp,
typename _Up>
2223 = decltype(
true ? std::declval<_Tp>() : std::declval<_Up>());
2227 template<
typename _Tp,
typename _Up>
2228 static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
2231 #if __cplusplus > 201703L
2234 template<
typename _Tp,
typename _Up>
2235 static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>>
2239 template<
typename,
typename>
2240 static __failure_type
2243 template<
typename _Tp,
typename _Up>
2244 static decltype(_S_test_2<_Tp, _Up>(0))
2254 template<
typename _Tp0>
2260 template<
typename _Tp1,
typename _Tp2,
2261 typename _Dp1 = __decay_t<_Tp1>,
typename _Dp2 = __decay_t<_Tp2>>
2262 struct __common_type_impl
2266 using type = common_type<_Dp1, _Dp2>;
2269 template<
typename _Tp1,
typename _Tp2>
2270 struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
2271 :
private __do_common_type_impl
2275 using type = decltype(_S_test<_Tp1, _Tp2>(0));
2279 template<
typename _Tp1,
typename _Tp2>
2280 struct common_type<_Tp1, _Tp2>
2281 :
public __common_type_impl<_Tp1, _Tp2>::type
2284 template<
typename...>
2285 struct __common_type_pack
2288 template<
typename,
typename,
typename =
void>
2289 struct __common_type_fold;
2292 template<
typename _Tp1,
typename _Tp2,
typename... _Rp>
2293 struct common_type<_Tp1, _Tp2, _Rp...>
2294 :
public __common_type_fold<common_type<_Tp1, _Tp2>,
2295 __common_type_pack<_Rp...>>
2301 template<
typename _CTp,
typename... _Rp>
2302 struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
2303 __void_t<typename _CTp::type>>
2304 :
public common_type<typename _CTp::type, _Rp...>
2308 template<
typename _CTp,
typename _Rp>
2309 struct __common_type_fold<_CTp, _Rp, void>
2312 template<typename _Tp, bool = is_enum<_Tp>::value>
2313 struct __underlying_type_impl
2315 using type = __underlying_type(_Tp);
2318 template<
typename _Tp>
2319 struct __underlying_type_impl<_Tp, false>
2323 template<
typename _Tp>
2325 :
public __underlying_type_impl<_Tp>
2328 template<
typename _Tp>
2329 struct __declval_protector
2331 static const bool __stop =
false;
2334 template<
typename _Tp>
2335 auto declval() noexcept -> decltype(__declval<_Tp>(0))
2337 static_assert(__declval_protector<_Tp>::__stop,
2338 "declval() must not be used!");
2339 return __declval<_Tp>(0);
2343 template<
typename _Signature>
2348 #define __cpp_lib_result_of_sfinae 201210
2350 struct __invoke_memfun_ref { };
2351 struct __invoke_memfun_deref { };
2352 struct __invoke_memobj_ref { };
2353 struct __invoke_memobj_deref { };
2354 struct __invoke_other { };
2357 template<
typename _Tp,
typename _Tag>
2358 struct __result_of_success : __success_type<_Tp>
2359 {
using __invoke_type = _Tag; };
2362 struct __result_of_memfun_ref_impl
2364 template<
typename _Fp,
typename _Tp1,
typename... _Args>
2365 static __result_of_success<decltype(
2366 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
2367 ), __invoke_memfun_ref> _S_test(
int);
2369 template<
typename...>
2370 static __failure_type _S_test(...);
2373 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2374 struct __result_of_memfun_ref
2375 :
private __result_of_memfun_ref_impl
2377 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2381 struct __result_of_memfun_deref_impl
2383 template<
typename _Fp,
typename _Tp1,
typename... _Args>
2384 static __result_of_success<decltype(
2385 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
2386 ), __invoke_memfun_deref> _S_test(
int);
2388 template<
typename...>
2389 static __failure_type _S_test(...);
2392 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2393 struct __result_of_memfun_deref
2394 :
private __result_of_memfun_deref_impl
2396 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2400 struct __result_of_memobj_ref_impl
2402 template<
typename _Fp,
typename _Tp1>
2403 static __result_of_success<decltype(
2404 std::declval<_Tp1>().*std::declval<_Fp>()
2405 ), __invoke_memobj_ref> _S_test(
int);
2407 template<
typename,
typename>
2408 static __failure_type _S_test(...);
2411 template<
typename _MemPtr,
typename _Arg>
2412 struct __result_of_memobj_ref
2413 :
private __result_of_memobj_ref_impl
2415 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2419 struct __result_of_memobj_deref_impl
2421 template<
typename _Fp,
typename _Tp1>
2422 static __result_of_success<decltype(
2423 (*std::declval<_Tp1>()).*std::declval<_Fp>()
2424 ), __invoke_memobj_deref> _S_test(
int);
2426 template<
typename,
typename>
2427 static __failure_type _S_test(...);
2430 template<
typename _MemPtr,
typename _Arg>
2431 struct __result_of_memobj_deref
2432 :
private __result_of_memobj_deref_impl
2434 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2437 template<typename _MemPtr, typename _Arg>
2438 struct __result_of_memobj;
2440 template<typename _Res, typename _Class, typename _Arg>
2441 struct __result_of_memobj<_Res _Class::*, _Arg>
2443 typedef __remove_cvref_t<_Arg> _Argval;
2444 typedef _Res _Class::* _MemPtr;
2445 typedef typename conditional<__or_<is_same<_Argval, _Class>,
2446 is_base_of<_Class, _Argval>>::value,
2447 __result_of_memobj_ref<_MemPtr, _Arg>,
2448 __result_of_memobj_deref<_MemPtr, _Arg>
2452 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2453 struct __result_of_memfun;
2455 template<
typename _Res,
typename _Class,
typename _Arg,
typename... _Args>
2456 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
2458 typedef typename remove_reference<_Arg>::type _Argval;
2459 typedef _Res _Class::* _MemPtr;
2460 typedef typename conditional<is_base_of<_Class, _Argval>::value,
2461 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
2462 __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
2471 template<
typename _Tp,
typename _Up = __remove_cvref_t<_Tp>>
2477 template<
typename _Tp,
typename _Up>
2478 struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
2483 template<bool, bool,
typename _Functor,
typename... _ArgTypes>
2484 struct __result_of_impl
2486 typedef __failure_type type;
2489 template<
typename _MemPtr,
typename _Arg>
2490 struct __result_of_impl<true, false, _MemPtr, _Arg>
2491 :
public __result_of_memobj<__decay_t<_MemPtr>,
2492 typename __inv_unwrap<_Arg>::type>
2495 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2496 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
2497 :
public __result_of_memfun<__decay_t<_MemPtr>,
2498 typename __inv_unwrap<_Arg>::type, _Args...>
2502 struct __result_of_other_impl
2504 template<
typename _Fn,
typename... _Args>
2505 static __result_of_success<decltype(
2506 std::declval<_Fn>()(std::declval<_Args>()...)
2507 ), __invoke_other> _S_test(
int);
2509 template<
typename...>
2510 static __failure_type _S_test(...);
2513 template<
typename _Functor,
typename... _ArgTypes>
2514 struct __result_of_impl<false, false, _Functor, _ArgTypes...>
2515 :
private __result_of_other_impl
2517 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2521 template<typename _Functor, typename... _ArgTypes>
2522 struct __invoke_result
2523 : public __result_of_impl<
2524 is_member_object_pointer<
2525 typename remove_reference<_Functor>::type
2527 is_member_function_pointer<
2528 typename remove_reference<_Functor>::type
2530 _Functor, _ArgTypes...
2534 template<
typename _Functor,
typename... _ArgTypes>
2535 struct result_of<_Functor(_ArgTypes...)>
2536 :
public __invoke_result<_Functor, _ArgTypes...>
2539 #if __cplusplus >= 201402L
2541 template<
size_t _Len,
size_t _Align =
2542 __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
2545 template <
size_t _Len,
typename... _Types>
2546 using aligned_union_t =
typename aligned_union<_Len, _Types...>::type;
2549 template<
typename _Tp>
2553 template<
bool _Cond,
typename _Tp =
void>
2557 template<
bool _Cond,
typename _Iftrue,
typename _Iffalse>
2561 template<
typename... _Tp>
2565 template<
typename _Tp>
2569 template<
typename _Tp>
2573 #if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11
2574 #define __cpp_lib_void_t 201411
2580 template<
typename _Default,
typename _AlwaysVoid,
2581 template<
typename...>
class _Op,
typename... _Args>
2585 using type = _Default;
2589 template<
typename _Default,
template<
typename...>
class _Op,
2591 struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
2594 using type = _Op<_Args...>;
2598 template<
typename _Default,
template<
typename...>
class _Op,
2603 template<
typename _Default,
template<
typename...>
class _Op,
2605 using __detected_or_t
2614 #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \
2615 template<typename _Tp, typename = __void_t<>> \
2616 struct __has_##_NTYPE \
2619 template<typename _Tp> \
2620 struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> \
2624 template <
typename _Tp>
2625 struct __is_swappable;
2627 template <
typename _Tp>
2628 struct __is_nothrow_swappable;
2630 template<
typename... _Elements>
2637 template<
typename... _Tps>
2638 struct __is_tuple_like_impl<tuple<_Tps...>> :
true_type
2642 template<
typename _Tp>
2643 struct __is_tuple_like
2644 :
public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
2647 template<
typename _Tp>
2648 _GLIBCXX20_CONSTEXPR
2650 _Require<__not_<__is_tuple_like<_Tp>>,
2651 is_move_constructible<_Tp>,
2652 is_move_assignable<_Tp>>
2654 noexcept(__and_<is_nothrow_move_constructible<_Tp>,
2655 is_nothrow_move_assignable<_Tp>>::value);
2657 template<typename _Tp,
size_t _Nm>
2658 _GLIBCXX20_CONSTEXPR
2660 __enable_if_t<__is_swappable<_Tp>::value>
2661 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
2662 noexcept(__is_nothrow_swappable<_Tp>::value);
2664 namespace __swappable_details {
2667 struct __do_is_swappable_impl
2669 template<
typename _Tp,
typename
2670 = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
2677 struct __do_is_nothrow_swappable_impl
2679 template<
typename _Tp>
2680 static __bool_constant<
2681 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2690 template<
typename _Tp>
2691 struct __is_swappable_impl
2692 :
public __swappable_details::__do_is_swappable_impl
2694 typedef decltype(__test<_Tp>(0)) type;
2697 template<typename _Tp>
2698 struct __is_nothrow_swappable_impl
2699 : public __swappable_details::__do_is_nothrow_swappable_impl
2701 typedef decltype(__test<_Tp>(0)) type;
2704 template<typename _Tp>
2705 struct __is_swappable
2706 : public __is_swappable_impl<_Tp>::type
2709 template<
typename _Tp>
2710 struct __is_nothrow_swappable
2711 :
public __is_nothrow_swappable_impl<_Tp>::type
2714 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
2715 #define __cpp_lib_is_swappable 201603
2719 template<
typename _Tp>
2721 :
public __is_swappable_impl<_Tp>::type
2723 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2724 "template argument must be a complete class or an unbounded array");
2728 template<
typename _Tp>
2730 :
public __is_nothrow_swappable_impl<_Tp>::type
2732 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2733 "template argument must be a complete class or an unbounded array");
2736 #if __cplusplus >= 201402L
2738 template<
typename _Tp>
2743 template<
typename _Tp>
2746 #endif // __cplusplus >= 201402L
2748 namespace __swappable_with_details {
2751 struct __do_is_swappable_with_impl
2753 template<
typename _Tp,
typename _Up,
typename
2754 = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
2756 = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
2759 template<
typename,
typename>
2763 struct __do_is_nothrow_swappable_with_impl
2765 template<
typename _Tp,
typename _Up>
2767 noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
2769 noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
2772 template<
typename,
typename>
2778 template<
typename _Tp,
typename _Up>
2779 struct __is_swappable_with_impl
2780 :
public __swappable_with_details::__do_is_swappable_with_impl
2782 typedef decltype(__test<_Tp, _Up>(0)) type;
2786 template<typename _Tp>
2787 struct __is_swappable_with_impl<_Tp&, _Tp&>
2788 : public __swappable_details::__do_is_swappable_impl
2790 typedef decltype(__test<_Tp&>(0)) type;
2793 template<typename _Tp, typename _Up>
2794 struct __is_nothrow_swappable_with_impl
2795 : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
2797 typedef decltype(__test<_Tp, _Up>(0)) type;
2801 template<typename _Tp>
2802 struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
2803 : public __swappable_details::__do_is_nothrow_swappable_impl
2805 typedef decltype(__test<_Tp&>(0)) type;
2809 template<typename _Tp, typename _Up>
2811 : public __is_swappable_with_impl<_Tp, _Up>::type
2815 template<
typename _Tp,
typename _Up>
2817 :
public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
2820 #if __cplusplus >= 201402L
2822 template<
typename _Tp,
typename _Up>
2827 template<
typename _Tp,
typename _Up>
2830 #endif // __cplusplus >= 201402L
2832 #endif// c++1z or gnu++11
2837 template<
typename _Result,
typename _Ret,
2842 template<
typename _Result,
typename _Ret>
2843 struct __is_invocable_impl<_Result, _Ret,
2845 __void_t<typename _Result::type>>
2849 #pragma GCC diagnostic push
2850 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
2852 template<
typename _Result,
typename _Ret>
2853 struct __is_invocable_impl<_Result, _Ret,
2855 __void_t<typename _Result::type>>
2860 static typename _Result::type _S_get();
2862 template<
typename _Tp>
2863 static void _S_conv(_Tp);
2866 template<
typename _Tp,
typename = decltype(_S_conv<_Tp>(_S_get()))>
2870 template<
typename _Tp>
2875 using type = decltype(_S_test<_Ret>(1));
2877 #pragma GCC diagnostic pop
2879 template<
typename _Fn,
typename... _ArgTypes>
2880 struct __is_invocable
2881 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2884 template<
typename _Fn,
typename _Tp,
typename... _Args>
2885 constexpr
bool __call_is_nt(__invoke_memfun_ref)
2887 using _Up =
typename __inv_unwrap<_Tp>::type;
2888 return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
2889 std::declval<_Args>()...));
2892 template<
typename _Fn,
typename _Tp,
typename... _Args>
2893 constexpr
bool __call_is_nt(__invoke_memfun_deref)
2895 return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
2896 std::declval<_Args>()...));
2899 template<
typename _Fn,
typename _Tp>
2900 constexpr
bool __call_is_nt(__invoke_memobj_ref)
2902 using _Up =
typename __inv_unwrap<_Tp>::type;
2903 return noexcept(std::declval<_Up>().*std::declval<_Fn>());
2906 template<
typename _Fn,
typename _Tp>
2907 constexpr
bool __call_is_nt(__invoke_memobj_deref)
2909 return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
2912 template<
typename _Fn,
typename... _Args>
2913 constexpr
bool __call_is_nt(__invoke_other)
2915 return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
2918 template<
typename _Result,
typename _Fn,
typename... _Args>
2919 struct __call_is_nothrow
2921 std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
2925 template<
typename _Fn,
typename... _Args>
2926 using __call_is_nothrow_
2927 = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
2930 template<
typename _Fn,
typename... _Args>
2931 struct __is_nothrow_invocable
2932 : __and_<__is_invocable<_Fn, _Args...>,
2933 __call_is_nothrow_<_Fn, _Args...>>::type
2936 #pragma GCC diagnostic push
2937 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
2938 struct __nonesuchbase {};
2939 struct __nonesuch :
private __nonesuchbase {
2940 ~__nonesuch() =
delete;
2941 __nonesuch(__nonesuch
const&) =
delete;
2942 void operator=(__nonesuch
const&) =
delete;
2944 #pragma GCC diagnostic pop
2946 #if __cplusplus >= 201703L
2947 # define __cpp_lib_is_invocable 201703
2950 template<
typename _Functor,
typename... _ArgTypes>
2951 struct invoke_result
2952 :
public __invoke_result<_Functor, _ArgTypes...>
2956 template<
typename _Fn,
typename... _Args>
2957 using invoke_result_t =
typename invoke_result<_Fn, _Args...>::type;
2960 template<
typename _Fn,
typename... _ArgTypes>
2962 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2964 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
2965 "_Fn must be a complete class or an unbounded array");
2969 template<
typename _Ret,
typename _Fn,
typename... _ArgTypes>
2970 struct is_invocable_r
2971 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
2973 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
2974 "_Fn must be a complete class or an unbounded array");
2978 template<
typename _Fn,
typename... _ArgTypes>
2979 struct is_nothrow_invocable
2980 : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
2981 __call_is_nothrow_<_Fn, _ArgTypes...>>::type
2983 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
2984 "_Fn must be a complete class or an unbounded array");
2987 template<
typename _Result,
typename _Ret,
typename =
void>
2988 struct __is_nt_invocable_impl :
false_type { };
2990 template<
typename _Result,
typename _Ret>
2991 struct __is_nt_invocable_impl<_Result, _Ret,
2992 __void_t<typename _Result::type>>
2993 : __or_<is_void<_Ret>,
2994 __is_nothrow_convertible<typename _Result::type, _Ret>>
2998 template<
typename _Ret,
typename _Fn,
typename... _ArgTypes>
2999 struct is_nothrow_invocable_r
3000 : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
3001 __call_is_nothrow_<_Fn, _ArgTypes...>>::type
3005 template<
typename _Fn,
typename... _Args>
3006 inline constexpr
bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
3009 template<
typename _Fn,
typename... _Args>
3010 inline constexpr
bool is_nothrow_invocable_v
3011 = is_nothrow_invocable<_Fn, _Args...>::value;
3014 template<
typename _Ret,
typename _Fn,
typename... _Args>
3015 inline constexpr
bool is_invocable_r_v
3016 = is_invocable_r<_Ret, _Fn, _Args...>::value;
3019 template<
typename _Ret,
typename _Fn,
typename... _Args>
3020 inline constexpr
bool is_nothrow_invocable_r_v
3021 = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
3024 #if __cplusplus >= 201703L
3025 # define __cpp_lib_type_trait_variable_templates 201510L
3026 template <
typename _Tp>
3027 inline constexpr
bool is_void_v = is_void<_Tp>::value;
3028 template <
typename _Tp>
3029 inline constexpr
bool is_null_pointer_v = is_null_pointer<_Tp>::value;
3030 template <
typename _Tp>
3031 inline constexpr
bool is_integral_v = is_integral<_Tp>::value;
3032 template <
typename _Tp>
3033 inline constexpr
bool is_floating_point_v = is_floating_point<_Tp>::value;
3034 template <
typename _Tp>
3035 inline constexpr
bool is_array_v = is_array<_Tp>::value;
3036 template <
typename _Tp>
3037 inline constexpr
bool is_pointer_v = is_pointer<_Tp>::value;
3038 template <
typename _Tp>
3039 inline constexpr
bool is_lvalue_reference_v =
3040 is_lvalue_reference<_Tp>::value;
3041 template <
typename _Tp>
3042 inline constexpr
bool is_rvalue_reference_v =
3043 is_rvalue_reference<_Tp>::value;
3044 template <
typename _Tp>
3045 inline constexpr
bool is_member_object_pointer_v =
3046 is_member_object_pointer<_Tp>::value;
3047 template <
typename _Tp>
3048 inline constexpr
bool is_member_function_pointer_v =
3049 is_member_function_pointer<_Tp>::value;
3050 template <
typename _Tp>
3051 inline constexpr
bool is_enum_v = is_enum<_Tp>::value;
3052 template <
typename _Tp>
3053 inline constexpr
bool is_union_v = is_union<_Tp>::value;
3054 template <
typename _Tp>
3055 inline constexpr
bool is_class_v = is_class<_Tp>::value;
3056 template <
typename _Tp>
3057 inline constexpr
bool is_function_v = is_function<_Tp>::value;
3058 template <
typename _Tp>
3059 inline constexpr
bool is_reference_v = is_reference<_Tp>::value;
3060 template <
typename _Tp>
3061 inline constexpr
bool is_arithmetic_v = is_arithmetic<_Tp>::value;
3062 template <
typename _Tp>
3063 inline constexpr
bool is_fundamental_v = is_fundamental<_Tp>::value;
3064 template <
typename _Tp>
3065 inline constexpr
bool is_object_v = is_object<_Tp>::value;
3066 template <
typename _Tp>
3067 inline constexpr
bool is_scalar_v = is_scalar<_Tp>::value;
3068 template <
typename _Tp>
3069 inline constexpr
bool is_compound_v = is_compound<_Tp>::value;
3070 template <
typename _Tp>
3071 inline constexpr
bool is_member_pointer_v = is_member_pointer<_Tp>::value;
3072 template <
typename _Tp>
3073 inline constexpr
bool is_const_v = is_const<_Tp>::value;
3074 template <
typename _Tp>
3075 inline constexpr
bool is_volatile_v = is_volatile<_Tp>::value;
3076 template <
typename _Tp>
3077 inline constexpr
bool is_trivial_v = is_trivial<_Tp>::value;
3078 template <
typename _Tp>
3079 inline constexpr
bool is_trivially_copyable_v =
3080 is_trivially_copyable<_Tp>::value;
3081 template <
typename _Tp>
3082 inline constexpr
bool is_standard_layout_v = is_standard_layout<_Tp>::value;
3083 #pragma GCC diagnostic push
3084 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3085 template <
typename _Tp>
3086 _GLIBCXX20_DEPRECATED(
"use is_standard_layout_v && is_trivial_v instead")
3087 inline constexpr
bool is_pod_v = is_pod<_Tp>::value;
3088 #pragma GCC diagnostic pop
3089 template <
typename _Tp>
3090 inline constexpr
bool is_literal_type_v = is_literal_type<_Tp>::value;
3091 template <
typename _Tp>
3092 inline constexpr
bool is_empty_v = is_empty<_Tp>::value;
3093 template <
typename _Tp>
3094 inline constexpr
bool is_polymorphic_v = is_polymorphic<_Tp>::value;
3095 template <
typename _Tp>
3096 inline constexpr
bool is_abstract_v = is_abstract<_Tp>::value;
3097 template <
typename _Tp>
3098 inline constexpr
bool is_final_v = is_final<_Tp>::value;
3099 template <
typename _Tp>
3100 inline constexpr
bool is_signed_v = is_signed<_Tp>::value;
3101 template <
typename _Tp>
3102 inline constexpr
bool is_unsigned_v = is_unsigned<_Tp>::value;
3103 template <
typename _Tp,
typename... _Args>
3104 inline constexpr
bool is_constructible_v =
3105 is_constructible<_Tp, _Args...>::value;
3106 template <
typename _Tp>
3107 inline constexpr
bool is_default_constructible_v =
3108 is_default_constructible<_Tp>::value;
3109 template <
typename _Tp>
3110 inline constexpr
bool is_copy_constructible_v =
3111 is_copy_constructible<_Tp>::value;
3112 template <
typename _Tp>
3113 inline constexpr
bool is_move_constructible_v =
3114 is_move_constructible<_Tp>::value;
3115 template <
typename _Tp,
typename _Up>
3116 inline constexpr
bool is_assignable_v = is_assignable<_Tp, _Up>::value;
3117 template <
typename _Tp>
3118 inline constexpr
bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
3119 template <
typename _Tp>
3120 inline constexpr
bool is_move_assignable_v = is_move_assignable<_Tp>::value;
3121 template <
typename _Tp>
3122 inline constexpr
bool is_destructible_v = is_destructible<_Tp>::value;
3123 template <
typename _Tp,
typename... _Args>
3124 inline constexpr
bool is_trivially_constructible_v =
3125 is_trivially_constructible<_Tp, _Args...>::value;
3126 template <
typename _Tp>
3127 inline constexpr
bool is_trivially_default_constructible_v =
3128 is_trivially_default_constructible<_Tp>::value;
3129 template <
typename _Tp>
3130 inline constexpr
bool is_trivially_copy_constructible_v =
3131 is_trivially_copy_constructible<_Tp>::value;
3132 template <
typename _Tp>
3133 inline constexpr
bool is_trivially_move_constructible_v =
3134 is_trivially_move_constructible<_Tp>::value;
3135 template <
typename _Tp,
typename _Up>
3136 inline constexpr
bool is_trivially_assignable_v =
3137 is_trivially_assignable<_Tp, _Up>::value;
3138 template <
typename _Tp>
3139 inline constexpr
bool is_trivially_copy_assignable_v =
3140 is_trivially_copy_assignable<_Tp>::value;
3141 template <
typename _Tp>
3142 inline constexpr
bool is_trivially_move_assignable_v =
3143 is_trivially_move_assignable<_Tp>::value;
3144 template <
typename _Tp>
3145 inline constexpr
bool is_trivially_destructible_v =
3146 is_trivially_destructible<_Tp>::value;
3147 template <
typename _Tp,
typename... _Args>
3148 inline constexpr
bool is_nothrow_constructible_v =
3149 is_nothrow_constructible<_Tp, _Args...>::value;
3150 template <
typename _Tp>
3151 inline constexpr
bool is_nothrow_default_constructible_v =
3152 is_nothrow_default_constructible<_Tp>::value;
3153 template <
typename _Tp>
3154 inline constexpr
bool is_nothrow_copy_constructible_v =
3155 is_nothrow_copy_constructible<_Tp>::value;
3156 template <
typename _Tp>
3157 inline constexpr
bool is_nothrow_move_constructible_v =
3158 is_nothrow_move_constructible<_Tp>::value;
3159 template <
typename _Tp,
typename _Up>
3160 inline constexpr
bool is_nothrow_assignable_v =
3161 is_nothrow_assignable<_Tp, _Up>::value;
3162 template <
typename _Tp>
3163 inline constexpr
bool is_nothrow_copy_assignable_v =
3164 is_nothrow_copy_assignable<_Tp>::value;
3165 template <
typename _Tp>
3166 inline constexpr
bool is_nothrow_move_assignable_v =
3167 is_nothrow_move_assignable<_Tp>::value;
3168 template <
typename _Tp>
3169 inline constexpr
bool is_nothrow_destructible_v =
3170 is_nothrow_destructible<_Tp>::value;
3171 template <
typename _Tp>
3172 inline constexpr
bool has_virtual_destructor_v =
3173 has_virtual_destructor<_Tp>::value;
3174 template <
typename _Tp>
3175 inline constexpr
size_t alignment_of_v = alignment_of<_Tp>::value;
3176 template <
typename _Tp>
3177 inline constexpr
size_t rank_v = rank<_Tp>::value;
3178 template <
typename _Tp,
unsigned _Idx = 0>
3179 inline constexpr
size_t extent_v = extent<_Tp, _Idx>::value;
3180 #ifdef _GLIBCXX_BUILTIN_IS_SAME_AS
3181 template <
typename _Tp,
typename _Up>
3182 inline constexpr
bool is_same_v = _GLIBCXX_BUILTIN_IS_SAME_AS(_Tp, _Up);
3184 template <
typename _Tp,
typename _Up>
3187 template <
typename _Base,
typename _Derived>
3188 inline constexpr
bool is_base_of_v = is_base_of<_Base, _Derived>::value;
3189 template <
typename _From,
typename _To>
3190 inline constexpr
bool is_convertible_v = is_convertible<_From, _To>::value;
3192 #ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
3193 # define __cpp_lib_has_unique_object_representations 201606
3195 template<
typename _Tp>
3196 struct has_unique_object_representations
3197 : bool_constant<__has_unique_object_representations(
3198 remove_cv_t<remove_all_extents_t<_Tp>>
3201 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
3202 "template argument must be a complete class or an unbounded array");
3205 template<
typename _Tp>
3206 inline constexpr
bool has_unique_object_representations_v
3207 = has_unique_object_representations<_Tp>::value;
3210 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
3211 # define __cpp_lib_is_aggregate 201703
3213 template<
typename _Tp>
3215 : bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
3219 template<
typename _Tp>
3220 inline constexpr
bool is_aggregate_v = is_aggregate<_Tp>::value;
3224 #if __cplusplus > 201703L
3225 #define __cpp_lib_remove_cvref 201711L
3228 template<
typename _Tp>
3231 using type = __remove_cvref_t<_Tp>;
3234 template<
typename _Tp>
3235 using remove_cvref_t = __remove_cvref_t<_Tp>;
3237 #define __cpp_lib_type_identity 201806L
3239 template<
typename _Tp>
3240 struct type_identity {
using type = _Tp; };
3242 template<
typename _Tp>
3243 using type_identity_t =
typename type_identity<_Tp>::type;
3245 #define __cpp_lib_unwrap_ref 201811L
3248 template<
typename _Tp>
3249 struct unwrap_reference {
using type = _Tp; };
3251 template<
typename _Tp>
3252 struct unwrap_reference<reference_wrapper<_Tp>> {
using type = _Tp&; };
3254 template<
typename _Tp>
3255 using unwrap_reference_t =
typename unwrap_reference<_Tp>::type;
3258 template<
typename _Tp>
3259 struct unwrap_ref_decay {
using type = unwrap_reference_t<decay_t<_Tp>>; };
3261 template<
typename _Tp>
3262 using unwrap_ref_decay_t =
typename unwrap_ref_decay<_Tp>::type;
3264 #define __cpp_lib_bounded_array_traits 201902L
3267 template<
typename _Tp>
3268 struct is_bounded_array
3269 :
public __is_array_known_bounds<_Tp>
3273 template<
typename _Tp>
3274 struct is_unbounded_array
3275 :
public __is_array_unknown_bounds<_Tp>
3278 template<
typename _Tp>
3279 inline constexpr
bool is_bounded_array_v
3280 = is_bounded_array<_Tp>::value;
3282 template<
typename _Tp>
3283 inline constexpr
bool is_unbounded_array_v
3284 = is_unbounded_array<_Tp>::value;
3286 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
3288 #define __cpp_lib_is_constant_evaluated 201811L
3290 constexpr
inline bool
3291 is_constant_evaluated() noexcept
3292 {
return __builtin_is_constant_evaluated(); }
3295 template<
typename _From,
typename _To>
3296 using __copy_cv =
typename __match_cv_qualifiers<_From, _To>::__type;
3298 template<
typename _Xp,
typename _Yp>
3300 = decltype(
false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());
3302 template<
typename _Ap,
typename _Bp,
typename =
void>
3303 struct __common_ref_impl
3307 template<
typename _Ap,
typename _Bp>
3308 using __common_ref =
typename __common_ref_impl<_Ap, _Bp>::type;
3311 template<
typename _Xp,
typename _Yp>
3312 struct __common_ref_impl<_Xp&, _Yp&,
3313 __void_t<__cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>>>
3314 {
using type = __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>; };
3317 template<
typename _Xp,
typename _Yp>
3318 using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&;
3321 template<
typename _Xp,
typename _Yp>
3322 struct __common_ref_impl<_Xp&&, _Yp&&,
3323 _Require<is_convertible<_Xp&&, __common_ref_C<_Xp, _Yp>>,
3324 is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>>
3325 {
using type = __common_ref_C<_Xp, _Yp>; };
3328 template<
typename _Xp,
typename _Yp>
3329 using __common_ref_D = __common_ref<const _Xp&, _Yp&>;
3332 template<
typename _Xp,
typename _Yp>
3333 struct __common_ref_impl<_Xp&&, _Yp&,
3334 _Require<is_convertible<_Xp&&, __common_ref_D<_Xp, _Yp>>>>
3335 {
using type = __common_ref_D<_Xp, _Yp>; };
3338 template<
typename _Xp,
typename _Yp>
3339 struct __common_ref_impl<_Xp&, _Yp&&>
3340 : __common_ref_impl<_Yp&&, _Xp&>
3343 template<
typename _Tp,
typename _Up,
3344 template<
typename>
class _TQual,
template<
typename>
class _UQual>
3345 struct basic_common_reference
3348 template<
typename _Tp>
3350 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>; };
3352 template<
typename _Tp>
3354 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>&; };
3356 template<
typename _Tp>
3357 struct __xref<_Tp&&>
3358 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>&&; };
3360 template<
typename _Tp1,
typename _Tp2>
3361 using __basic_common_ref
3362 =
typename basic_common_reference<remove_cvref_t<_Tp1>,
3363 remove_cvref_t<_Tp2>,
3364 __xref<_Tp1>::template __type,
3365 __xref<_Tp2>::template __type>::type;
3367 template<
typename... _Tp>
3368 struct common_reference;
3370 template<
typename... _Tp>
3371 using common_reference_t =
typename common_reference<_Tp...>::type;
3375 struct common_reference<>
3379 template<
typename _Tp0>
3380 struct common_reference<_Tp0>
3381 {
using type = _Tp0; };
3383 template<
typename _Tp1,
typename _Tp2,
int _Bullet = 1,
typename =
void>
3384 struct __common_reference_impl
3385 : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
3389 template<
typename _Tp1,
typename _Tp2>
3390 struct common_reference<_Tp1, _Tp2>
3391 : __common_reference_impl<_Tp1, _Tp2>
3395 template<
typename _Tp1,
typename _Tp2>
3396 struct __common_reference_impl<_Tp1&, _Tp2&, 1,
3397 void_t<__common_ref<_Tp1&, _Tp2&>>>
3398 {
using type = __common_ref<_Tp1&, _Tp2&>; };
3400 template<
typename _Tp1,
typename _Tp2>
3401 struct __common_reference_impl<_Tp1&&, _Tp2&&, 1,
3402 void_t<__common_ref<_Tp1&&, _Tp2&&>>>
3403 {
using type = __common_ref<_Tp1&&, _Tp2&&>; };
3405 template<
typename _Tp1,
typename _Tp2>
3406 struct __common_reference_impl<_Tp1&, _Tp2&&, 1,
3407 void_t<__common_ref<_Tp1&, _Tp2&&>>>
3408 {
using type = __common_ref<_Tp1&, _Tp2&&>; };
3410 template<
typename _Tp1,
typename _Tp2>
3411 struct __common_reference_impl<_Tp1&&, _Tp2&, 1,
3412 void_t<__common_ref<_Tp1&&, _Tp2&>>>
3413 {
using type = __common_ref<_Tp1&&, _Tp2&>; };
3416 template<
typename _Tp1,
typename _Tp2>
3417 struct __common_reference_impl<_Tp1, _Tp2, 2,
3418 void_t<__basic_common_ref<_Tp1, _Tp2>>>
3419 {
using type = __basic_common_ref<_Tp1, _Tp2>; };
3422 template<
typename _Tp1,
typename _Tp2>
3423 struct __common_reference_impl<_Tp1, _Tp2, 3,
3424 void_t<__cond_res<_Tp1, _Tp2>>>
3425 {
using type = __cond_res<_Tp1, _Tp2>; };
3428 template<
typename _Tp1,
typename _Tp2>
3429 struct __common_reference_impl<_Tp1, _Tp2, 4,
3431 {
using type = common_type_t<_Tp1, _Tp2>; };
3434 template<
typename _Tp1,
typename _Tp2>
3435 struct __common_reference_impl<_Tp1, _Tp2, 5, void>
3439 template<
typename _Tp1,
typename _Tp2,
typename... _Rest>
3440 struct common_reference<_Tp1, _Tp2, _Rest...>
3441 : __common_type_fold<common_reference<_Tp1, _Tp2>,
3442 __common_type_pack<_Rest...>>
3446 template<
typename _Tp1,
typename _Tp2,
typename... _Rest>
3447 struct __common_type_fold<common_reference<_Tp1, _Tp2>,
3448 __common_type_pack<_Rest...>,
3449 void_t<common_reference_t<_Tp1, _Tp2>>>
3450 :
public common_reference<common_reference_t<_Tp1, _Tp2>, _Rest...>
3455 _GLIBCXX_END_NAMESPACE_VERSION
3460 #endif // _GLIBCXX_TYPE_TRAITS
typename result_of< _Tp >::type result_of_t
Alias template for result_of.
is_nothrow_copy_constructible
Provide aligned storage for types.
The underlying type of an enum.
typename add_volatile< _Tp >::type add_volatile_t
Alias template for add_volatile.
is_trivially_copy_constructible
typename remove_all_extents< _Tp >::type remove_all_extents_t
Alias template for remove_all_extents.
is_nothrow_default_constructible
typename conditional< _Cond, _Iftrue, _Iffalse >::type conditional_t
Alias template for conditional.
aligned_storage< _S_len, alignment_value >::type type
The storage.
typename add_rvalue_reference< _Tp >::type add_rvalue_reference_t
Alias template for add_rvalue_reference.
is_trivially_move_assignable
is_nothrow_copy_assignable
constexpr bool is_nothrow_swappable_with_v
is_nothrow_swappable_with_v
Define a member typedef type only if a boolean constant is true.
Metafunctions used for detecting swappable types: p0185r1.
typename add_const< _Tp >::type add_const_t
Alias template for add_const.
constexpr bool is_swappable_with_v
is_swappable_with_v
typename remove_volatile< _Tp >::type remove_volatile_t
Alias template for remove_volatile.
typename aligned_storage< _Len, _Align >::type aligned_storage_t
Alias template for aligned_storage.
is_nothrow_move_constructible
is_member_function_pointer
constexpr bool is_nothrow_swappable_v
is_nothrow_swappable_v
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
is_null_pointer (LWG 2247).
Primary class template for reference_wrapper.
is_trivially_copy_assignable
__is_nullptr_t (deprecated extension).
void void_t
A metafunction that always yields void, used for detecting valid types.
is_trivially_destructible
typename make_signed< _Tp >::type make_signed_t
Alias template for make_signed.
constexpr bool is_swappable_v
is_swappable_v
typename common_type< _Tp...>::type common_type_t
Alias template for common_type.
typename add_pointer< _Tp >::type add_pointer_t
Alias template for add_pointer.
is_nothrow_move_assignable
typename add_lvalue_reference< _Tp >::type add_lvalue_reference_t
Alias template for add_lvalue_reference.
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
is_trivially_constructible
Define a member typedef type to one of two argument types.
is_pod (deprecated in C++20)
typename remove_cv< _Tp >::type remove_cv_t
Alias template for remove_cv.
typename remove_pointer< _Tp >::type remove_pointer_t
Alias template for remove_pointer.
typename remove_const< _Tp >::type remove_const_t
Alias template for remove_const.
typename underlying_type< _Tp >::type underlying_type_t
Alias template for underlying_type.
is_nothrow_swappable_with
is_trivially_move_constructible
typename remove_extent< _Tp >::type remove_extent_t
Alias template for remove_extent.
typename add_cv< _Tp >::type add_cv_t
Alias template for add_cv.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
typename enable_if< _Cond, _Tp >::type enable_if_t
Alias template for enable_if.
Implementation of the detection idiom (negative case).
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
is_trivially_default_constructible
typename decay< _Tp >::type decay_t
Alias template for decay.