29#ifndef _GLIBCXX_TYPE_TRAITS
30#define _GLIBCXX_TYPE_TRAITS 1
32#pragma GCC system_header
34#if __cplusplus < 201103L
40namespace 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>
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())>
845 static true_type __test(
int);
848 static false_type __test(...);
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
1495#if __cplusplus > 201703L
1496#define __cpp_lib_is_nothrow_convertible 201806L
1498 template<
typename _From,
typename _To>
1499 struct is_nothrow_convertible
1500 :
public __is_nt_convertible_helper<_From, _To>::type
1504 template<
typename _From,
typename _To>
1505 inline constexpr bool is_nothrow_convertible_v
1506 = is_nothrow_convertible<_From, _To>::value;
1512 template<
typename _Tp>
1514 {
typedef _Tp type; };
1516 template<
typename _Tp>
1518 {
typedef _Tp type; };
1521 template<
typename _Tp>
1523 {
typedef _Tp type; };
1525 template<
typename _Tp>
1527 {
typedef _Tp type; };
1530 template<
typename _Tp>
1532 {
using type = _Tp; };
1534 template<
typename _Tp>
1536 {
using type = _Tp; };
1538 template<
typename _Tp>
1539 struct remove_cv<volatile _Tp>
1540 {
using type = _Tp; };
1542 template<
typename _Tp>
1543 struct remove_cv<const volatile _Tp>
1544 {
using type = _Tp; };
1547 template<
typename _Tp>
1549 {
typedef _Tp
const type; };
1552 template<
typename _Tp>
1554 {
typedef _Tp
volatile type; };
1557 template<
typename _Tp>
1564#if __cplusplus > 201103L
1566#define __cpp_lib_transformation_trait_aliases 201304
1569 template<
typename _Tp>
1573 template<
typename _Tp>
1577 template<
typename _Tp>
1581 template<
typename _Tp>
1585 template<
typename _Tp>
1589 template<
typename _Tp>
1596 template<
typename _Tp>
1598 {
typedef _Tp type; };
1600 template<
typename _Tp>
1602 {
typedef _Tp type; };
1604 template<
typename _Tp>
1605 struct remove_reference<_Tp&&>
1606 {
typedef _Tp type; };
1608 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1609 struct __add_lvalue_reference_helper
1610 {
typedef _Tp type; };
1612 template<
typename _Tp>
1613 struct __add_lvalue_reference_helper<_Tp, true>
1614 {
typedef _Tp& type; };
1617 template<
typename _Tp>
1619 :
public __add_lvalue_reference_helper<_Tp>
1622 template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1623 struct __add_rvalue_reference_helper
1624 {
typedef _Tp type; };
1626 template<
typename _Tp>
1627 struct __add_rvalue_reference_helper<_Tp, true>
1628 {
typedef _Tp&& type; };
1631 template<
typename _Tp>
1633 :
public __add_rvalue_reference_helper<_Tp>
1636#if __cplusplus > 201103L
1638 template<
typename _Tp>
1642 template<
typename _Tp>
1646 template<
typename _Tp>
1655 template<
typename _Unqualified,
bool _IsConst,
bool _IsVol>
1656 struct __cv_selector;
1658 template<
typename _Unqualified>
1659 struct __cv_selector<_Unqualified, false, false>
1660 {
typedef _Unqualified __type; };
1662 template<
typename _Unqualified>
1663 struct __cv_selector<_Unqualified, false, true>
1664 {
typedef volatile _Unqualified __type; };
1666 template<
typename _Unqualified>
1667 struct __cv_selector<_Unqualified, true, false>
1668 {
typedef const _Unqualified __type; };
1670 template<
typename _Unqualified>
1671 struct __cv_selector<_Unqualified, true, true>
1672 {
typedef const volatile _Unqualified __type; };
1674 template<
typename _Qualified,
typename _Unqualified,
1675 bool _IsConst = is_const<_Qualified>::value,
1676 bool _IsVol = is_volatile<_Qualified>::value>
1677 class __match_cv_qualifiers
1679 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
1682 typedef typename __match::__type __type;
1686 template<
typename _Tp>
1687 struct __make_unsigned
1688 {
typedef _Tp __type; };
1691 struct __make_unsigned<char>
1692 {
typedef unsigned char __type; };
1695 struct __make_unsigned<signed char>
1696 {
typedef unsigned char __type; };
1699 struct __make_unsigned<short>
1700 {
typedef unsigned short __type; };
1703 struct __make_unsigned<int>
1704 {
typedef unsigned int __type; };
1707 struct __make_unsigned<long>
1708 {
typedef unsigned long __type; };
1711 struct __make_unsigned<long long>
1712 {
typedef unsigned long long __type; };
1714#if defined(__GLIBCXX_TYPE_INT_N_0)
1716 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0>
1717 {
typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; };
1719#if defined(__GLIBCXX_TYPE_INT_N_1)
1721 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1>
1722 {
typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; };
1724#if defined(__GLIBCXX_TYPE_INT_N_2)
1726 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2>
1727 {
typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; };
1729#if defined(__GLIBCXX_TYPE_INT_N_3)
1731 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3>
1732 {
typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; };
1736 template<
typename _Tp,
1737 bool _IsInt = is_integral<_Tp>::value,
1738 bool _IsEnum = is_enum<_Tp>::value>
1739 class __make_unsigned_selector;
1741 template<
typename _Tp>
1742 class __make_unsigned_selector<_Tp, true, false>
1744 using __unsigned_type
1745 =
typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
1749 =
typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1752 class __make_unsigned_selector_base
1755 template<
typename...>
struct _List { };
1757 template<
typename _Tp,
typename... _Up>
1758 struct _List<_Tp, _Up...> : _List<_Up...>
1759 {
static constexpr size_t __size =
sizeof(_Tp); };
1761 template<
size_t _Sz,
typename _Tp,
bool = (_Sz <= _Tp::__size)>
1764 template<
size_t _Sz,
typename _U
int,
typename... _UInts>
1765 struct __select<_Sz, _List<_Uint, _UInts...>,
true>
1766 {
using __type = _Uint; };
1768 template<
size_t _Sz,
typename _Uint,
typename... _UInts>
1769 struct __select<_Sz, _List<_Uint, _UInts...>, false>
1770 : __select<_Sz, _List<_UInts...>>
1775 template<
typename _Tp>
1776 class __make_unsigned_selector<_Tp, false, true>
1777 : __make_unsigned_selector_base
1780 using _UInts = _List<
unsigned char,
unsigned short,
unsigned int,
1781 unsigned long,
unsigned long long>;
1783 using __unsigned_type =
typename __select<
sizeof(_Tp), _UInts>::__type;
1787 =
typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1794#ifdef __WCHAR_TYPE__
1796 struct __make_unsigned<wchar_t>
1799 =
typename __make_unsigned_selector<wchar_t, false, true>::__type;
1803#ifdef _GLIBCXX_USE_CHAR8_T
1805 struct __make_unsigned<char8_t>
1808 =
typename __make_unsigned_selector<char8_t, false, true>::__type;
1813 struct __make_unsigned<char16_t>
1816 =
typename __make_unsigned_selector<char16_t, false, true>::__type;
1820 struct __make_unsigned<char32_t>
1823 =
typename __make_unsigned_selector<char32_t, false, true>::__type;
1831 template<
typename _Tp>
1833 {
typedef typename __make_unsigned_selector<_Tp>::__type type; };
1842 template<
typename _Tp>
1843 struct __make_signed
1844 {
typedef _Tp __type; };
1847 struct __make_signed<char>
1848 {
typedef signed char __type; };
1851 struct __make_signed<unsigned char>
1852 {
typedef signed char __type; };
1855 struct __make_signed<unsigned short>
1856 {
typedef signed short __type; };
1859 struct __make_signed<unsigned int>
1860 {
typedef signed int __type; };
1863 struct __make_signed<unsigned long>
1864 {
typedef signed long __type; };
1867 struct __make_signed<unsigned long long>
1868 {
typedef signed long long __type; };
1870#if defined(__GLIBCXX_TYPE_INT_N_0)
1872 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0>
1873 {
typedef __GLIBCXX_TYPE_INT_N_0 __type; };
1875#if defined(__GLIBCXX_TYPE_INT_N_1)
1877 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1>
1878 {
typedef __GLIBCXX_TYPE_INT_N_1 __type; };
1880#if defined(__GLIBCXX_TYPE_INT_N_2)
1882 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2>
1883 {
typedef __GLIBCXX_TYPE_INT_N_2 __type; };
1885#if defined(__GLIBCXX_TYPE_INT_N_3)
1887 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3>
1888 {
typedef __GLIBCXX_TYPE_INT_N_3 __type; };
1892 template<
typename _Tp,
1893 bool _IsInt = is_integral<_Tp>::value,
1894 bool _IsEnum = is_enum<_Tp>::value>
1895 class __make_signed_selector;
1897 template<
typename _Tp>
1898 class __make_signed_selector<_Tp, true, false>
1901 =
typename __make_signed<__remove_cv_t<_Tp>>::__type;
1905 =
typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
1909 template<
typename _Tp>
1910 class __make_signed_selector<_Tp, false, true>
1912 typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
1915 typedef typename __make_signed_selector<__unsigned_type>::__type __type;
1922#if defined(__WCHAR_TYPE__)
1924 struct __make_signed<wchar_t>
1927 =
typename __make_signed_selector<wchar_t, false, true>::__type;
1931#if defined(_GLIBCXX_USE_CHAR8_T)
1933 struct __make_signed<char8_t>
1936 =
typename __make_signed_selector<char8_t, false, true>::__type;
1941 struct __make_signed<char16_t>
1944 =
typename __make_signed_selector<char16_t, false, true>::__type;
1948 struct __make_signed<char32_t>
1951 =
typename __make_signed_selector<char32_t, false, true>::__type;
1959 template<
typename _Tp>
1961 {
typedef typename __make_signed_selector<_Tp>::__type type; };
1967#if __cplusplus > 201103L
1969 template<
typename _Tp>
1973 template<
typename _Tp>
1980 template<
typename _Tp>
1982 {
typedef _Tp type; };
1984 template<
typename _Tp, std::
size_t _Size>
1986 {
typedef _Tp type; };
1988 template<
typename _Tp>
1989 struct remove_extent<_Tp[]>
1990 {
typedef _Tp type; };
1993 template<
typename _Tp>
1995 {
typedef _Tp type; };
1997 template<
typename _Tp, std::
size_t _Size>
1999 {
typedef typename remove_all_extents<_Tp>::type type; };
2001 template<
typename _Tp>
2002 struct remove_all_extents<_Tp[]>
2003 {
typedef typename remove_all_extents<_Tp>::type type; };
2005#if __cplusplus > 201103L
2007 template<
typename _Tp>
2011 template<
typename _Tp>
2017 template<
typename _Tp,
typename>
2018 struct __remove_pointer_helper
2019 {
typedef _Tp type; };
2021 template<
typename _Tp,
typename _Up>
2022 struct __remove_pointer_helper<_Tp, _Up*>
2023 {
typedef _Up type; };
2026 template<
typename _Tp>
2028 :
public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
2031 template<
typename _Tp,
bool = __or_<__is_referenceable<_Tp>,
2032 is_
void<_Tp>>::value>
2033 struct __add_pointer_helper
2034 {
typedef _Tp type; };
2036 template<
typename _Tp>
2037 struct __add_pointer_helper<_Tp, true>
2038 {
typedef typename remove_reference<_Tp>::type* type; };
2041 template<
typename _Tp>
2043 :
public __add_pointer_helper<_Tp>
2046#if __cplusplus > 201103L
2048 template<
typename _Tp>
2052 template<
typename _Tp>
2056 template<std::
size_t _Len>
2057 struct __aligned_storage_msa
2061 unsigned char __data[_Len];
2062 struct __attribute__((__aligned__)) { } __align;
2076 template<std::size_t _Len, std::size_t _Align =
2077 __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
2082 unsigned char __data[_Len];
2083 struct __attribute__((__aligned__((_Align)))) { } __align;
2087 template <
typename... _Types>
2088 struct __strictest_alignment
2090 static const size_t _S_alignment = 0;
2091 static const size_t _S_size = 0;
2094 template <
typename _Tp,
typename... _Types>
2095 struct __strictest_alignment<_Tp, _Types...>
2097 static const size_t _S_alignment =
2098 alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
2099 ?
alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
2100 static const size_t _S_size =
2101 sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
2102 ?
sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
2115 template <
size_t _Len,
typename... _Types>
2119 static_assert(
sizeof...(_Types) != 0,
"At least one type is required");
2121 using __strictest = __strictest_alignment<_Types...>;
2122 static const size_t _S_len = _Len > __strictest::_S_size
2123 ? _Len : __strictest::_S_size;
2131 template <
size_t _Len,
typename... _Types>
2132 const size_t aligned_union<_Len, _Types...>::alignment_value;
2138 template<
typename _Up,
2141 struct __decay_selector;
2144 template<
typename _Up>
2145 struct __decay_selector<_Up, false, false>
2146 {
typedef __remove_cv_t<_Up> __type; };
2148 template<
typename _Up>
2149 struct __decay_selector<_Up, true, false>
2150 {
typedef typename remove_extent<_Up>::type* __type; };
2152 template<
typename _Up>
2153 struct __decay_selector<_Up, false, true>
2154 {
typedef typename add_pointer<_Up>::type __type; };
2158 template<
typename _Tp>
2161 typedef typename remove_reference<_Tp>::type __remove_type;
2164 typedef typename __decay_selector<__remove_type>::__type type;
2170 template<
typename _Tp>
2171 struct __strip_reference_wrapper
2176 template<
typename _Tp>
2177 struct __strip_reference_wrapper<reference_wrapper<_Tp> >
2179 typedef _Tp& __type;
2183 template<
typename _Tp>
2184 using __decay_t =
typename decay<_Tp>::type;
2186 template<
typename _Tp>
2187 using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
2192 template<
bool,
typename _Tp =
void>
2197 template<
typename _Tp>
2199 {
typedef _Tp type; };
2204 template<
bool _Cond,
typename _Tp =
void>
2205 using __enable_if_t =
typename enable_if<_Cond, _Tp>::type;
2208 template<
typename... _Cond>
2209 using _Require = __enable_if_t<__and_<_Cond...>::value>;
2212 template<
typename _Tp>
2213 using __remove_cvref_t
2214 =
typename remove_cv<typename remove_reference<_Tp>::type>::type;
2219 template<
bool _Cond,
typename _Iftrue,
typename _Iffalse>
2221 {
typedef _Iftrue
type; };
2224 template<
typename _Iftrue,
typename _Iffalse>
2226 {
typedef _Iffalse type; };
2229 template<
typename... _Tp>
2235 struct __do_common_type_impl
2237 template<
typename _Tp,
typename _Up>
2239 =
decltype(
true ? std::declval<_Tp>() :
std::
declval<_Up>());
2243 template<
typename _Tp,
typename _Up>
2244 static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
2247#if __cplusplus > 201703L
2250 template<
typename _Tp,
typename _Up>
2251 static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>>
2255 template<
typename,
typename>
2256 static __failure_type
2259 template<
typename _Tp,
typename _Up>
2260 static decltype(_S_test_2<_Tp, _Up>(0))
2270 template<
typename _Tp0>
2271 struct common_type<_Tp0>
2272 :
public common_type<_Tp0, _Tp0>
2276 template<
typename _Tp1,
typename _Tp2,
2277 typename _Dp1 = __decay_t<_Tp1>,
typename _Dp2 = __decay_t<_Tp2>>
2278 struct __common_type_impl
2282 using type = common_type<_Dp1, _Dp2>;
2285 template<
typename _Tp1,
typename _Tp2>
2286 struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
2287 :
private __do_common_type_impl
2291 using type =
decltype(_S_test<_Tp1, _Tp2>(0));
2295 template<
typename _Tp1,
typename _Tp2>
2296 struct common_type<_Tp1, _Tp2>
2297 :
public __common_type_impl<_Tp1, _Tp2>::type
2300 template<
typename...>
2301 struct __common_type_pack
2304 template<
typename,
typename,
typename =
void>
2305 struct __common_type_fold;
2308 template<
typename _Tp1,
typename _Tp2,
typename... _Rp>
2309 struct common_type<_Tp1, _Tp2, _Rp...>
2310 :
public __common_type_fold<common_type<_Tp1, _Tp2>,
2311 __common_type_pack<_Rp...>>
2317 template<
typename _CTp,
typename... _Rp>
2318 struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
2319 __void_t<typename _CTp::type>>
2320 :
public common_type<typename _CTp::type, _Rp...>
2324 template<
typename _CTp,
typename _Rp>
2325 struct __common_type_fold<_CTp, _Rp, void>
2328 template<typename _Tp, bool = is_enum<_Tp>::value>
2329 struct __underlying_type_impl
2331 using type = __underlying_type(_Tp);
2334 template<
typename _Tp>
2335 struct __underlying_type_impl<_Tp, false>
2340 template<
typename _Tp>
2342 :
public __underlying_type_impl<_Tp>
2346 template<
typename _Tp>
2347 struct __declval_protector
2349 static const bool __stop =
false;
2357 template<
typename _Tp>
2358 auto declval() noexcept -> decltype(__declval<_Tp>(0))
2360 static_assert(__declval_protector<_Tp>::__stop,
2361 "declval() must not be used!");
2362 return __declval<_Tp>(0);
2366 template<
typename _Signature>
2371#define __cpp_lib_result_of_sfinae 201210
2374 struct __invoke_memfun_ref { };
2375 struct __invoke_memfun_deref { };
2376 struct __invoke_memobj_ref { };
2377 struct __invoke_memobj_deref { };
2378 struct __invoke_other { };
2381 template<
typename _Tp,
typename _Tag>
2382 struct __result_of_success : __success_type<_Tp>
2383 {
using __invoke_type = _Tag; };
2386 struct __result_of_memfun_ref_impl
2388 template<
typename _Fp,
typename _Tp1,
typename... _Args>
2389 static __result_of_success<
decltype(
2390 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
2391 ), __invoke_memfun_ref> _S_test(
int);
2393 template<
typename...>
2394 static __failure_type _S_test(...);
2397 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2398 struct __result_of_memfun_ref
2399 :
private __result_of_memfun_ref_impl
2401 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2405 struct __result_of_memfun_deref_impl
2407 template<
typename _Fp,
typename _Tp1,
typename... _Args>
2408 static __result_of_success<
decltype(
2409 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
2410 ), __invoke_memfun_deref> _S_test(
int);
2412 template<
typename...>
2413 static __failure_type _S_test(...);
2416 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2417 struct __result_of_memfun_deref
2418 :
private __result_of_memfun_deref_impl
2420 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2424 struct __result_of_memobj_ref_impl
2426 template<
typename _Fp,
typename _Tp1>
2427 static __result_of_success<
decltype(
2428 std::declval<_Tp1>().*std::declval<_Fp>()
2429 ), __invoke_memobj_ref> _S_test(
int);
2431 template<
typename,
typename>
2432 static __failure_type _S_test(...);
2435 template<
typename _MemPtr,
typename _Arg>
2436 struct __result_of_memobj_ref
2437 :
private __result_of_memobj_ref_impl
2439 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2443 struct __result_of_memobj_deref_impl
2445 template<
typename _Fp,
typename _Tp1>
2446 static __result_of_success<
decltype(
2447 (*std::declval<_Tp1>()).*std::declval<_Fp>()
2448 ), __invoke_memobj_deref> _S_test(
int);
2450 template<
typename,
typename>
2451 static __failure_type _S_test(...);
2454 template<
typename _MemPtr,
typename _Arg>
2455 struct __result_of_memobj_deref
2456 :
private __result_of_memobj_deref_impl
2458 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2461 template<
typename _MemPtr,
typename _Arg>
2462 struct __result_of_memobj;
2464 template<
typename _Res,
typename _Class,
typename _Arg>
2465 struct __result_of_memobj<_Res _Class::*, _Arg>
2467 typedef __remove_cvref_t<_Arg> _Argval;
2468 typedef _Res _Class::* _MemPtr;
2469 typedef typename conditional<__or_<is_same<_Argval, _Class>,
2470 is_base_of<_Class, _Argval>>::value,
2471 __result_of_memobj_ref<_MemPtr, _Arg>,
2472 __result_of_memobj_deref<_MemPtr, _Arg>
2476 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2477 struct __result_of_memfun;
2479 template<
typename _Res,
typename _Class,
typename _Arg,
typename... _Args>
2480 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
2482 typedef typename remove_reference<_Arg>::type _Argval;
2483 typedef _Res _Class::* _MemPtr;
2484 typedef typename conditional<is_base_of<_Class, _Argval>::value,
2485 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
2486 __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
2495 template<
typename _Tp,
typename _Up = __remove_cvref_t<_Tp>>
2501 template<
typename _Tp,
typename _Up>
2502 struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
2507 template<bool, bool,
typename _Functor,
typename... _ArgTypes>
2508 struct __result_of_impl
2510 typedef __failure_type type;
2513 template<
typename _MemPtr,
typename _Arg>
2514 struct __result_of_impl<true, false, _MemPtr, _Arg>
2515 :
public __result_of_memobj<__decay_t<_MemPtr>,
2516 typename __inv_unwrap<_Arg>::type>
2519 template<
typename _MemPtr,
typename _Arg,
typename... _Args>
2520 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
2521 :
public __result_of_memfun<__decay_t<_MemPtr>,
2522 typename __inv_unwrap<_Arg>::type, _Args...>
2526 struct __result_of_other_impl
2528 template<
typename _Fn,
typename... _Args>
2529 static __result_of_success<
decltype(
2530 std::declval<_Fn>()(std::declval<_Args>()...)
2531 ), __invoke_other> _S_test(
int);
2533 template<
typename...>
2534 static __failure_type _S_test(...);
2537 template<
typename _Functor,
typename... _ArgTypes>
2538 struct __result_of_impl<false, false, _Functor, _ArgTypes...>
2539 :
private __result_of_other_impl
2541 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2545 template<typename _Functor, typename... _ArgTypes>
2546 struct __invoke_result
2547 : public __result_of_impl<
2548 is_member_object_pointer<
2549 typename remove_reference<_Functor>::type
2551 is_member_function_pointer<
2552 typename remove_reference<_Functor>::type
2554 _Functor, _ArgTypes...
2559 template<
typename _Functor,
typename... _ArgTypes>
2560 struct result_of<_Functor(_ArgTypes...)>
2561 :
public __invoke_result<_Functor, _ArgTypes...>
2564#if __cplusplus >= 201402L
2566 template<
size_t _Len,
size_t _Align =
2567 __alignof__(
typename __aligned_storage_msa<_Len>::__type)>
2570 template <
size_t _Len,
typename... _Types>
2571 using aligned_union_t =
typename aligned_union<_Len, _Types...>::type;
2574 template<
typename _Tp>
2578 template<
bool _Cond,
typename _Tp =
void>
2582 template<
bool _Cond,
typename _Iftrue,
typename _Iffalse>
2586 template<
typename... _Tp>
2590 template<
typename _Tp>
2594 template<
typename _Tp>
2598#if __cplusplus >= 201703L || !defined(__STRICT_ANSI__)
2599#define __cpp_lib_void_t 201411
2607 template<
typename _Default,
typename _AlwaysVoid,
2608 template<
typename...>
class _Op,
typename... _Args>
2612 using type = _Default;
2616 template<
typename _Default,
template<
typename...>
class _Op,
2618 struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
2620 using value_t = true_type;
2621 using type = _Op<_Args...>;
2625 template<
typename _Default,
template<
typename...>
class _Op,
2627 using __detected_or = __detector<_Default, void, _Op, _Args...>;
2630 template<
typename _Default,
template<
typename...>
class _Op,
2632 using __detected_or_t
2633 =
typename __detected_or<_Default, _Op, _Args...>::type;
2639#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \
2640 template<typename _Tp, typename = __void_t<>> \
2641 struct __has_##_NTYPE \
2644 template<typename _Tp> \
2645 struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> \
2649 template <
typename _Tp>
2650 struct __is_swappable;
2652 template <
typename _Tp>
2653 struct __is_nothrow_swappable;
2659 template<
typename... _Tps>
2660 struct __is_tuple_like_impl<tuple<_Tps...>> :
true_type
2664 template<
typename _Tp>
2665 struct __is_tuple_like
2666 :
public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
2670 template<
typename _Tp>
2671 _GLIBCXX20_CONSTEXPR
2673 _Require<__not_<__is_tuple_like<_Tp>>,
2674 is_move_constructible<_Tp>,
2675 is_move_assignable<_Tp>>
2677 noexcept(__and_<is_nothrow_move_constructible<_Tp>,
2678 is_nothrow_move_assignable<_Tp>>::value);
2680 template<
typename _Tp,
size_t _Nm>
2681 _GLIBCXX20_CONSTEXPR
2683 __enable_if_t<__is_swappable<_Tp>::value>
2684 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
2685 noexcept(__is_nothrow_swappable<_Tp>::value);
2688 namespace __swappable_details {
2691 struct __do_is_swappable_impl
2693 template<
typename _Tp,
typename
2694 =
decltype(
swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
2695 static true_type __test(
int);
2701 struct __do_is_nothrow_swappable_impl
2703 template<
typename _Tp>
2704 static __bool_constant<
2705 noexcept(
swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2714 template<
typename _Tp>
2715 struct __is_swappable_impl
2716 :
public __swappable_details::__do_is_swappable_impl
2718 typedef decltype(__test<_Tp>(0)) type;
2721 template<
typename _Tp>
2722 struct __is_nothrow_swappable_impl
2723 :
public __swappable_details::__do_is_nothrow_swappable_impl
2725 typedef decltype(__test<_Tp>(0)) type;
2728 template<
typename _Tp>
2729 struct __is_swappable
2730 :
public __is_swappable_impl<_Tp>::type
2733 template<
typename _Tp>
2734 struct __is_nothrow_swappable
2735 :
public __is_nothrow_swappable_impl<_Tp>::type
2739#if __cplusplus > 201402L || !defined(__STRICT_ANSI__)
2740#define __cpp_lib_is_swappable 201603
2744 template<
typename _Tp>
2746 :
public __is_swappable_impl<_Tp>::type
2748 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2749 "template argument must be a complete class or an unbounded array");
2753 template<
typename _Tp>
2755 :
public __is_nothrow_swappable_impl<_Tp>::type
2757 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2758 "template argument must be a complete class or an unbounded array");
2761#if __cplusplus >= 201402L
2763 template<
typename _Tp>
2768 template<
typename _Tp>
2774 namespace __swappable_with_details {
2777 struct __do_is_swappable_with_impl
2779 template<
typename _Tp,
typename _Up,
typename
2780 =
decltype(
swap(std::declval<_Tp>(), std::declval<_Up>())),
2782 =
decltype(
swap(std::declval<_Up>(), std::declval<_Tp>()))>
2785 template<
typename,
typename>
2789 struct __do_is_nothrow_swappable_with_impl
2791 template<
typename _Tp,
typename _Up>
2792 static __bool_constant<
2793 noexcept(
swap(std::declval<_Tp>(), std::declval<_Up>()))
2795 noexcept(
swap(std::declval<_Up>(), std::declval<_Tp>()))
2798 template<
typename,
typename>
2804 template<
typename _Tp,
typename _Up>
2805 struct __is_swappable_with_impl
2806 :
public __swappable_with_details::__do_is_swappable_with_impl
2808 typedef decltype(__test<_Tp, _Up>(0)) type;
2812 template<
typename _Tp>
2813 struct __is_swappable_with_impl<_Tp&, _Tp&>
2814 :
public __swappable_details::__do_is_swappable_impl
2816 typedef decltype(__test<_Tp&>(0)) type;
2819 template<
typename _Tp,
typename _Up>
2820 struct __is_nothrow_swappable_with_impl
2821 :
public __swappable_with_details::__do_is_nothrow_swappable_with_impl
2823 typedef decltype(__test<_Tp, _Up>(0)) type;
2827 template<
typename _Tp>
2828 struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
2829 :
public __swappable_details::__do_is_nothrow_swappable_impl
2831 typedef decltype(__test<_Tp&>(0)) type;
2836 template<
typename _Tp,
typename _Up>
2838 :
public __is_swappable_with_impl<_Tp, _Up>::type
2840 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2841 "first template argument must be a complete class or an unbounded array");
2842 static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}),
2843 "second template argument must be a complete class or an unbounded array");
2847 template<
typename _Tp,
typename _Up>
2849 :
public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
2851 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2852 "first template argument must be a complete class or an unbounded array");
2853 static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}),
2854 "second template argument must be a complete class or an unbounded array");
2857#if __cplusplus >= 201402L
2859 template<
typename _Tp,
typename _Up>
2864 template<
typename _Tp,
typename _Up>
2876 template<
typename _Result,
typename _Ret,
2878 struct __is_invocable_impl
2885 template<
typename _Result,
typename _Ret>
2886 struct __is_invocable_impl<_Result, _Ret,
2888 __void_t<typename _Result::type>>
2891 using __nothrow_type = true_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>>
2906 static typename _Result::type _S_get() noexcept;
2908 template<typename _Tp>
2909 static
void _S_conv(_Tp) noexcept;
2912 template<typename _Tp,
bool _Check_Noex = false,
2913 typename = decltype(_S_conv<_Tp>(_S_get())),
2914 bool _Noex = noexcept(_S_conv<_Tp>(_S_get()))>
2915 static __bool_constant<_Check_Noex ? _Noex : true>
2918 template<typename _Tp,
bool = false>
2924 using type = decltype(_S_test<_Ret>(1));
2927 using __nothrow_type = decltype(_S_test<_Ret, true>(1));
2929#pragma GCC diagnostic pop
2931 template<
typename _Fn,
typename... _ArgTypes>
2932 struct __is_invocable
2933 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2936 template<
typename _Fn,
typename _Tp,
typename... _Args>
2937 constexpr bool __call_is_nt(__invoke_memfun_ref)
2939 using _Up =
typename __inv_unwrap<_Tp>::type;
2940 return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
2941 std::declval<_Args>()...));
2944 template<
typename _Fn,
typename _Tp,
typename... _Args>
2945 constexpr bool __call_is_nt(__invoke_memfun_deref)
2947 return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
2948 std::declval<_Args>()...));
2951 template<
typename _Fn,
typename _Tp>
2952 constexpr bool __call_is_nt(__invoke_memobj_ref)
2954 using _Up =
typename __inv_unwrap<_Tp>::type;
2955 return noexcept(std::declval<_Up>().*std::declval<_Fn>());
2958 template<
typename _Fn,
typename _Tp>
2959 constexpr bool __call_is_nt(__invoke_memobj_deref)
2961 return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
2964 template<
typename _Fn,
typename... _Args>
2965 constexpr bool __call_is_nt(__invoke_other)
2967 return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
2970 template<
typename _Result,
typename _Fn,
typename... _Args>
2971 struct __call_is_nothrow
2973 std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
2977 template<
typename _Fn,
typename... _Args>
2978 using __call_is_nothrow_
2979 = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
2982 template<
typename _Fn,
typename... _Args>
2983 struct __is_nothrow_invocable
2984 : __and_<__is_invocable<_Fn, _Args...>,
2985 __call_is_nothrow_<_Fn, _Args...>>::type
2988#pragma GCC diagnostic push
2989#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
2990 struct __nonesuchbase {};
2991 struct __nonesuch :
private __nonesuchbase {
2992 ~__nonesuch() =
delete;
2993 __nonesuch(__nonesuch
const&) =
delete;
2994 void operator=(__nonesuch
const&) =
delete;
2996#pragma GCC diagnostic pop
2999#if __cplusplus >= 201703L
3000# define __cpp_lib_is_invocable 201703
3003 template<
typename _Functor,
typename... _ArgTypes>
3005 :
public __invoke_result<_Functor, _ArgTypes...>
3007 static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}),
3008 "_Functor must be a complete class or an unbounded array");
3009 static_assert((std::__is_complete_or_unbounded(
3010 __type_identity<_ArgTypes>{}) && ...),
3011 "each argument type must be a complete class or an unbounded array");
3015 template<
typename _Fn,
typename... _Args>
3019 template<
typename _Fn,
typename... _ArgTypes>
3021 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
3023 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3024 "_Fn must be a complete class or an unbounded array");
3025 static_assert((std::__is_complete_or_unbounded(
3026 __type_identity<_ArgTypes>{}) && ...),
3027 "each argument type must be a complete class or an unbounded array");
3031 template<
typename _Ret,
typename _Fn,
typename... _ArgTypes>
3033 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
3035 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3036 "_Fn must be a complete class or an unbounded array");
3037 static_assert((std::__is_complete_or_unbounded(
3038 __type_identity<_ArgTypes>{}) && ...),
3039 "each argument type must be a complete class or an unbounded array");
3040 static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
3041 "_Ret must be a complete class or an unbounded array");
3045 template<
typename _Fn,
typename... _ArgTypes>
3047 : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
3048 __call_is_nothrow_<_Fn, _ArgTypes...>>::type
3050 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3051 "_Fn must be a complete class or an unbounded array");
3052 static_assert((std::__is_complete_or_unbounded(
3053 __type_identity<_ArgTypes>{}) && ...),
3054 "each argument type must be a complete class or an unbounded array");
3058 template<
typename _Result,
typename _Ret>
3059 using __is_nt_invocable_impl
3060 =
typename __is_invocable_impl<_Result, _Ret>::__nothrow_type;
3064 template<
typename _Ret,
typename _Fn,
typename... _ArgTypes>
3066 : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
3067 __call_is_nothrow_<_Fn, _ArgTypes...>>::type
3069 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
3070 "_Fn must be a complete class or an unbounded array");
3071 static_assert((std::__is_complete_or_unbounded(
3072 __type_identity<_ArgTypes>{}) && ...),
3073 "each argument type must be a complete class or an unbounded array");
3074 static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
3075 "_Ret must be a complete class or an unbounded array");
3079#if __cplusplus >= 201703L
3080# define __cpp_lib_type_trait_variable_templates 201510L
3094template <
typename _Tp>
3096template <
typename _Tp>
3098template <
typename _Tp>
3100template <
typename _Tp>
3102template <
typename _Tp>
3104template <
typename _Tp>
3106template <
typename _Tp>
3107 inline constexpr bool is_lvalue_reference_v =
3109template <
typename _Tp>
3110 inline constexpr bool is_rvalue_reference_v =
3112template <
typename _Tp>
3113 inline constexpr bool is_member_object_pointer_v =
3115template <
typename _Tp>
3116 inline constexpr bool is_member_function_pointer_v =
3118template <
typename _Tp>
3120template <
typename _Tp>
3122template <
typename _Tp>
3124template <
typename _Tp>
3126template <
typename _Tp>
3128template <
typename _Tp>
3130template <
typename _Tp>
3132template <
typename _Tp>
3134template <
typename _Tp>
3136template <
typename _Tp>
3138template <
typename _Tp>
3140template <
typename _Tp>
3142template <
typename _Tp>
3144template <
typename _Tp>
3146template <
typename _Tp>
3147 inline constexpr bool is_trivially_copyable_v =
3149template <
typename _Tp>
3151#pragma GCC diagnostic push
3152#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3153template <
typename _Tp>
3154 _GLIBCXX20_DEPRECATED(
"use is_standard_layout_v && is_trivial_v instead")
3155 inline constexpr
bool is_pod_v =
is_pod<_Tp>::value;
3156template <typename _Tp>
3157 _GLIBCXX17_DEPRECATED
3158 inline constexpr
bool is_literal_type_v =
is_literal_type<_Tp>::value;
3159#pragma GCC diagnostic pop
3160 template <
typename _Tp>
3162template <
typename _Tp>
3164template <
typename _Tp>
3166template <
typename _Tp>
3168template <
typename _Tp>
3170template <
typename _Tp>
3172template <
typename _Tp,
typename... _Args>
3173 inline constexpr bool is_constructible_v =
3175template <
typename _Tp>
3176 inline constexpr bool is_default_constructible_v =
3178template <
typename _Tp>
3179 inline constexpr bool is_copy_constructible_v =
3181template <
typename _Tp>
3182 inline constexpr bool is_move_constructible_v =
3184template <
typename _Tp,
typename _Up>
3186template <
typename _Tp>
3188template <
typename _Tp>
3190template <
typename _Tp>
3192template <
typename _Tp,
typename... _Args>
3193 inline constexpr bool is_trivially_constructible_v =
3195template <
typename _Tp>
3196 inline constexpr bool is_trivially_default_constructible_v =
3198template <
typename _Tp>
3199 inline constexpr bool is_trivially_copy_constructible_v =
3201template <
typename _Tp>
3202 inline constexpr bool is_trivially_move_constructible_v =
3204template <
typename _Tp,
typename _Up>
3205 inline constexpr bool is_trivially_assignable_v =
3207template <
typename _Tp>
3208 inline constexpr bool is_trivially_copy_assignable_v =
3210template <
typename _Tp>
3211 inline constexpr bool is_trivially_move_assignable_v =
3213template <
typename _Tp>
3214 inline constexpr bool is_trivially_destructible_v =
3216template <
typename _Tp,
typename... _Args>
3217 inline constexpr bool is_nothrow_constructible_v =
3219template <
typename _Tp>
3220 inline constexpr bool is_nothrow_default_constructible_v =
3222template <
typename _Tp>
3223 inline constexpr bool is_nothrow_copy_constructible_v =
3225template <
typename _Tp>
3226 inline constexpr bool is_nothrow_move_constructible_v =
3228template <
typename _Tp,
typename _Up>
3229 inline constexpr bool is_nothrow_assignable_v =
3231template <
typename _Tp>
3232 inline constexpr bool is_nothrow_copy_assignable_v =
3234template <
typename _Tp>
3235 inline constexpr bool is_nothrow_move_assignable_v =
3237template <
typename _Tp>
3238 inline constexpr bool is_nothrow_destructible_v =
3240template <
typename _Tp>
3241 inline constexpr bool has_virtual_destructor_v =
3243template <
typename _Tp>
3245template <
typename _Tp>
3247template <
typename _Tp,
unsigned _Idx = 0>
3249#ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME
3250template <
typename _Tp,
typename _Up>
3251 inline constexpr bool is_same_v = __is_same(_Tp, _Up);
3253template <
typename _Tp,
typename _Up>
3256template <
typename _Base,
typename _Derived>
3258template <
typename _From,
typename _To>
3260template<
typename _Fn,
typename... _Args>
3261 inline constexpr bool is_invocable_v =
is_invocable<_Fn, _Args...>::value;
3262template<
typename _Fn,
typename... _Args>
3263 inline constexpr bool is_nothrow_invocable_v
3265template<
typename _Ret,
typename _Fn,
typename... _Args>
3266 inline constexpr bool is_invocable_r_v
3268template<
typename _Ret,
typename _Fn,
typename... _Args>
3269 inline constexpr bool is_nothrow_invocable_r_v
3273#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
3274# define __cpp_lib_has_unique_object_representations 201606
3276 template<
typename _Tp>
3277 struct has_unique_object_representations
3279 remove_cv_t<remove_all_extents_t<_Tp>>
3282 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
3283 "template argument must be a complete class or an unbounded array");
3287 template<
typename _Tp>
3288 inline constexpr bool has_unique_object_representations_v
3289 = has_unique_object_representations<_Tp>::value;
3292#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
3293# define __cpp_lib_is_aggregate 201703
3295 template<
typename _Tp>
3301 template<
typename _Tp>
3302 inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
3306#if __cplusplus > 201703L
3307#define __cpp_lib_remove_cvref 201711L
3310 template<
typename _Tp>
3315 template<
typename _Tp>
3316 struct remove_cvref<_Tp&>
3320 template<
typename _Tp>
3321 struct remove_cvref<_Tp&&>
3325 template<
typename _Tp>
3326 using remove_cvref_t =
typename remove_cvref<_Tp>::type;
3328#define __cpp_lib_type_identity 201806L
3330 template<
typename _Tp>
3331 struct type_identity {
using type = _Tp; };
3333 template<
typename _Tp>
3334 using type_identity_t =
typename type_identity<_Tp>::type;
3336#define __cpp_lib_unwrap_ref 201811L
3339 template<
typename _Tp>
3340 struct unwrap_reference {
using type = _Tp; };
3342 template<
typename _Tp>
3343 struct unwrap_reference<reference_wrapper<_Tp>> {
using type = _Tp&; };
3345 template<
typename _Tp>
3346 using unwrap_reference_t =
typename unwrap_reference<_Tp>::type;
3349 template<
typename _Tp>
3350 struct unwrap_ref_decay {
using type = unwrap_reference_t<decay_t<_Tp>>; };
3352 template<
typename _Tp>
3353 using unwrap_ref_decay_t =
typename unwrap_ref_decay<_Tp>::type;
3355#define __cpp_lib_bounded_array_traits 201902L
3358 template<
typename _Tp>
3359 struct is_bounded_array
3360 :
public __is_array_known_bounds<_Tp>
3364 template<
typename _Tp>
3365 struct is_unbounded_array
3366 :
public __is_array_unknown_bounds<_Tp>
3370 template<
typename _Tp>
3371 inline constexpr bool is_bounded_array_v
3372 = is_bounded_array<_Tp>::value;
3375 template<
typename _Tp>
3376 inline constexpr bool is_unbounded_array_v
3377 = is_unbounded_array<_Tp>::value;
3379#if __cplusplus > 202002L
3380#define __cpp_lib_is_scoped_enum 202011L
3385 template<
typename _Tp>
3386 struct is_scoped_enum
3390 template<
typename _Tp>
3391 requires __is_enum(_Tp)
3392 &&
requires(_Tp __t) { __t = __t; }
3393 struct is_scoped_enum<_Tp>
3394 :
bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
3399 template<
typename _Tp>
3400 requires __is_enum(_Tp)
3401 &&
requires(_Tp __t) { __t = __t; }
3402 struct is_scoped_enum<const _Tp>
3403 :
bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
3409 template<
typename _Tp>
3410 inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
3413#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
3415#define __cpp_lib_is_constant_evaluated 201811L
3418 constexpr inline bool
3419 is_constant_evaluated() noexcept
3420 {
return __builtin_is_constant_evaluated(); }
3425 template<
typename _From,
typename _To>
3426 using __copy_cv =
typename __match_cv_qualifiers<_From, _To>::__type;
3428 template<
typename _Xp,
typename _Yp>
3430 =
decltype(
false ? declval<_Xp(&)()>()() :
declval<_Yp(&)()>()());
3432 template<
typename _Ap,
typename _Bp,
typename =
void>
3433 struct __common_ref_impl
3437 template<
typename _Ap,
typename _Bp>
3438 using __common_ref =
typename __common_ref_impl<_Ap, _Bp>::type;
3441 template<
typename _Xp,
typename _Yp>
3442 using __condres_cvref
3443 = __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>;
3446 template<
typename _Xp,
typename _Yp>
3447 struct __common_ref_impl<_Xp&, _Yp&, __void_t<__condres_cvref<_Xp, _Yp>>>
3448 : enable_if<is_reference_v<__condres_cvref<_Xp, _Yp>>,
3449 __condres_cvref<_Xp, _Yp>>
3453 template<
typename _Xp,
typename _Yp>
3454 using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&;
3457 template<
typename _Xp,
typename _Yp>
3458 struct __common_ref_impl<_Xp&&, _Yp&&,
3459 _Require<is_convertible<_Xp&&, __common_ref_C<_Xp, _Yp>>,
3460 is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>>
3461 {
using type = __common_ref_C<_Xp, _Yp>; };
3464 template<
typename _Xp,
typename _Yp>
3465 using __common_ref_D = __common_ref<const _Xp&, _Yp&>;
3468 template<
typename _Xp,
typename _Yp>
3469 struct __common_ref_impl<_Xp&&, _Yp&,
3470 _Require<is_convertible<_Xp&&, __common_ref_D<_Xp, _Yp>>>>
3471 {
using type = __common_ref_D<_Xp, _Yp>; };
3474 template<
typename _Xp,
typename _Yp>
3475 struct __common_ref_impl<_Xp&, _Yp&&>
3476 : __common_ref_impl<_Yp&&, _Xp&>
3480 template<
typename _Tp,
typename _Up,
3481 template<
typename>
class _TQual,
template<
typename>
class _UQual>
3482 struct basic_common_reference
3486 template<
typename _Tp>
3488 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>; };
3490 template<
typename _Tp>
3492 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>&; };
3494 template<
typename _Tp>
3495 struct __xref<_Tp&&>
3496 {
template<
typename _Up>
using __type = __copy_cv<_Tp, _Up>&&; };
3498 template<
typename _Tp1,
typename _Tp2>
3499 using __basic_common_ref
3500 =
typename basic_common_reference<remove_cvref_t<_Tp1>,
3501 remove_cvref_t<_Tp2>,
3502 __xref<_Tp1>::template __type,
3503 __xref<_Tp2>::template __type>::type;
3506 template<
typename... _Tp>
3507 struct common_reference;
3509 template<
typename... _Tp>
3510 using common_reference_t =
typename common_reference<_Tp...>::type;
3514 struct common_reference<>
3518 template<
typename _Tp0>
3519 struct common_reference<_Tp0>
3520 {
using type = _Tp0; };
3523 template<
typename _Tp1,
typename _Tp2,
int _Bullet = 1,
typename =
void>
3524 struct __common_reference_impl
3525 : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
3529 template<
typename _Tp1,
typename _Tp2>
3530 struct common_reference<_Tp1, _Tp2>
3531 : __common_reference_impl<_Tp1, _Tp2>
3535 template<
typename _Tp1,
typename _Tp2>
3536 struct __common_reference_impl<_Tp1&, _Tp2&, 1,
3537 void_t<__common_ref<_Tp1&, _Tp2&>>>
3538 {
using type = __common_ref<_Tp1&, _Tp2&>; };
3540 template<
typename _Tp1,
typename _Tp2>
3541 struct __common_reference_impl<_Tp1&&, _Tp2&&, 1,
3542 void_t<__common_ref<_Tp1&&, _Tp2&&>>>
3543 {
using type = __common_ref<_Tp1&&, _Tp2&&>; };
3545 template<
typename _Tp1,
typename _Tp2>
3546 struct __common_reference_impl<_Tp1&, _Tp2&&, 1,
3547 void_t<__common_ref<_Tp1&, _Tp2&&>>>
3548 {
using type = __common_ref<_Tp1&, _Tp2&&>; };
3550 template<
typename _Tp1,
typename _Tp2>
3551 struct __common_reference_impl<_Tp1&&, _Tp2&, 1,
3552 void_t<__common_ref<_Tp1&&, _Tp2&>>>
3553 {
using type = __common_ref<_Tp1&&, _Tp2&>; };
3556 template<
typename _Tp1,
typename _Tp2>
3557 struct __common_reference_impl<_Tp1, _Tp2, 2,
3558 void_t<__basic_common_ref<_Tp1, _Tp2>>>
3559 {
using type = __basic_common_ref<_Tp1, _Tp2>; };
3562 template<
typename _Tp1,
typename _Tp2>
3563 struct __common_reference_impl<_Tp1, _Tp2, 3,
3564 void_t<__cond_res<_Tp1, _Tp2>>>
3565 {
using type = __cond_res<_Tp1, _Tp2>; };
3568 template<
typename _Tp1,
typename _Tp2>
3569 struct __common_reference_impl<_Tp1, _Tp2, 4,
3571 {
using type = common_type_t<_Tp1, _Tp2>; };
3574 template<
typename _Tp1,
typename _Tp2>
3575 struct __common_reference_impl<_Tp1, _Tp2, 5, void>
3579 template<
typename _Tp1,
typename _Tp2,
typename... _Rest>
3580 struct common_reference<_Tp1, _Tp2, _Rest...>
3581 : __common_type_fold<common_reference<_Tp1, _Tp2>,
3582 __common_type_pack<_Rest...>>
3586 template<
typename _Tp1,
typename _Tp2,
typename... _Rest>
3587 struct __common_type_fold<common_reference<_Tp1, _Tp2>,
3588 __common_type_pack<_Rest...>,
3589 void_t<common_reference_t<_Tp1, _Tp2>>>
3590 :
public common_reference<common_reference_t<_Tp1, _Tp2>, _Rest...>
3598_GLIBCXX_END_NAMESPACE_VERSION
static const size_t alignment_value
The value of the strictest alignment of _Types.
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.
The bitset class represents a fixed-size sequence of bits.
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