1	// C++11 <type_traits> -*- C++ -*-
2
3	// Copyright (C) 2007-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the
7	// terms of the GNU General Public License as published by the
8	// Free Software Foundation; either version 3, or (at your option)
9	// any later version.
10
11	// This library is distributed in the hope that it will be useful,
12	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	// GNU General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/** @file include/type_traits
26	* This is a Standard C++ Library header.
27	*/
28
29	#ifndef _GLIBCXX_TYPE_TRAITS
30	#define _GLIBCXX_TYPE_TRAITS 1
31
32	#pragma GCC system_header
33
34	#if __cplusplus < 201103L
35	# include <bits/c++0x_warning.h>
36	#else
37
38	#include <bits/c++config.h>
39
40	namespace std _GLIBCXX_VISIBILITY(default)
41	{
42	_GLIBCXX_BEGIN_NAMESPACE_VERSION
43
44	template<typename... _Elements>
45	class tuple;
46
47	template<typename _Tp>
48	class reference_wrapper;
49
50	/**
51	* @defgroup metaprogramming Metaprogramming
52	* @ingroup utilities
53	*
54	* Template utilities for compile-time introspection and modification,
55	* including type classification traits, type property inspection traits
56	* and type transformation traits.
57	*
58	* @since C++11
59	*
60	* @{
61	*/
62
63	/// integral_constant
64	template<typename _Tp, _Tp __v>
65	struct integral_constant
66	{
67	static constexpr _Tp value = __v;
68	typedef _Tp value_type;
69	typedef integral_constant<_Tp, __v> type;
70	constexpr operator value_type() const noexcept { return value; }
71	#if __cplusplus > 201103L
72
73	#define __cpp_lib_integral_constant_callable 201304
74
75	constexpr value_type operator()() const noexcept { return value; }
76	#endif
77	};
78
79	template<typename _Tp, _Tp __v>
80	constexpr _Tp integral_constant<_Tp, __v>::value;
81
82	/// The type used as a compile-time boolean with true value.
83	using true_type = integral_constant<bool, true>;
84
85	/// The type used as a compile-time boolean with false value.
86	using false_type = integral_constant<bool, false>;
87
88	/// @cond undocumented
89	/// bool_constant for C++11
90	template<bool __v>
91	using __bool_constant = integral_constant<bool, __v>;
92	/// @endcond
93
94	#if __cplusplus >= 201703L
95	# define __cpp_lib_bool_constant 201505
96	/// Alias template for compile-time boolean constant types.
97	/// @since C++17
98	template<bool __v>
99	using bool_constant = integral_constant<bool, __v>;
100	#endif
101
102	// Metaprogramming helper types.
103
104	template<bool, typename, typename>
105	struct conditional;
106
107	/// @cond undocumented
108	template <typename _Type>
109	struct __type_identity
110	{ using type = _Type; };
111
112	template<typename _Tp>
113	using __type_identity_t = typename __type_identity<_Tp>::type;
114
115	template<typename...>
116	struct __or_;
117
118	template<>
119	struct __or_<>
120	: public false_type
121	{ };
122
123	template<typename _B1>
124	struct __or_<_B1>
125	: public _B1
126	{ };
127
128	template<typename _B1, typename _B2>
129	struct __or_<_B1, _B2>
130	: public conditional<_B1::value, _B1, _B2>::type
131	{ };
132
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
136	{ };
137
138	template<typename...>
139	struct __and_;
140
141	template<>
142	struct __and_<>
143	: public true_type
144	{ };
145
146	template<typename _B1>
147	struct __and_<_B1>
148	: public _B1
149	{ };
150
151	template<typename _B1, typename _B2>
152	struct __and_<_B1, _B2>
153	: public conditional<_B1::value, _B2, _B1>::type
154	{ };
155
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
159	{ };
160
161	template<typename _Pp>
162	struct __not_
163	: public __bool_constant<!bool(_Pp::value)>
164	{ };
165	/// @endcond
166
167	#if __cplusplus >= 201703L
168
169	/// @cond undocumented
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;
174	/// @endcond
175
176	#define __cpp_lib_logical_traits 201510
177
178	template<typename... _Bn>
179	struct conjunction
180	: __and_<_Bn...>
181	{ };
182
183	template<typename... _Bn>
184	struct disjunction
185	: __or_<_Bn...>
186	{ };
187
188	template<typename _Pp>
189	struct negation
190	: __not_<_Pp>
191	{ };
192
193	/** @ingroup variable_templates
194	* @{
195	*/
196	template<typename... _Bn>
197	inline constexpr bool conjunction_v = conjunction<_Bn...>::value;
198
199	template<typename... _Bn>
200	inline constexpr bool disjunction_v = disjunction<_Bn...>::value;
201
202	template<typename _Pp>
203	inline constexpr bool negation_v = negation<_Pp>::value;
204	/// @}
205
206	#endif // C++17
207
208	// Forward declarations
209	template<typename>
210	struct is_reference;
211	template<typename>
212	struct is_function;
213	template<typename>
214	struct is_void;
215	template<typename>
216	struct remove_cv;
217	template<typename>
218	struct is_const;
219
220	/// @cond undocumented
221	template<typename>
222	struct __is_array_unknown_bounds;
223
224	// Helper functions that return false_type for incomplete classes,
225	// incomplete unions and arrays of known bound from those.
226
227	template <typename _Tp, size_t = sizeof(_Tp)>
228	constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
229	{ return {}; }
230
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)
239	{ return {}; }
240
241	// For several sfinae-friendly trait implementations we transport both the
242	// result information (as the member type) and the failure information (no
243	// member type). This is very similar to std::enable_if, but we cannot use
244	// them, because we need to derive from them as an implementation detail.
245
246	template<typename _Tp>
247	struct __success_type
248	{ typedef _Tp type; };
249
250	struct __failure_type
251	{ };
252
253	// __remove_cv_t (std::remove_cv_t for C++11).
254	template<typename _Tp>
255	using __remove_cv_t = typename remove_cv<_Tp>::type;
256
257	// Primary type categories.
258
259	template<typename>
260	struct __is_void_helper
261	: public false_type { };
262
263	template<>
264	struct __is_void_helper<void>
265	: public true_type { };
266	/// @endcond
267
268	/// is_void
269	template<typename _Tp>
270	struct is_void
271	: public __is_void_helper<__remove_cv_t<_Tp>>::type
272	{ };
273
274	/// @cond undocumented
275	template<typename>
276	struct __is_integral_helper
277	: public false_type { };
278
279	template<>
280	struct __is_integral_helper<bool>
281	: public true_type { };
282
283	template<>
284	struct __is_integral_helper<char>
285	: public true_type { };
286
287	template<>
288	struct __is_integral_helper<signed char>
289	: public true_type { };
290
291	template<>
292	struct __is_integral_helper<unsigned char>
293	: public true_type { };
294
295	// We want is_integral<wchar_t> to be true (and make_signed/unsigned to work)
296	// even when libc doesn't provide working <wchar.h> and related functions,
297	// so check __WCHAR_TYPE__ instead of _GLIBCXX_USE_WCHAR_T.
298	#ifdef __WCHAR_TYPE__
299	template<>
300	struct __is_integral_helper<wchar_t>
301	: public true_type { };
302	#endif
303
304	#ifdef _GLIBCXX_USE_CHAR8_T
305	template<>
306	struct __is_integral_helper<char8_t>
307	: public true_type { };
308	#endif
309
310	template<>
311	struct __is_integral_helper<char16_t>
312	: public true_type { };
313
314	template<>
315	struct __is_integral_helper<char32_t>
316	: public true_type { };
317
318	template<>
319	struct __is_integral_helper<short>
320	: public true_type { };
321
322	template<>
323	struct __is_integral_helper<unsigned short>
324	: public true_type { };
325
326	template<>
327	struct __is_integral_helper<int>
328	: public true_type { };
329
330	template<>
331	struct __is_integral_helper<unsigned int>
332	: public true_type { };
333
334	template<>
335	struct __is_integral_helper<long>
336	: public true_type { };
337
338	template<>
339	struct __is_integral_helper<unsigned long>
340	: public true_type { };
341
342	template<>
343	struct __is_integral_helper<long long>
344	: public true_type { };
345
346	template<>
347	struct __is_integral_helper<unsigned long long>
348	: public true_type { };
349
350	// Conditionalizing on __STRICT_ANSI__ here will break any port that
351	// uses one of these types for size_t.
352	#if defined(__GLIBCXX_TYPE_INT_N_0)
353	template<>
354	struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0>
355	: public true_type { };
356
357	template<>
358	struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0>
359	: public true_type { };
360	#endif
361	#if defined(__GLIBCXX_TYPE_INT_N_1)
362	template<>
363	struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1>
364	: public true_type { };
365
366	template<>
367	struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1>
368	: public true_type { };
369	#endif
370	#if defined(__GLIBCXX_TYPE_INT_N_2)
371	template<>
372	struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2>
373	: public true_type { };
374
375	template<>
376	struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2>
377	: public true_type { };
378	#endif
379	#if defined(__GLIBCXX_TYPE_INT_N_3)
380	template<>
381	struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3>
382	: public true_type { };
383
384	template<>
385	struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3>
386	: public true_type { };
387	#endif
388	/// @endcond
389
390	/// is_integral
391	template<typename _Tp>
392	struct is_integral
393	: public __is_integral_helper<__remove_cv_t<_Tp>>::type
394	{ };
395
396	/// @cond undocumented
397	template<typename>
398	struct __is_floating_point_helper
399	: public false_type { };
400
401	template<>
402	struct __is_floating_point_helper<float>
403	: public true_type { };
404
405	template<>
406	struct __is_floating_point_helper<double>
407	: public true_type { };
408
409	template<>
410	struct __is_floating_point_helper<long double>
411	: public true_type { };
412
413	#if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128) && !defined(__CUDACC__)
414	template<>
415	struct __is_floating_point_helper<__float128>
416	: public true_type { };
417	#endif
418	/// @endcond
419
420	/// is_floating_point
421	template<typename _Tp>
422	struct is_floating_point
423	: public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
424	{ };
425
426	/// is_array
427	template<typename>
428	struct is_array
429	: public false_type { };
430
431	template<typename _Tp, std::size_t _Size>
432	struct is_array<_Tp[_Size]>
433	: public true_type { };
434
435	template<typename _Tp>
436	struct is_array<_Tp[]>
437	: public true_type { };
438
439	template<typename>
440	struct __is_pointer_helper
441	: public false_type { };
442
443	template<typename _Tp>
444	struct __is_pointer_helper<_Tp*>
445	: public true_type { };
446
447	/// is_pointer
448	template<typename _Tp>
449	struct is_pointer
450	: public __is_pointer_helper<__remove_cv_t<_Tp>>::type
451	{ };
452
453	/// is_lvalue_reference
454	template<typename>
455	struct is_lvalue_reference
456	: public false_type { };
457
458	template<typename _Tp>
459	struct is_lvalue_reference<_Tp&>
460	: public true_type { };
461
462	/// is_rvalue_reference
463	template<typename>
464	struct is_rvalue_reference
465	: public false_type { };
466
467	template<typename _Tp>
468	struct is_rvalue_reference<_Tp&&>
469	: public true_type { };
470
471	template<typename>
472	struct __is_member_object_pointer_helper
473	: public false_type { };
474
475	template<typename _Tp, typename _Cp>
476	struct __is_member_object_pointer_helper<_Tp _Cp::*>
477	: public __not_<is_function<_Tp>>::type { };
478
479	/// is_member_object_pointer
480	template<typename _Tp>
481	struct is_member_object_pointer
482	: public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type
483	{ };
484
485	template<typename>
486	struct __is_member_function_pointer_helper
487	: public false_type { };
488
489	template<typename _Tp, typename _Cp>
490	struct __is_member_function_pointer_helper<_Tp _Cp::*>
491	: public is_function<_Tp>::type { };
492
493	/// is_member_function_pointer
494	template<typename _Tp>
495	struct is_member_function_pointer
496	: public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type
497	{ };
498
499	/// is_enum
500	template<typename _Tp>
501	struct is_enum
502	: public integral_constant<bool, __is_enum(_Tp)>
503	{ };
504
505	/// is_union
506	template<typename _Tp>
507	struct is_union
508	: public integral_constant<bool, __is_union(_Tp)>
509	{ };
510
511	/// is_class
512	template<typename _Tp>
513	struct is_class
514	: public integral_constant<bool, __is_class(_Tp)>
515	{ };
516
517	/// is_function
518	template<typename _Tp>
519	struct is_function
520	: public __bool_constant<!is_const<const _Tp>::value> { };
521
522	template<typename _Tp>
523	struct is_function<_Tp&>
524	: public false_type { };
525
526	template<typename _Tp>
527	struct is_function<_Tp&&>
528	: public false_type { };
529
530	#define __cpp_lib_is_null_pointer 201309
531
532	template<typename>
533	struct __is_null_pointer_helper
534	: public false_type { };
535
536	template<>
537	struct __is_null_pointer_helper<std::nullptr_t>
538	: public true_type { };
539
540	/// is_null_pointer (LWG 2247).
541	template<typename _Tp>
542	struct is_null_pointer
543	: public __is_null_pointer_helper<__remove_cv_t<_Tp>>::type
544	{ };
545
546	/// __is_nullptr_t (deprecated extension).
547	/// @deprecated Use `is_null_pointer` instead.
548	template<typename _Tp>
549	struct __is_nullptr_t
550	: public is_null_pointer<_Tp>
551	{ } _GLIBCXX_DEPRECATED_SUGGEST("std::is_null_pointer");
552
553	// Composite type categories.
554
555	/// is_reference
556	template<typename _Tp>
557	struct is_reference
558	: public __or_<is_lvalue_reference<_Tp>,
559	is_rvalue_reference<_Tp>>::type
560	{ };
561
562	/// is_arithmetic
563	template<typename _Tp>
564	struct is_arithmetic
565	: public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
566	{ };
567
568	/// is_fundamental
569	template<typename _Tp>
570	struct is_fundamental
571	: public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
572	is_null_pointer<_Tp>>::type
573	{ };
574
575	/// is_object
576	template<typename _Tp>
577	struct is_object
578	: public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
579	is_void<_Tp>>>::type
580	{ };
581
582	template<typename>
583	struct is_member_pointer;
584
585	/// is_scalar
586	template<typename _Tp>
587	struct is_scalar
588	: public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
589	is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
590	{ };
591
592	/// is_compound
593	template<typename _Tp>
594	struct is_compound
595	: public __not_<is_fundamental<_Tp>>::type { };
596
597	/// @cond undocumented
598	template<typename _Tp>
599	struct __is_member_pointer_helper
600	: public false_type { };
601
602	template<typename _Tp, typename _Cp>
603	struct __is_member_pointer_helper<_Tp _Cp::*>
604	: public true_type { };
605	/// @endcond
606
607	/// is_member_pointer
608	template<typename _Tp>
609	struct is_member_pointer
610	: public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type
611	{ };
612
613	template<typename, typename>
614	struct is_same;
615
616	/// @cond undocumented
617	template<typename _Tp, typename... _Types>
618	using __is_one_of = __or_<is_same<_Tp, _Types>...>;
619
620	// Check if a type is one of the signed integer 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,
624	signed long long
625	#if defined(__GLIBCXX_TYPE_INT_N_0)
626	, signed __GLIBCXX_TYPE_INT_N_0
627	#endif
628	#if defined(__GLIBCXX_TYPE_INT_N_1)
629	, signed __GLIBCXX_TYPE_INT_N_1
630	#endif
631	#if defined(__GLIBCXX_TYPE_INT_N_2)
632	, signed __GLIBCXX_TYPE_INT_N_2
633	#endif
634	#if defined(__GLIBCXX_TYPE_INT_N_3)
635	, signed __GLIBCXX_TYPE_INT_N_3
636	#endif
637	>;
638
639	// Check if a type is one of the unsigned integer types.
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,
643	unsigned long long
644	#if defined(__GLIBCXX_TYPE_INT_N_0)
645	, unsigned __GLIBCXX_TYPE_INT_N_0
646	#endif
647	#if defined(__GLIBCXX_TYPE_INT_N_1)
648	, unsigned __GLIBCXX_TYPE_INT_N_1
649	#endif
650	#if defined(__GLIBCXX_TYPE_INT_N_2)
651	, unsigned __GLIBCXX_TYPE_INT_N_2
652	#endif
653	#if defined(__GLIBCXX_TYPE_INT_N_3)
654	, unsigned __GLIBCXX_TYPE_INT_N_3
655	#endif
656	>;
657
658	// Check if a type is one of the signed or unsigned integer types.
659	template<typename _Tp>
660	using __is_standard_integer
661	= __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
662
663	// __void_t (std::void_t for C++11)
664	template<typename...> using __void_t = void;
665
666	// Utility to detect referenceable types ([defns.referenceable]).
667
668	template<typename _Tp, typename = void>
669	struct __is_referenceable
670	: public false_type
671	{ };
672
673	template<typename _Tp>
674	struct __is_referenceable<_Tp, __void_t<_Tp&>>
675	: public true_type
676	{ };
677	/// @endcond
678
679	// Type properties.
680
681	/// is_const
682	template<typename>
683	struct is_const
684	: public false_type { };
685
686	template<typename _Tp>
687	struct is_const<_Tp const>
688	: public true_type { };
689
690	/// is_volatile
691	template<typename>
692	struct is_volatile
693	: public false_type { };
694
695	template<typename _Tp>
696	struct is_volatile<_Tp volatile>
697	: public true_type { };
698
699	/// is_trivial
700	template<typename _Tp>
701	struct is_trivial
702	: public integral_constant<bool, __is_trivial(_Tp)>
703	{
704	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
705	"template argument must be a complete class or an unbounded array");
706	};
707
708	/// is_trivially_copyable
709	template<typename _Tp>
710	struct is_trivially_copyable
711	: public integral_constant<bool, __is_trivially_copyable(_Tp)>
712	{
713	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
714	"template argument must be a complete class or an unbounded array");
715	};
716
717	/// is_standard_layout
718	template<typename _Tp>
719	struct is_standard_layout
720	: public integral_constant<bool, __is_standard_layout(_Tp)>
721	{
722	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
723	"template argument must be a complete class or an unbounded array");
724	};
725
726	/** is_pod (deprecated in C++20)
727	* @deprecated Use `is_standard_layout && is_trivial` instead.
728	*/
729	// Could use is_standard_layout && is_trivial instead of the builtin.
730	template<typename _Tp>
731	struct
732	_GLIBCXX20_DEPRECATED("use is_standard_layout && is_trivial instead")
733	is_pod
734	: public integral_constant<bool, __is_pod(_Tp)>
735	{
736	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
737	"template argument must be a complete class or an unbounded array");
738	};
739
740	/** is_literal_type
741	* @deprecated Deprecated in C++20. The idea of a literal type isn't useful.
742	*/
743	template<typename _Tp>
744	struct
745	_GLIBCXX17_DEPRECATED
746	is_literal_type
747	: public integral_constant<bool, __is_literal_type(_Tp)>
748	{
749	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
750	"template argument must be a complete class or an unbounded array");
751	};
752
753	/// is_empty
754	template<typename _Tp>
755	struct is_empty
756	: public integral_constant<bool, __is_empty(_Tp)>
757	{ };
758
759	/// is_polymorphic
760	template<typename _Tp>
761	struct is_polymorphic
762	: public integral_constant<bool, __is_polymorphic(_Tp)>
763	{ };
764
765	#if __cplusplus >= 201402L
766	#define __cpp_lib_is_final 201402L
767	/// is_final
768	/// @since C++14
769	template<typename _Tp>
770	struct is_final
771	: public integral_constant<bool, __is_final(_Tp)>
772	{ };
773	#endif
774
775	/// is_abstract
776	template<typename _Tp>
777	struct is_abstract
778	: public integral_constant<bool, __is_abstract(_Tp)>
779	{ };
780
781	/// @cond undocumented
782	template<typename _Tp,
783	bool = is_arithmetic<_Tp>::value>
784	struct __is_signed_helper
785	: public false_type { };
786
787	template<typename _Tp>
788	struct __is_signed_helper<_Tp, true>
789	: public integral_constant<bool, _Tp(-1) < _Tp(0)>
790	{ };
791	/// @endcond
792
793	/// is_signed
794	template<typename _Tp>
795	struct is_signed
796	: public __is_signed_helper<_Tp>::type
797	{ };
798
799	/// is_unsigned
800	template<typename _Tp>
801	struct is_unsigned
802	: public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
803	{ };
804
805	/// @cond undocumented
806	template<typename _Tp, typename _Up = _Tp&&>
807	_Up
808	__declval(int);
809
810	template<typename _Tp>
811	_Tp
812	__declval(long);
813	/// @endcond
814
815	template<typename _Tp>
816	auto declval() noexcept -> decltype(__declval<_Tp>(0));
817
818	template<typename, unsigned = 0>
819	struct extent;
820
821	template<typename>
822	struct remove_all_extents;
823
824	/// @cond undocumented
825	template<typename _Tp>
826	struct __is_array_known_bounds
827	: public integral_constant<bool, (extent<_Tp>::value > 0)>
828	{ };
829
830	template<typename _Tp>
831	struct __is_array_unknown_bounds
832	: public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
833	{ };
834
835	// Destructible and constructible type properties.
836
837	// In N3290 is_destructible does not say anything about function
838	// types and abstract types, see LWG 2049. This implementation
839	// describes function types as non-destructible and all complete
840	// object types as destructible, iff the explicit destructor
841	// call expression is wellformed.
842	struct __do_is_destructible_impl
843	{
844	template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
845	static true_type __test(int);
846
847	template<typename>
848	static false_type __test(...);
849	};
850
851	template<typename _Tp>
852	struct __is_destructible_impl
853	: public __do_is_destructible_impl
854	{
855	typedef decltype(__test<_Tp>(0)) type;
856	};
857
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;
864
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
869	{ };
870
871	template<typename _Tp>
872	struct __is_destructible_safe<_Tp, true, false>
873	: public false_type { };
874
875	template<typename _Tp>
876	struct __is_destructible_safe<_Tp, false, true>
877	: public true_type { };
878	/// @endcond
879
880	/// is_destructible
881	template<typename _Tp>
882	struct is_destructible
883	: public __is_destructible_safe<_Tp>::type
884	{
885	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
886	"template argument must be a complete class or an unbounded array");
887	};
888
889	/// @cond undocumented
890
891	// is_nothrow_destructible requires that is_destructible is
892	// satisfied as well. We realize that by mimicing the
893	// implementation of is_destructible but refer to noexcept(expr)
894	// instead of decltype(expr).
895	struct __do_is_nt_destructible_impl
896	{
897	template<typename _Tp>
898	static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
899	__test(int);
900
901	template<typename>
902	static false_type __test(...);
903	};
904
905	template<typename _Tp>
906	struct __is_nt_destructible_impl
907	: public __do_is_nt_destructible_impl
908	{
909	typedef decltype(__test<_Tp>(0)) type;
910	};
911
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;
918
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
923	{ };
924
925	template<typename _Tp>
926	struct __is_nt_destructible_safe<_Tp, true, false>
927	: public false_type { };
928
929	template<typename _Tp>
930	struct __is_nt_destructible_safe<_Tp, false, true>
931	: public true_type { };
932	/// @endcond
933
934	/// is_nothrow_destructible
935	template<typename _Tp>
936	struct is_nothrow_destructible
937	: public __is_nt_destructible_safe<_Tp>::type
938	{
939	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
940	"template argument must be a complete class or an unbounded array");
941	};
942
943	/// @cond undocumented
944	template<typename _Tp, typename... _Args>
945	struct __is_constructible_impl
946	: public __bool_constant<__is_constructible(_Tp, _Args...)>
947	{ };
948	/// @endcond
949
950	/// is_constructible
951	template<typename _Tp, typename... _Args>
952	struct is_constructible
953	: public __is_constructible_impl<_Tp, _Args...>
954	{
955	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
956	"template argument must be a complete class or an unbounded array");
957	};
958
959	/// is_default_constructible
960	template<typename _Tp>
961	struct is_default_constructible
962	: public __is_constructible_impl<_Tp>::type
963	{
964	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
965	"template argument must be a complete class or an unbounded array");
966	};
967
968	/// @cond undocumented
969	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
970	struct __is_copy_constructible_impl;
971
972	template<typename _Tp>
973	struct __is_copy_constructible_impl<_Tp, false>
974	: public false_type { };
975
976	template<typename _Tp>
977	struct __is_copy_constructible_impl<_Tp, true>
978	: public __is_constructible_impl<_Tp, const _Tp&>
979	{ };
980	/// @endcond
981
982	/// is_copy_constructible
983	template<typename _Tp>
984	struct is_copy_constructible
985	: public __is_copy_constructible_impl<_Tp>
986	{
987	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
988	"template argument must be a complete class or an unbounded array");
989	};
990
991	/// @cond undocumented
992	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
993	struct __is_move_constructible_impl;
994
995	template<typename _Tp>
996	struct __is_move_constructible_impl<_Tp, false>
997	: public false_type { };
998
999	template<typename _Tp>
1000	struct __is_move_constructible_impl<_Tp, true>
1001	: public __is_constructible_impl<_Tp, _Tp&&>
1002	{ };
1003	/// @endcond
1004
1005	/// is_move_constructible
1006	template<typename _Tp>
1007	struct is_move_constructible
1008	: public __is_move_constructible_impl<_Tp>
1009	{
1010	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1011	"template argument must be a complete class or an unbounded array");
1012	};
1013
1014	/// @cond undocumented
1015	template<typename _Tp, typename... _Args>
1016	using __is_nothrow_constructible_impl
1017	= __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>;
1018	/// @endcond
1019
1020	/// is_nothrow_constructible
1021	template<typename _Tp, typename... _Args>
1022	struct is_nothrow_constructible
1023	: public __is_nothrow_constructible_impl<_Tp, _Args...>::type
1024	{
1025	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1026	"template argument must be a complete class or an unbounded array");
1027	};
1028
1029	/// is_nothrow_default_constructible
1030	template<typename _Tp>
1031	struct is_nothrow_default_constructible
1032	: public __bool_constant<__is_nothrow_constructible(_Tp)>
1033	{
1034	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1035	"template argument must be a complete class or an unbounded array");
1036	};
1037
1038	/// @cond undocumented
1039	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1040	struct __is_nothrow_copy_constructible_impl;
1041
1042	template<typename _Tp>
1043	struct __is_nothrow_copy_constructible_impl<_Tp, false>
1044	: public false_type { };
1045
1046	template<typename _Tp>
1047	struct __is_nothrow_copy_constructible_impl<_Tp, true>
1048	: public __is_nothrow_constructible_impl<_Tp, const _Tp&>
1049	{ };
1050	/// @endcond
1051
1052	/// is_nothrow_copy_constructible
1053	template<typename _Tp>
1054	struct is_nothrow_copy_constructible
1055	: public __is_nothrow_copy_constructible_impl<_Tp>::type
1056	{
1057	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1058	"template argument must be a complete class or an unbounded array");
1059	};
1060
1061	/// @cond undocumented
1062	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1063	struct __is_nothrow_move_constructible_impl;
1064
1065	template<typename _Tp>
1066	struct __is_nothrow_move_constructible_impl<_Tp, false>
1067	: public false_type { };
1068
1069	template<typename _Tp>
1070	struct __is_nothrow_move_constructible_impl<_Tp, true>
1071	: public __is_nothrow_constructible_impl<_Tp, _Tp&&>
1072	{ };
1073	/// @endcond
1074
1075	/// is_nothrow_move_constructible
1076	template<typename _Tp>
1077	struct is_nothrow_move_constructible
1078	: public __is_nothrow_move_constructible_impl<_Tp>::type
1079	{
1080	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1081	"template argument must be a complete class or an unbounded array");
1082	};
1083
1084	/// is_assignable
1085	template<typename _Tp, typename _Up>
1086	struct is_assignable
1087	: public __bool_constant<__is_assignable(_Tp, _Up)>
1088	{
1089	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1090	"template argument must be a complete class or an unbounded array");
1091	};
1092
1093	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1094	struct __is_copy_assignable_impl;
1095
1096	template<typename _Tp>
1097	struct __is_copy_assignable_impl<_Tp, false>
1098	: public false_type { };
1099
1100	template<typename _Tp>
1101	struct __is_copy_assignable_impl<_Tp, true>
1102	: public __bool_constant<__is_assignable(_Tp&, const _Tp&)>
1103	{ };
1104
1105	/// is_copy_assignable
1106	template<typename _Tp>
1107	struct is_copy_assignable
1108	: public __is_copy_assignable_impl<_Tp>::type
1109	{
1110	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1111	"template argument must be a complete class or an unbounded array");
1112	};
1113
1114	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1115	struct __is_move_assignable_impl;
1116
1117	template<typename _Tp>
1118	struct __is_move_assignable_impl<_Tp, false>
1119	: public false_type { };
1120
1121	template<typename _Tp>
1122	struct __is_move_assignable_impl<_Tp, true>
1123	: public __bool_constant<__is_assignable(_Tp&, _Tp&&)>
1124	{ };
1125
1126	/// is_move_assignable
1127	template<typename _Tp>
1128	struct is_move_assignable
1129	: public __is_move_assignable_impl<_Tp>::type
1130	{
1131	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1132	"template argument must be a complete class or an unbounded array");
1133	};
1134
1135	template<typename _Tp, typename _Up>
1136	using __is_nothrow_assignable_impl
1137	= __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;
1138
1139	/// is_nothrow_assignable
1140	template<typename _Tp, typename _Up>
1141	struct is_nothrow_assignable
1142	: public __is_nothrow_assignable_impl<_Tp, _Up>
1143	{
1144	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1145	"template argument must be a complete class or an unbounded array");
1146	};
1147
1148	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1149	struct __is_nt_copy_assignable_impl;
1150
1151	template<typename _Tp>
1152	struct __is_nt_copy_assignable_impl<_Tp, false>
1153	: public false_type { };
1154
1155	template<typename _Tp>
1156	struct __is_nt_copy_assignable_impl<_Tp, true>
1157	: public __is_nothrow_assignable_impl<_Tp&, const _Tp&>
1158	{ };
1159
1160	/// is_nothrow_copy_assignable
1161	template<typename _Tp>
1162	struct is_nothrow_copy_assignable
1163	: public __is_nt_copy_assignable_impl<_Tp>
1164	{
1165	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1166	"template argument must be a complete class or an unbounded array");
1167	};
1168
1169	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1170	struct __is_nt_move_assignable_impl;
1171
1172	template<typename _Tp>
1173	struct __is_nt_move_assignable_impl<_Tp, false>
1174	: public false_type { };
1175
1176	template<typename _Tp>
1177	struct __is_nt_move_assignable_impl<_Tp, true>
1178	: public __is_nothrow_assignable_impl<_Tp&, _Tp&&>
1179	{ };
1180
1181	/// is_nothrow_move_assignable
1182	template<typename _Tp>
1183	struct is_nothrow_move_assignable
1184	: public __is_nt_move_assignable_impl<_Tp>
1185	{
1186	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1187	"template argument must be a complete class or an unbounded array");
1188	};
1189
1190	/// is_trivially_constructible
1191	template<typename _Tp, typename... _Args>
1192	struct is_trivially_constructible
1193	: public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
1194	{
1195	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1196	"template argument must be a complete class or an unbounded array");
1197	};
1198
1199	/// is_trivially_default_constructible
1200	template<typename _Tp>
1201	struct is_trivially_default_constructible
1202	: public __bool_constant<__is_trivially_constructible(_Tp)>
1203	{
1204	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1205	"template argument must be a complete class or an unbounded array");
1206	};
1207
1208	struct __do_is_implicitly_default_constructible_impl
1209	{
1210	template <typename _Tp>
1211	static void __helper(const _Tp&);
1212
1213	template <typename _Tp>
1214	static true_type __test(const _Tp&,
1215	decltype(__helper<const _Tp&>({}))* = 0);
1216
1217	static false_type __test(...);
1218	};
1219
1220	template<typename _Tp>
1221	struct __is_implicitly_default_constructible_impl
1222	: public __do_is_implicitly_default_constructible_impl
1223	{
1224	typedef decltype(__test(declval<_Tp>())) type;
1225	};
1226
1227	template<typename _Tp>
1228	struct __is_implicitly_default_constructible_safe
1229	: public __is_implicitly_default_constructible_impl<_Tp>::type
1230	{ };
1231
1232	template <typename _Tp>
1233	struct __is_implicitly_default_constructible
1234	: public __and_<__is_constructible_impl<_Tp>,
1235	__is_implicitly_default_constructible_safe<_Tp>>
1236	{ };
1237
1238	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1239	struct __is_trivially_copy_constructible_impl;
1240
1241	template<typename _Tp>
1242	struct __is_trivially_copy_constructible_impl<_Tp, false>
1243	: public false_type { };
1244
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&)>>
1250	{ };
1251
1252	/// is_trivially_copy_constructible
1253	template<typename _Tp>
1254	struct is_trivially_copy_constructible
1255	: public __is_trivially_copy_constructible_impl<_Tp>
1256	{
1257	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1258	"template argument must be a complete class or an unbounded array");
1259	};
1260
1261	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1262	struct __is_trivially_move_constructible_impl;
1263
1264	template<typename _Tp>
1265	struct __is_trivially_move_constructible_impl<_Tp, false>
1266	: public false_type { };
1267
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&&)>>
1273	{ };
1274
1275	/// is_trivially_move_constructible
1276	template<typename _Tp>
1277	struct is_trivially_move_constructible
1278	: public __is_trivially_move_constructible_impl<_Tp>
1279	{
1280	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1281	"template argument must be a complete class or an unbounded array");
1282	};
1283
1284	/// is_trivially_assignable
1285	template<typename _Tp, typename _Up>
1286	struct is_trivially_assignable
1287	: public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
1288	{
1289	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1290	"template argument must be a complete class or an unbounded array");
1291	};
1292
1293	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1294	struct __is_trivially_copy_assignable_impl;
1295
1296	template<typename _Tp>
1297	struct __is_trivially_copy_assignable_impl<_Tp, false>
1298	: public false_type { };
1299
1300	template<typename _Tp>
1301	struct __is_trivially_copy_assignable_impl<_Tp, true>
1302	: public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
1303	{ };
1304
1305	/// is_trivially_copy_assignable
1306	template<typename _Tp>
1307	struct is_trivially_copy_assignable
1308	: public __is_trivially_copy_assignable_impl<_Tp>
1309	{
1310	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1311	"template argument must be a complete class or an unbounded array");
1312	};
1313
1314	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1315	struct __is_trivially_move_assignable_impl;
1316
1317	template<typename _Tp>
1318	struct __is_trivially_move_assignable_impl<_Tp, false>
1319	: public false_type { };
1320
1321	template<typename _Tp>
1322	struct __is_trivially_move_assignable_impl<_Tp, true>
1323	: public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
1324	{ };
1325
1326	/// is_trivially_move_assignable
1327	template<typename _Tp>
1328	struct is_trivially_move_assignable
1329	: public __is_trivially_move_assignable_impl<_Tp>
1330	{
1331	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1332	"template argument must be a complete class or an unbounded array");
1333	};
1334
1335	/// is_trivially_destructible
1336	template<typename _Tp>
1337	struct is_trivially_destructible
1338	: public __and_<__is_destructible_safe<_Tp>,
1339	__bool_constant<__has_trivial_destructor(_Tp)>>
1340	{
1341	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1342	"template argument must be a complete class or an unbounded array");
1343	};
1344
1345
1346	/// has_virtual_destructor
1347	template<typename _Tp>
1348	struct has_virtual_destructor
1349	: public integral_constant<bool, __has_virtual_destructor(_Tp)>
1350	{
1351	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1352	"template argument must be a complete class or an unbounded array");
1353	};
1354
1355
1356	// type property queries.
1357
1358	/// alignment_of
1359	template<typename _Tp>
1360	struct alignment_of
1361	: public integral_constant<std::size_t, alignof(_Tp)>
1362	{
1363	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
1364	"template argument must be a complete class or an unbounded array");
1365	};
1366
1367	/// rank
1368	template<typename>
1369	struct rank
1370	: public integral_constant<std::size_t, 0> { };
1371
1372	template<typename _Tp, std::size_t _Size>
1373	struct rank<_Tp[_Size]>
1374	: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1375
1376	template<typename _Tp>
1377	struct rank<_Tp[]>
1378	: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1379
1380	/// extent
1381	template<typename, unsigned _Uint>
1382	struct extent
1383	: public integral_constant<std::size_t, 0> { };
1384
1385	template<typename _Tp, unsigned _Uint, std::size_t _Size>
1386	struct extent<_Tp[_Size], _Uint>
1387	: public integral_constant<std::size_t,
1388	_Uint == 0 ? _Size : extent<_Tp,
1389	_Uint - 1>::value>
1390	{ };
1391
1392	template<typename _Tp, unsigned _Uint>
1393	struct extent<_Tp[], _Uint>
1394	: public integral_constant<std::size_t,
1395	_Uint == 0 ? 0 : extent<_Tp,
1396	_Uint - 1>::value>
1397	{ };
1398
1399
1400	// Type relations.
1401
1402	/// is_same
1403	template<typename _Tp, typename _Up>
1404	struct is_same
1405	#ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME
1406	: public integral_constant<bool, __is_same(_Tp, _Up)>
1407	#else
1408	: public false_type
1409	#endif
1410	{ };
1411
1412	#ifndef _GLIBCXX_HAVE_BUILTIN_IS_SAME
1413	template<typename _Tp>
1414	struct is_same<_Tp, _Tp>
1415	: public true_type
1416	{ };
1417	#endif
1418
1419	/// is_base_of
1420	template<typename _Base, typename _Derived>
1421	struct is_base_of
1422	: public integral_constant<bool, __is_base_of(_Base, _Derived)>
1423	{ };
1424
1425	template<typename _From, typename _To,
1426	bool = __or_<is_void<_From>, is_function<_To>,
1427	is_array<_To>>::value>
1428	struct __is_convertible_helper
1429	{
1430	typedef typename is_void<_To>::type type;
1431	};
1432
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>
1437	{
1438	template<typename _To1>
1439	static void __test_aux(_To1) noexcept;
1440
1441	template<typename _From1, typename _To1,
1442	typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
1443	static true_type
1444	__test(int);
1445
1446	template<typename, typename>
1447	static false_type
1448	__test(...);
1449
1450	public:
1451	typedef decltype(__test<_From, _To>(0)) type;
1452	};
1453	#pragma GCC diagnostic pop
1454
1455	/// is_convertible
1456	template<typename _From, typename _To>
1457	struct is_convertible
1458	: public __is_convertible_helper<_From, _To>::type
1459	{ };
1460
1461	// helper trait for unique_ptr<T[]>, shared_ptr<T[]>, and span<T, N>
1462	template<typename _ToElementType, typename _FromElementType>
1463	using __is_array_convertible
1464	= is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
1465
1466	template<typename _From, typename _To,
1467	bool = __or_<is_void<_From>, is_function<_To>,
1468	is_array<_To>>::value>
1469	struct __is_nt_convertible_helper
1470	: is_void<_To>
1471	{ };
1472
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>
1477	{
1478	template<typename _To1>
1479	static void __test_aux(_To1) noexcept;
1480
1481	template<typename _From1, typename _To1>
1482	static
1483	__bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
1484	__test(int);
1485
1486	template<typename, typename>
1487	static false_type
1488	__test(...);
1489
1490	public:
1491	using type = decltype(__test<_From, _To>(0));
1492	};
1493	#pragma GCC diagnostic pop
1494
1495	#if __cplusplus > 201703L
1496	#define __cpp_lib_is_nothrow_convertible 201806L
1497	/// is_nothrow_convertible
1498	template<typename _From, typename _To>
1499	struct is_nothrow_convertible
1500	: public __is_nt_convertible_helper<_From, _To>::type
1501	{ };
1502
1503	/// is_nothrow_convertible_v
1504	template<typename _From, typename _To>
1505	inline constexpr bool is_nothrow_convertible_v
1506	= is_nothrow_convertible<_From, _To>::value;
1507	#endif // C++2a
1508
1509	// Const-volatile modifications.
1510
1511	/// remove_const
1512	template<typename _Tp>
1513	struct remove_const
1514	{ typedef _Tp type; };
1515
1516	template<typename _Tp>
1517	struct remove_const<_Tp const>
1518	{ typedef _Tp type; };
1519
1520	/// remove_volatile
1521	template<typename _Tp>
1522	struct remove_volatile
1523	{ typedef _Tp type; };
1524
1525	template<typename _Tp>
1526	struct remove_volatile<_Tp volatile>
1527	{ typedef _Tp type; };
1528
1529	/// remove_cv
1530	template<typename _Tp>
1531	struct remove_cv
1532	{ using type = _Tp; };
1533
1534	template<typename _Tp>
1535	struct remove_cv<const _Tp>
1536	{ using type = _Tp; };
1537
1538	template<typename _Tp>
1539	struct remove_cv<volatile _Tp>
1540	{ using type = _Tp; };
1541
1542	template<typename _Tp>
1543	struct remove_cv<const volatile _Tp>
1544	{ using type = _Tp; };
1545
1546	/// add_const
1547	template<typename _Tp>
1548	struct add_const
1549	{ typedef _Tp const type; };
1550
1551	/// add_volatile
1552	template<typename _Tp>
1553	struct add_volatile
1554	{ typedef _Tp volatile type; };
1555
1556	/// add_cv
1557	template<typename _Tp>
1558	struct add_cv
1559	{
1560	typedef typename
1561	add_const<typename add_volatile<_Tp>::type>::type type;
1562	};
1563
1564	#if __cplusplus > 201103L
1565
1566	#define __cpp_lib_transformation_trait_aliases 201304
1567
1568	/// Alias template for remove_const
1569	template<typename _Tp>
1570	using remove_const_t = typename remove_const<_Tp>::type;
1571
1572	/// Alias template for remove_volatile
1573	template<typename _Tp>
1574	using remove_volatile_t = typename remove_volatile<_Tp>::type;
1575
1576	/// Alias template for remove_cv
1577	template<typename _Tp>
1578	using remove_cv_t = typename remove_cv<_Tp>::type;
1579
1580	/// Alias template for add_const
1581	template<typename _Tp>
1582	using add_const_t = typename add_const<_Tp>::type;
1583
1584	/// Alias template for add_volatile
1585	template<typename _Tp>
1586	using add_volatile_t = typename add_volatile<_Tp>::type;
1587
1588	/// Alias template for add_cv
1589	template<typename _Tp>
1590	using add_cv_t = typename add_cv<_Tp>::type;
1591	#endif
1592
1593	// Reference transformations.
1594
1595	/// remove_reference
1596	template<typename _Tp>
1597	struct remove_reference
1598	{ typedef _Tp type; };
1599
1600	template<typename _Tp>
1601	struct remove_reference<_Tp&>
1602	{ typedef _Tp type; };
1603
1604	template<typename _Tp>
1605	struct remove_reference<_Tp&&>
1606	{ typedef _Tp type; };
1607
1608	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1609	struct __add_lvalue_reference_helper
1610	{ typedef _Tp type; };
1611
1612	template<typename _Tp>
1613	struct __add_lvalue_reference_helper<_Tp, true>
1614	{ typedef _Tp& type; };
1615
1616	/// add_lvalue_reference
1617	template<typename _Tp>
1618	struct add_lvalue_reference
1619	: public __add_lvalue_reference_helper<_Tp>
1620	{ };
1621
1622	template<typename _Tp, bool = __is_referenceable<_Tp>::value>
1623	struct __add_rvalue_reference_helper
1624	{ typedef _Tp type; };
1625
1626	template<typename _Tp>
1627	struct __add_rvalue_reference_helper<_Tp, true>
1628	{ typedef _Tp&& type; };
1629
1630	/// add_rvalue_reference
1631	template<typename _Tp>
1632	struct add_rvalue_reference
1633	: public __add_rvalue_reference_helper<_Tp>
1634	{ };
1635
1636	#if __cplusplus > 201103L
1637	/// Alias template for remove_reference
1638	template<typename _Tp>
1639	using remove_reference_t = typename remove_reference<_Tp>::type;
1640
1641	/// Alias template for add_lvalue_reference
1642	template<typename _Tp>
1643	using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
1644
1645	/// Alias template for add_rvalue_reference
1646	template<typename _Tp>
1647	using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
1648	#endif
1649
1650	// Sign modifications.
1651
1652	/// @cond undocumented
1653
1654	// Utility for constructing identically cv-qualified types.
1655	template<typename _Unqualified, bool _IsConst, bool _IsVol>
1656	struct __cv_selector;
1657
1658	template<typename _Unqualified>
1659	struct __cv_selector<_Unqualified, false, false>
1660	{ typedef _Unqualified __type; };
1661
1662	template<typename _Unqualified>
1663	struct __cv_selector<_Unqualified, false, true>
1664	{ typedef volatile _Unqualified __type; };
1665
1666	template<typename _Unqualified>
1667	struct __cv_selector<_Unqualified, true, false>
1668	{ typedef const _Unqualified __type; };
1669
1670	template<typename _Unqualified>
1671	struct __cv_selector<_Unqualified, true, true>
1672	{ typedef const volatile _Unqualified __type; };
1673
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
1678	{
1679	typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
1680
1681	public:
1682	typedef typename __match::__type __type;
1683	};
1684
1685	// Utility for finding the unsigned versions of signed integral types.
1686	template<typename _Tp>
1687	struct __make_unsigned
1688	{ typedef _Tp __type; };
1689
1690	template<>
1691	struct __make_unsigned<char>
1692	{ typedef unsigned char __type; };
1693
1694	template<>
1695	struct __make_unsigned<signed char>
1696	{ typedef unsigned char __type; };
1697
1698	template<>
1699	struct __make_unsigned<short>
1700	{ typedef unsigned short __type; };
1701
1702	template<>
1703	struct __make_unsigned<int>
1704	{ typedef unsigned int __type; };
1705
1706	template<>
1707	struct __make_unsigned<long>
1708	{ typedef unsigned long __type; };
1709
1710	template<>
1711	struct __make_unsigned<long long>
1712	{ typedef unsigned long long __type; };
1713
1714	#if defined(__GLIBCXX_TYPE_INT_N_0)
1715	template<>
1716	struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0>
1717	{ typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; };
1718	#endif
1719	#if defined(__GLIBCXX_TYPE_INT_N_1)
1720	template<>
1721	struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1>
1722	{ typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; };
1723	#endif
1724	#if defined(__GLIBCXX_TYPE_INT_N_2)
1725	template<>
1726	struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2>
1727	{ typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; };
1728	#endif
1729	#if defined(__GLIBCXX_TYPE_INT_N_3)
1730	template<>
1731	struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3>
1732	{ typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; };
1733	#endif
1734
1735	// Select between integral and enum: not possible to be both.
1736	template<typename _Tp,
1737	bool _IsInt = is_integral<_Tp>::value,
1738	bool _IsEnum = is_enum<_Tp>::value>
1739	class __make_unsigned_selector;
1740
1741	template<typename _Tp>
1742	class __make_unsigned_selector<_Tp, true, false>
1743	{
1744	using __unsigned_type
1745	= typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
1746
1747	public:
1748	using __type
1749	= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1750	};
1751
1752	class __make_unsigned_selector_base
1753	{
1754	protected:
1755	template<typename...> struct _List { };
1756
1757	template<typename _Tp, typename... _Up>
1758	struct _List<_Tp, _Up...> : _List<_Up...>
1759	{ static constexpr size_t __size = sizeof(_Tp); };
1760
1761	template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
1762	struct __select;
1763
1764	template<size_t _Sz, typename _Uint, typename... _UInts>
1765	struct __select<_Sz, _List<_Uint, _UInts...>, true>
1766	{ using __type = _Uint; };
1767
1768	template<size_t _Sz, typename _Uint, typename... _UInts>
1769	struct __select<_Sz, _List<_Uint, _UInts...>, false>
1770	: __select<_Sz, _List<_UInts...>>
1771	{ };
1772	};
1773
1774	// Choose unsigned integer type with the smallest rank and same size as _Tp
1775	template<typename _Tp>
1776	class __make_unsigned_selector<_Tp, false, true>
1777	: __make_unsigned_selector_base
1778	{
1779	// With -fshort-enums, an enum may be as small as a char.
1780	using _UInts = _List<unsigned char, unsigned short, unsigned int,
1781	unsigned long, unsigned long long>;
1782
1783	using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
1784
1785	public:
1786	using __type
1787	= typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
1788	};
1789
1790	// wchar_t, char8_t, char16_t and char32_t are integral types but are
1791	// neither signed integer types nor unsigned integer types, so must be
1792	// transformed to the unsigned integer type with the smallest rank.
1793	// Use the partial specialization for enumeration types to do that.
1794	#ifdef __WCHAR_TYPE__
1795	template<>
1796	struct __make_unsigned<wchar_t>
1797	{
1798	using __type
1799	= typename __make_unsigned_selector<wchar_t, false, true>::__type;
1800	};
1801	#endif
1802
1803	#ifdef _GLIBCXX_USE_CHAR8_T
1804	template<>
1805	struct __make_unsigned<char8_t>
1806	{
1807	using __type
1808	= typename __make_unsigned_selector<char8_t, false, true>::__type;
1809	};
1810	#endif
1811
1812	template<>
1813	struct __make_unsigned<char16_t>
1814	{
1815	using __type
1816	= typename __make_unsigned_selector<char16_t, false, true>::__type;
1817	};
1818
1819	template<>
1820	struct __make_unsigned<char32_t>
1821	{
1822	using __type
1823	= typename __make_unsigned_selector<char32_t, false, true>::__type;
1824	};
1825	/// @endcond
1826
1827	// Given an integral/enum type, return the corresponding unsigned
1828	// integer type.
1829	// Primary template.
1830	/// make_unsigned
1831	template<typename _Tp>
1832	struct make_unsigned
1833	{ typedef typename __make_unsigned_selector<_Tp>::__type type; };
1834
1835	// Integral, but don't define.
1836	template<>
1837	struct make_unsigned<bool>;
1838
1839	/// @cond undocumented
1840
1841	// Utility for finding the signed versions of unsigned integral types.
1842	template<typename _Tp>
1843	struct __make_signed
1844	{ typedef _Tp __type; };
1845
1846	template<>
1847	struct __make_signed<char>
1848	{ typedef signed char __type; };
1849
1850	template<>
1851	struct __make_signed<unsigned char>
1852	{ typedef signed char __type; };
1853
1854	template<>
1855	struct __make_signed<unsigned short>
1856	{ typedef signed short __type; };
1857
1858	template<>
1859	struct __make_signed<unsigned int>
1860	{ typedef signed int __type; };
1861
1862	template<>
1863	struct __make_signed<unsigned long>
1864	{ typedef signed long __type; };
1865
1866	template<>
1867	struct __make_signed<unsigned long long>
1868	{ typedef signed long long __type; };
1869
1870	#if defined(__GLIBCXX_TYPE_INT_N_0)
1871	template<>
1872	struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0>
1873	{ typedef __GLIBCXX_TYPE_INT_N_0 __type; };
1874	#endif
1875	#if defined(__GLIBCXX_TYPE_INT_N_1)
1876	template<>
1877	struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1>
1878	{ typedef __GLIBCXX_TYPE_INT_N_1 __type; };
1879	#endif
1880	#if defined(__GLIBCXX_TYPE_INT_N_2)
1881	template<>
1882	struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2>
1883	{ typedef __GLIBCXX_TYPE_INT_N_2 __type; };
1884	#endif
1885	#if defined(__GLIBCXX_TYPE_INT_N_3)
1886	template<>
1887	struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3>
1888	{ typedef __GLIBCXX_TYPE_INT_N_3 __type; };
1889	#endif
1890
1891	// Select between integral and enum: not possible to be both.
1892	template<typename _Tp,
1893	bool _IsInt = is_integral<_Tp>::value,
1894	bool _IsEnum = is_enum<_Tp>::value>
1895	class __make_signed_selector;
1896
1897	template<typename _Tp>
1898	class __make_signed_selector<_Tp, true, false>
1899	{
1900	using __signed_type
1901	= typename __make_signed<__remove_cv_t<_Tp>>::__type;
1902
1903	public:
1904	using __type
1905	= typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
1906	};
1907
1908	// Choose signed integer type with the smallest rank and same size as _Tp
1909	template<typename _Tp>
1910	class __make_signed_selector<_Tp, false, true>
1911	{
1912	typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
1913
1914	public:
1915	typedef typename __make_signed_selector<__unsigned_type>::__type __type;
1916	};
1917
1918	// wchar_t, char16_t and char32_t are integral types but are neither
1919	// signed integer types nor unsigned integer types, so must be
1920	// transformed to the signed integer type with the smallest rank.
1921	// Use the partial specialization for enumeration types to do that.
1922	#if defined(__WCHAR_TYPE__)
1923	template<>
1924	struct __make_signed<wchar_t>
1925	{
1926	using __type
1927	= typename __make_signed_selector<wchar_t, false, true>::__type;
1928	};
1929	#endif
1930
1931	#if defined(_GLIBCXX_USE_CHAR8_T)
1932	template<>
1933	struct __make_signed<char8_t>
1934	{
1935	using __type
1936	= typename __make_signed_selector<char8_t, false, true>::__type;
1937	};
1938	#endif
1939
1940	template<>
1941	struct __make_signed<char16_t>
1942	{
1943	using __type
1944	= typename __make_signed_selector<char16_t, false, true>::__type;
1945	};
1946
1947	template<>
1948	struct __make_signed<char32_t>
1949	{
1950	using __type
1951	= typename __make_signed_selector<char32_t, false, true>::__type;
1952	};
1953	/// @endcond
1954
1955	// Given an integral/enum type, return the corresponding signed
1956	// integer type.
1957	// Primary template.
1958	/// make_signed
1959	template<typename _Tp>
1960	struct make_signed
1961	{ typedef typename __make_signed_selector<_Tp>::__type type; };
1962
1963	// Integral, but don't define.
1964	template<>
1965	struct make_signed<bool>;
1966
1967	#if __cplusplus > 201103L
1968	/// Alias template for make_signed
1969	template<typename _Tp>
1970	using make_signed_t = typename make_signed<_Tp>::type;
1971
1972	/// Alias template for make_unsigned
1973	template<typename _Tp>
1974	using make_unsigned_t = typename make_unsigned<_Tp>::type;
1975	#endif
1976
1977	// Array modifications.
1978
1979	/// remove_extent
1980	template<typename _Tp>
1981	struct remove_extent
1982	{ typedef _Tp type; };
1983
1984	template<typename _Tp, std::size_t _Size>
1985	struct remove_extent<_Tp[_Size]>
1986	{ typedef _Tp type; };
1987
1988	template<typename _Tp>
1989	struct remove_extent<_Tp[]>
1990	{ typedef _Tp type; };
1991
1992	/// remove_all_extents
1993	template<typename _Tp>
1994	struct remove_all_extents
1995	{ typedef _Tp type; };
1996
1997	template<typename _Tp, std::size_t _Size>
1998	struct remove_all_extents<_Tp[_Size]>
1999	{ typedef typename remove_all_extents<_Tp>::type type; };
2000
2001	template<typename _Tp>
2002	struct remove_all_extents<_Tp[]>
2003	{ typedef typename remove_all_extents<_Tp>::type type; };
2004
2005	#if __cplusplus > 201103L
2006	/// Alias template for remove_extent
2007	template<typename _Tp>
2008	using remove_extent_t = typename remove_extent<_Tp>::type;
2009
2010	/// Alias template for remove_all_extents
2011	template<typename _Tp>
2012	using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
2013	#endif
2014
2015	// Pointer modifications.
2016
2017	template<typename _Tp, typename>
2018	struct __remove_pointer_helper
2019	{ typedef _Tp type; };
2020
2021	template<typename _Tp, typename _Up>
2022	struct __remove_pointer_helper<_Tp, _Up*>
2023	{ typedef _Up type; };
2024
2025	/// remove_pointer
2026	template<typename _Tp>
2027	struct remove_pointer
2028	: public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>>
2029	{ };
2030
2031	template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
2032	is_void<_Tp>>::value>
2033	struct __add_pointer_helper
2034	{ typedef _Tp type; };
2035
2036	template<typename _Tp>
2037	struct __add_pointer_helper<_Tp, true>
2038	{ typedef typename remove_reference<_Tp>::type* type; };
2039
2040	/// add_pointer
2041	template<typename _Tp>
2042	struct add_pointer
2043	: public __add_pointer_helper<_Tp>
2044	{ };
2045
2046	#if __cplusplus > 201103L
2047	/// Alias template for remove_pointer
2048	template<typename _Tp>
2049	using remove_pointer_t = typename remove_pointer<_Tp>::type;
2050
2051	/// Alias template for add_pointer
2052	template<typename _Tp>
2053	using add_pointer_t = typename add_pointer<_Tp>::type;
2054	#endif
2055
2056	template<std::size_t _Len>
2057	struct __aligned_storage_msa
2058	{
2059	union __type
2060	{
2061	unsigned char __data[_Len];
2062	struct __attribute__((__aligned__)) { } __align;
2063	};
2064	};
2065
2066	/**
2067	* @brief Alignment type.
2068	*
2069	* The value of _Align is a default-alignment which shall be the
2070	* most stringent alignment requirement for any C++ object type
2071	* whose size is no greater than _Len (3.9). The member typedef
2072	* type shall be a POD type suitable for use as uninitialized
2073	* storage for any object whose size is at most _Len and whose
2074	* alignment is a divisor of _Align.
2075	*/
2076	template<std::size_t _Len, std::size_t _Align =
2077	__alignof__(typename __aligned_storage_msa<_Len>::__type)>
2078	struct aligned_storage
2079	{
2080	union type
2081	{
2082	unsigned char __data[_Len];
2083	struct __attribute__((__aligned__((_Align)))) { } __align;
2084	};
2085	};
2086
2087	template <typename... _Types>
2088	struct __strictest_alignment
2089	{
2090	static const size_t _S_alignment = 0;
2091	static const size_t _S_size = 0;
2092	};
2093
2094	template <typename _Tp, typename... _Types>
2095	struct __strictest_alignment<_Tp, _Types...>
2096	{
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;
2103	};
2104
2105	/**
2106	* @brief Provide aligned storage for types.
2107	*
2108	* [meta.trans.other]
2109	*
2110	* Provides aligned storage for any of the provided types of at
2111	* least size _Len.
2112	*
2113	* @see aligned_storage
2114	*/
2115	template <size_t _Len, typename... _Types>
2116	struct aligned_union
2117	{
2118	private:
2119	static_assert(sizeof...(_Types) != 0, "At least one type is required");
2120
2121	using __strictest = __strictest_alignment<_Types...>;
2122	static const size_t _S_len = _Len > __strictest::_S_size
2123	? _Len : __strictest::_S_size;
2124	public:
2125	/// The value of the strictest alignment of _Types.
2126	static const size_t alignment_value = __strictest::_S_alignment;
2127	/// The storage.
2128	typedef typename aligned_storage<_S_len, alignment_value>::type type;
2129	};
2130
2131	template <size_t _Len, typename... _Types>
2132	const size_t aligned_union<_Len, _Types...>::alignment_value;
2133
2134	/// @cond undocumented
2135
2136	// Decay trait for arrays and functions, used for perfect forwarding
2137	// in make_pair, make_tuple, etc.
2138	template<typename _Up,
2139	bool _IsArray = is_array<_Up>::value,
2140	bool _IsFunction = is_function<_Up>::value>
2141	struct __decay_selector;
2142
2143	// NB: DR 705.
2144	template<typename _Up>
2145	struct __decay_selector<_Up, false, false>
2146	{ typedef __remove_cv_t<_Up> __type; };
2147
2148	template<typename _Up>
2149	struct __decay_selector<_Up, true, false>
2150	{ typedef typename remove_extent<_Up>::type* __type; };
2151
2152	template<typename _Up>
2153	struct __decay_selector<_Up, false, true>
2154	{ typedef typename add_pointer<_Up>::type __type; };
2155	/// @endcond
2156
2157	/// decay
2158	template<typename _Tp>
2159	class decay
2160	{
2161	typedef typename remove_reference<_Tp>::type __remove_type;
2162
2163	public:
2164	typedef typename __decay_selector<__remove_type>::__type type;
2165	};
2166
2167	/// @cond undocumented
2168
2169	// Helper which adds a reference to a type when given a reference_wrapper
2170	template<typename _Tp>
2171	struct __strip_reference_wrapper
2172	{
2173	typedef _Tp __type;
2174	};
2175
2176	template<typename _Tp>
2177	struct __strip_reference_wrapper<reference_wrapper<_Tp> >
2178	{
2179	typedef _Tp& __type;
2180	};
2181
2182	// __decay_t (std::decay_t for C++11).
2183	template<typename _Tp>
2184	using __decay_t = typename decay<_Tp>::type;
2185
2186	template<typename _Tp>
2187	using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
2188	/// @endcond
2189
2190	// Primary template.
2191	/// Define a member typedef `type` only if a boolean constant is true.
2192	template<bool, typename _Tp = void>
2193	struct enable_if
2194	{ };
2195
2196	// Partial specialization for true.
2197	template<typename _Tp>
2198	struct enable_if<true, _Tp>
2199	{ typedef _Tp type; };
2200
2201	/// @cond undocumented
2202
2203	// __enable_if_t (std::enable_if_t for C++11)
2204	template<bool _Cond, typename _Tp = void>
2205	using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
2206
2207	// Helper for SFINAE constraints
2208	template<typename... _Cond>
2209	using _Require = __enable_if_t<__and_<_Cond...>::value>;
2210
2211	// __remove_cvref_t (std::remove_cvref_t for C++11).
2212	template<typename _Tp>
2213	using __remove_cvref_t
2214	= typename remove_cv<typename remove_reference<_Tp>::type>::type;
2215	/// @endcond
2216
2217	// Primary template.
2218	/// Define a member typedef @c type to one of two argument types.
2219	template<bool _Cond, typename _Iftrue, typename _Iffalse>
2220	struct conditional
2221	{ typedef _Iftrue type; };
2222
2223	// Partial specialization for false.
2224	template<typename _Iftrue, typename _Iffalse>
2225	struct conditional<false, _Iftrue, _Iffalse>
2226	{ typedef _Iffalse type; };
2227
2228	/// common_type
2229	template<typename... _Tp>
2230	struct common_type;
2231
2232	// Sfinae-friendly common_type implementation:
2233
2234	/// @cond undocumented
2235	struct __do_common_type_impl
2236	{
2237	template<typename _Tp, typename _Up>
2238	using __cond_t
2239	= decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
2240
2241	// if decay_t<decltype(false ? declval<D1>() : declval<D2>())>
2242	// denotes a valid type, let C denote that type.
2243	template<typename _Tp, typename _Up>
2244	static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
2245	_S_test(int);
2246
2247	#if __cplusplus > 201703L
2248	// Otherwise, if COND-RES(CREF(D1), CREF(D2)) denotes a type,
2249	// let C denote the type decay_t<COND-RES(CREF(D1), CREF(D2))>.
2250	template<typename _Tp, typename _Up>
2251	static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>>
2252	_S_test_2(int);
2253	#endif
2254
2255	template<typename, typename>
2256	static __failure_type
2257	_S_test_2(...);
2258
2259	template<typename _Tp, typename _Up>
2260	static decltype(_S_test_2<_Tp, _Up>(0))
2261	_S_test(...);
2262	};
2263
2264	// If sizeof...(T) is zero, there shall be no member type.
2265	template<>
2266	struct common_type<>
2267	{ };
2268
2269	// If sizeof...(T) is one, the same type, if any, as common_type_t<T0, T0>.
2270	template<typename _Tp0>
2271	struct common_type<_Tp0>
2272	: public common_type<_Tp0, _Tp0>
2273	{ };
2274
2275	// If sizeof...(T) is two, ...
2276	template<typename _Tp1, typename _Tp2,
2277	typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
2278	struct __common_type_impl
2279	{
2280	// If is_same_v<T1, D1> is false or is_same_v<T2, D2> is false,
2281	// let C denote the same type, if any, as common_type_t<D1, D2>.
2282	using type = common_type<_Dp1, _Dp2>;
2283	};
2284
2285	template<typename _Tp1, typename _Tp2>
2286	struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
2287	: private __do_common_type_impl
2288	{
2289	// Otherwise, if decay_t<decltype(false ? declval<D1>() : declval<D2>())>
2290	// denotes a valid type, let C denote that type.
2291	using type = decltype(_S_test<_Tp1, _Tp2>(0));
2292	};
2293
2294	// If sizeof...(T) is two, ...
2295	template<typename _Tp1, typename _Tp2>
2296	struct common_type<_Tp1, _Tp2>
2297	: public __common_type_impl<_Tp1, _Tp2>::type
2298	{ };
2299
2300	template<typename...>
2301	struct __common_type_pack
2302	{ };
2303
2304	template<typename, typename, typename = void>
2305	struct __common_type_fold;
2306
2307	// If sizeof...(T) is greater than two, ...
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...>>
2312	{ };
2313
2314	// Let C denote the same type, if any, as common_type_t<T1, T2>.
2315	// If there is such a type C, type shall denote the same type, if any,
2316	// as common_type_t<C, R...>.
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...>
2321	{ };
2322
2323	// Otherwise, there shall be no member type.
2324	template<typename _CTp, typename _Rp>
2325	struct __common_type_fold<_CTp, _Rp, void>
2326	{ };
2327
2328	template<typename _Tp, bool = is_enum<_Tp>::value>
2329	struct __underlying_type_impl
2330	{
2331	using type = __underlying_type(_Tp);
2332	};
2333
2334	template<typename _Tp>
2335	struct __underlying_type_impl<_Tp, false>
2336	{ };
2337	/// @endcond
2338
2339	/// The underlying type of an enum.
2340	template<typename _Tp>
2341	struct underlying_type
2342	: public __underlying_type_impl<_Tp>
2343	{ };
2344
2345	/// @cond undocumented
2346	template<typename _Tp>
2347	struct __declval_protector
2348	{
2349	static const bool __stop = false;
2350	};
2351	/// @endcond
2352
2353	/** Utility to simplify expressions used in unevaluated operands
2354	* @since C++11
2355	* @ingroup utilities
2356	*/
2357	template<typename _Tp>
2358	auto declval() noexcept -> decltype(__declval<_Tp>(0))
2359	{
2360	static_assert(__declval_protector<_Tp>::__stop,
2361	"declval() must not be used!");
2362	return __declval<_Tp>(0);
2363	}
2364
2365	/// result_of
2366	template<typename _Signature>
2367	struct result_of;
2368
2369	// Sfinae-friendly result_of implementation:
2370
2371	#define __cpp_lib_result_of_sfinae 201210
2372
2373	/// @cond undocumented
2374	struct __invoke_memfun_ref { };
2375	struct __invoke_memfun_deref { };
2376	struct __invoke_memobj_ref { };
2377	struct __invoke_memobj_deref { };
2378	struct __invoke_other { };
2379
2380	// Associate a tag type with a specialization of __success_type.
2381	template<typename _Tp, typename _Tag>
2382	struct __result_of_success : __success_type<_Tp>
2383	{ using __invoke_type = _Tag; };
2384
2385	// [func.require] paragraph 1 bullet 1:
2386	struct __result_of_memfun_ref_impl
2387	{
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);
2392
2393	template<typename...>
2394	static __failure_type _S_test(...);
2395	};
2396
2397	template<typename _MemPtr, typename _Arg, typename... _Args>
2398	struct __result_of_memfun_ref
2399	: private __result_of_memfun_ref_impl
2400	{
2401	typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2402	};
2403
2404	// [func.require] paragraph 1 bullet 2:
2405	struct __result_of_memfun_deref_impl
2406	{
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);
2411
2412	template<typename...>
2413	static __failure_type _S_test(...);
2414	};
2415
2416	template<typename _MemPtr, typename _Arg, typename... _Args>
2417	struct __result_of_memfun_deref
2418	: private __result_of_memfun_deref_impl
2419	{
2420	typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2421	};
2422
2423	// [func.require] paragraph 1 bullet 3:
2424	struct __result_of_memobj_ref_impl
2425	{
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);
2430
2431	template<typename, typename>
2432	static __failure_type _S_test(...);
2433	};
2434
2435	template<typename _MemPtr, typename _Arg>
2436	struct __result_of_memobj_ref
2437	: private __result_of_memobj_ref_impl
2438	{
2439	typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2440	};
2441
2442	// [func.require] paragraph 1 bullet 4:
2443	struct __result_of_memobj_deref_impl
2444	{
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);
2449
2450	template<typename, typename>
2451	static __failure_type _S_test(...);
2452	};
2453
2454	template<typename _MemPtr, typename _Arg>
2455	struct __result_of_memobj_deref
2456	: private __result_of_memobj_deref_impl
2457	{
2458	typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
2459	};
2460
2461	template<typename _MemPtr, typename _Arg>
2462	struct __result_of_memobj;
2463
2464	template<typename _Res, typename _Class, typename _Arg>
2465	struct __result_of_memobj<_Res _Class::*, _Arg>
2466	{
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>
2473	>::type::type type;
2474	};
2475
2476	template<typename _MemPtr, typename _Arg, typename... _Args>
2477	struct __result_of_memfun;
2478
2479	template<typename _Res, typename _Class, typename _Arg, typename... _Args>
2480	struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
2481	{
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...>
2487	>::type::type type;
2488	};
2489
2490	// _GLIBCXX_RESOLVE_LIB_DEFECTS
2491	// 2219. INVOKE-ing a pointer to member with a reference_wrapper
2492	// as the object expression
2493
2494	// Used by result_of, invoke etc. to unwrap a reference_wrapper.
2495	template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
2496	struct __inv_unwrap
2497	{
2498	using type = _Tp;
2499	};
2500
2501	template<typename _Tp, typename _Up>
2502	struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
2503	{
2504	using type = _Up&;
2505	};
2506
2507	template<bool, bool, typename _Functor, typename... _ArgTypes>
2508	struct __result_of_impl
2509	{
2510	typedef __failure_type type;
2511	};
2512
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>
2517	{ };
2518
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...>
2523	{ };
2524
2525	// [func.require] paragraph 1 bullet 5:
2526	struct __result_of_other_impl
2527	{
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);
2532
2533	template<typename...>
2534	static __failure_type _S_test(...);
2535	};
2536
2537	template<typename _Functor, typename... _ArgTypes>
2538	struct __result_of_impl<false, false, _Functor, _ArgTypes...>
2539	: private __result_of_other_impl
2540	{
2541	typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2542	};
2543
2544	// __invoke_result (std::invoke_result for C++11)
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
2550	>::value,
2551	is_member_function_pointer<
2552	typename remove_reference<_Functor>::type
2553	>::value,
2554	_Functor, _ArgTypes...
2555	>::type
2556	{ };
2557	/// @endcond
2558
2559	template<typename _Functor, typename... _ArgTypes>
2560	struct result_of<_Functor(_ArgTypes...)>
2561	: public __invoke_result<_Functor, _ArgTypes...>
2562	{ };
2563
2564	#if __cplusplus >= 201402L
2565	/// Alias template for aligned_storage
2566	template<size_t _Len, size_t _Align =
2567	__alignof__(typename __aligned_storage_msa<_Len>::__type)>
2568	using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
2569
2570	template <size_t _Len, typename... _Types>
2571	using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
2572
2573	/// Alias template for decay
2574	template<typename _Tp>
2575	using decay_t = typename decay<_Tp>::type;
2576
2577	/// Alias template for enable_if
2578	template<bool _Cond, typename _Tp = void>
2579	using enable_if_t = typename enable_if<_Cond, _Tp>::type;
2580
2581	/// Alias template for conditional
2582	template<bool _Cond, typename _Iftrue, typename _Iffalse>
2583	using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
2584
2585	/// Alias template for common_type
2586	template<typename... _Tp>
2587	using common_type_t = typename common_type<_Tp...>::type;
2588
2589	/// Alias template for underlying_type
2590	template<typename _Tp>
2591	using underlying_type_t = typename underlying_type<_Tp>::type;
2592
2593	/// Alias template for result_of
2594	template<typename _Tp>
2595	using result_of_t = typename result_of<_Tp>::type;
2596	#endif // C++14
2597
2598	#if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11
2599	#define __cpp_lib_void_t 201411
2600	/// A metafunction that always yields void, used for detecting valid types.
2601	template<typename...> using void_t = void;
2602	#endif
2603
2604	/// @cond undocumented
2605
2606	/// Implementation of the detection idiom (negative case).
2607	template<typename _Default, typename _AlwaysVoid,
2608	template<typename...> class _Op, typename... _Args>
2609	struct __detector
2610	{
2611	using value_t = false_type;
2612	using type = _Default;
2613	};
2614
2615	/// Implementation of the detection idiom (positive case).
2616	template<typename _Default, template<typename...> class _Op,
2617	typename... _Args>
2618	struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
2619	{
2620	using value_t = true_type;
2621	using type = _Op<_Args...>;
2622	};
2623
2624	// Detect whether _Op<_Args...> is a valid type, use _Default if not.
2625	template<typename _Default, template<typename...> class _Op,
2626	typename... _Args>
2627	using __detected_or = __detector<_Default, void, _Op, _Args...>;
2628
2629	// _Op<_Args...> if that is a valid type, otherwise _Default.
2630	template<typename _Default, template<typename...> class _Op,
2631	typename... _Args>
2632	using __detected_or_t
2633	= typename __detected_or<_Default, _Op, _Args...>::type;
2634
2635	/**
2636	* Use SFINAE to determine if the type _Tp has a publicly-accessible
2637	* member type _NTYPE.
2638	*/
2639	#define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \
2640	template<typename _Tp, typename = __void_t<>> \
2641	struct __has_##_NTYPE \
2642	: false_type \
2643	{ }; \
2644	template<typename _Tp> \
2645	struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> \
2646	: true_type \
2647	{ };
2648
2649	template <typename _Tp>
2650	struct __is_swappable;
2651
2652	template <typename _Tp>
2653	struct __is_nothrow_swappable;
2654
2655	template<typename>
2656	struct __is_tuple_like_impl : false_type
2657	{ };
2658
2659	template<typename... _Tps>
2660	struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
2661	{ };
2662
2663	// Internal type trait that allows us to sfinae-protect tuple_cat.
2664	template<typename _Tp>
2665	struct __is_tuple_like
2666	: public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
2667	{ };
2668	/// @endcond
2669
2670	template<typename _Tp>
2671	_GLIBCXX20_CONSTEXPR
2672	inline
2673	_Require<__not_<__is_tuple_like<_Tp>>,
2674	is_move_constructible<_Tp>,
2675	is_move_assignable<_Tp>>
2676	swap(_Tp&, _Tp&)
2677	noexcept(__and_<is_nothrow_move_constructible<_Tp>,
2678	is_nothrow_move_assignable<_Tp>>::value);
2679
2680	template<typename _Tp, size_t _Nm>
2681	_GLIBCXX20_CONSTEXPR
2682	inline
2683	__enable_if_t<__is_swappable<_Tp>::value>
2684	swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
2685	noexcept(__is_nothrow_swappable<_Tp>::value);
2686
2687	/// @cond undocumented
2688	namespace __swappable_details {
2689	using std::swap;
2690
2691	struct __do_is_swappable_impl
2692	{
2693	template<typename _Tp, typename
2694	= decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
2695	static true_type __test(int);
2696
2697	template<typename>
2698	static false_type __test(...);
2699	};
2700
2701	struct __do_is_nothrow_swappable_impl
2702	{
2703	template<typename _Tp>
2704	static __bool_constant<
2705	noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2706	> __test(int);
2707
2708	template<typename>
2709	static false_type __test(...);
2710	};
2711
2712	} // namespace __swappable_details
2713
2714	template<typename _Tp>
2715	struct __is_swappable_impl
2716	: public __swappable_details::__do_is_swappable_impl
2717	{
2718	typedef decltype(__test<_Tp>(0)) type;
2719	};
2720
2721	template<typename _Tp>
2722	struct __is_nothrow_swappable_impl
2723	: public __swappable_details::__do_is_nothrow_swappable_impl
2724	{
2725	typedef decltype(__test<_Tp>(0)) type;
2726	};
2727
2728	template<typename _Tp>
2729	struct __is_swappable
2730	: public __is_swappable_impl<_Tp>::type
2731	{ };
2732
2733	template<typename _Tp>
2734	struct __is_nothrow_swappable
2735	: public __is_nothrow_swappable_impl<_Tp>::type
2736	{ };
2737	/// @endcond
2738
2739	#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
2740	#define __cpp_lib_is_swappable 201603
2741	/// Metafunctions used for detecting swappable types: p0185r1
2742
2743	/// is_swappable
2744	template<typename _Tp>
2745	struct is_swappable
2746	: public __is_swappable_impl<_Tp>::type
2747	{
2748	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2749	"template argument must be a complete class or an unbounded array");
2750	};
2751
2752	/// is_nothrow_swappable
2753	template<typename _Tp>
2754	struct is_nothrow_swappable
2755	: public __is_nothrow_swappable_impl<_Tp>::type
2756	{
2757	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
2758	"template argument must be a complete class or an unbounded array");
2759	};
2760
2761	#if __cplusplus >= 201402L
2762	/// is_swappable_v
2763	template<typename _Tp>
2764	_GLIBCXX17_INLINE constexpr bool is_swappable_v =
2765	is_swappable<_Tp>::value;
2766
2767	/// is_nothrow_swappable_v
2768	template<typename _Tp>
2769	_GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_v =
2770	is_nothrow_swappable<_Tp>::value;
2771	#endif // __cplusplus >= 201402L
2772
2773	/// @cond undocumented
2774	namespace __swappable_with_details {
2775	using std::swap;
2776
2777	struct __do_is_swappable_with_impl
2778	{
2779	template<typename _Tp, typename _Up, typename
2780	= decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
2781	typename
2782	= decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
2783	static true_type __test(int);
2784
2785	template<typename, typename>
2786	static false_type __test(...);
2787	};
2788
2789	struct __do_is_nothrow_swappable_with_impl
2790	{
2791	template<typename _Tp, typename _Up>
2792	static __bool_constant<
2793	noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
2794	&&
2795	noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
2796	> __test(int);
2797
2798	template<typename, typename>
2799	static false_type __test(...);
2800	};
2801
2802	} // namespace __swappable_with_details
2803
2804	template<typename _Tp, typename _Up>
2805	struct __is_swappable_with_impl
2806	: public __swappable_with_details::__do_is_swappable_with_impl
2807	{
2808	typedef decltype(__test<_Tp, _Up>(0)) type;
2809	};
2810
2811	// Optimization for the homogenous lvalue case, not required:
2812	template<typename _Tp>
2813	struct __is_swappable_with_impl<_Tp&, _Tp&>
2814	: public __swappable_details::__do_is_swappable_impl
2815	{
2816	typedef decltype(__test<_Tp&>(0)) type;
2817	};
2818
2819	template<typename _Tp, typename _Up>
2820	struct __is_nothrow_swappable_with_impl
2821	: public __swappable_with_details::__do_is_nothrow_swappable_with_impl
2822	{
2823	typedef decltype(__test<_Tp, _Up>(0)) type;
2824	};
2825
2826	// Optimization for the homogenous lvalue case, not required:
2827	template<typename _Tp>
2828	struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
2829	: public __swappable_details::__do_is_nothrow_swappable_impl
2830	{
2831	typedef decltype(__test<_Tp&>(0)) type;
2832	};
2833	/// @endcond
2834
2835	/// is_swappable_with
2836	template<typename _Tp, typename _Up>
2837	struct is_swappable_with
2838	: public __is_swappable_with_impl<_Tp, _Up>::type
2839	{
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");
2844	};
2845
2846	/// is_nothrow_swappable_with
2847	template<typename _Tp, typename _Up>
2848	struct is_nothrow_swappable_with
2849	: public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
2850	{
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");
2855	};
2856
2857	#if __cplusplus >= 201402L
2858	/// is_swappable_with_v
2859	template<typename _Tp, typename _Up>
2860	_GLIBCXX17_INLINE constexpr bool is_swappable_with_v =
2861	is_swappable_with<_Tp, _Up>::value;
2862
2863	/// is_nothrow_swappable_with_v
2864	template<typename _Tp, typename _Up>
2865	_GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_with_v =
2866	is_nothrow_swappable_with<_Tp, _Up>::value;
2867	#endif // __cplusplus >= 201402L
2868
2869	#endif// c++1z or gnu++11
2870
2871	/// @cond undocumented
2872
2873	// __is_invocable (std::is_invocable for C++11)
2874
2875	// The primary template is used for invalid INVOKE expressions.
2876	template<typename _Result, typename _Ret,
2877	bool = is_void<_Ret>::value, typename = void>
2878	struct __is_invocable_impl
2879	: false_type
2880	{
2881	using __nothrow_type = false_type; // For is_nothrow_invocable_r
2882	};
2883
2884	// Used for valid INVOKE and INVOKE<void> expressions.
2885	template<typename _Result, typename _Ret>
2886	struct __is_invocable_impl<_Result, _Ret,
2887	/* is_void<_Ret> = */ true,
2888	__void_t<typename _Result::type>>
2889	: true_type
2890	{
2891	using __nothrow_type = true_type; // For is_nothrow_invocable_r
2892	};
2893
2894	#pragma GCC diagnostic push
2895	#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
2896	// Used for INVOKE<R> expressions to check the implicit conversion to R.
2897	template<typename _Result, typename _Ret>
2898	struct __is_invocable_impl<_Result, _Ret,
2899	/* is_void<_Ret> = */ false,
2900	__void_t<typename _Result::type>>
2901	{
2902	private:
2903	// The type of the INVOKE expression.
2904	// Unlike declval, this doesn't add_rvalue_reference, so it respects
2905	// guaranteed copy elision.
2906	static typename _Result::type _S_get() noexcept;
2907
2908	template<typename _Tp>
2909	static void _S_conv(_Tp) noexcept;
2910
2911	// This overload is viable if INVOKE(f, args...) can convert to _Tp.
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>
2916	_S_test(int);
2917
2918	template<typename _Tp, bool = false>
2919	static false_type
2920	_S_test(...);
2921
2922	public:
2923	// For is_invocable_r
2924	using type = decltype(_S_test<_Ret>(1));
2925
2926	// For is_nothrow_invocable_r
2927	using __nothrow_type = decltype(_S_test<_Ret, true>(1));
2928	};
2929	#pragma GCC diagnostic pop
2930
2931	template<typename _Fn, typename... _ArgTypes>
2932	struct __is_invocable
2933	: __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
2934	{ };
2935
2936	template<typename _Fn, typename _Tp, typename... _Args>
2937	constexpr bool __call_is_nt(__invoke_memfun_ref)
2938	{
2939	using _Up = typename __inv_unwrap<_Tp>::type;
2940	return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
2941	std::declval<_Args>()...));
2942	}
2943
2944	template<typename _Fn, typename _Tp, typename... _Args>
2945	constexpr bool __call_is_nt(__invoke_memfun_deref)
2946	{
2947	return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
2948	std::declval<_Args>()...));
2949	}
2950
2951	template<typename _Fn, typename _Tp>
2952	constexpr bool __call_is_nt(__invoke_memobj_ref)
2953	{
2954	using _Up = typename __inv_unwrap<_Tp>::type;
2955	return noexcept(std::declval<_Up>().*std::declval<_Fn>());
2956	}
2957
2958	template<typename _Fn, typename _Tp>
2959	constexpr bool __call_is_nt(__invoke_memobj_deref)
2960	{
2961	return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
2962	}
2963
2964	template<typename _Fn, typename... _Args>
2965	constexpr bool __call_is_nt(__invoke_other)
2966	{
2967	return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
2968	}
2969
2970	template<typename _Result, typename _Fn, typename... _Args>
2971	struct __call_is_nothrow
2972	: __bool_constant<
2973	std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
2974	>
2975	{ };
2976
2977	template<typename _Fn, typename... _Args>
2978	using __call_is_nothrow_
2979	= __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
2980
2981	// __is_nothrow_invocable (std::is_nothrow_invocable for C++11)
2982	template<typename _Fn, typename... _Args>
2983	struct __is_nothrow_invocable
2984	: __and_<__is_invocable<_Fn, _Args...>,
2985	__call_is_nothrow_<_Fn, _Args...>>::type
2986	{ };
2987
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;
2995	};
2996	#pragma GCC diagnostic pop
2997	/// @endcond
2998
2999	#if __cplusplus >= 201703L
3000	# define __cpp_lib_is_invocable 201703
3001
3002	/// std::invoke_result
3003	template<typename _Functor, typename... _ArgTypes>
3004	struct invoke_result
3005	: public __invoke_result<_Functor, _ArgTypes...>
3006	{
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");
3012	};
3013
3014	/// std::invoke_result_t
3015	template<typename _Fn, typename... _Args>
3016	using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
3017
3018	/// std::is_invocable
3019	template<typename _Fn, typename... _ArgTypes>
3020	struct is_invocable
3021	: __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
3022	{
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");
3028	};
3029
3030	/// std::is_invocable_r
3031	template<typename _Ret, typename _Fn, typename... _ArgTypes>
3032	struct is_invocable_r
3033	: __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
3034	{
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");
3042	};
3043
3044	/// std::is_nothrow_invocable
3045	template<typename _Fn, typename... _ArgTypes>
3046	struct is_nothrow_invocable
3047	: __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
3048	__call_is_nothrow_<_Fn, _ArgTypes...>>::type
3049	{
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");
3055	};
3056
3057	/// @cond undocumented
3058	template<typename _Result, typename _Ret>
3059	using __is_nt_invocable_impl
3060	= typename __is_invocable_impl<_Result, _Ret>::__nothrow_type;
3061	/// @endcond
3062
3063	/// std::is_nothrow_invocable_r
3064	template<typename _Ret, typename _Fn, typename... _ArgTypes>
3065	struct is_nothrow_invocable_r
3066	: __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
3067	__call_is_nothrow_<_Fn, _ArgTypes...>>::type
3068	{
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");
3076	};
3077	#endif // C++17
3078
3079	#if __cplusplus >= 201703L
3080	# define __cpp_lib_type_trait_variable_templates 201510L
3081	/**
3082	* @defgroup variable_templates Variable templates for type traits.
3083	* @ingroup metaprogramming
3084	*
3085	* The variable `is_foo_v<T>` is a boolean constant with the same value
3086	* as the type trait `is_foo<T>::value`.
3087	*
3088	* @since C++17
3089	*/
3090
3091	/** @ingroup variable_templates
3092	* @{
3093	*/
3094	template <typename _Tp>
3095	inline constexpr bool is_void_v = is_void<_Tp>::value;
3096	template <typename _Tp>
3097	inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
3098	template <typename _Tp>
3099	inline constexpr bool is_integral_v = is_integral<_Tp>::value;
3100	template <typename _Tp>
3101	inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
3102	template <typename _Tp>
3103	inline constexpr bool is_array_v = is_array<_Tp>::value;
3104	template <typename _Tp>
3105	inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
3106	template <typename _Tp>
3107	inline constexpr bool is_lvalue_reference_v =
3108	is_lvalue_reference<_Tp>::value;
3109	template <typename _Tp>
3110	inline constexpr bool is_rvalue_reference_v =
3111	is_rvalue_reference<_Tp>::value;
3112	template <typename _Tp>
3113	inline constexpr bool is_member_object_pointer_v =
3114	is_member_object_pointer<_Tp>::value;
3115	template <typename _Tp>
3116	inline constexpr bool is_member_function_pointer_v =
3117	is_member_function_pointer<_Tp>::value;
3118	template <typename _Tp>
3119	inline constexpr bool is_enum_v = is_enum<_Tp>::value;
3120	template <typename _Tp>
3121	inline constexpr bool is_union_v = is_union<_Tp>::value;
3122	template <typename _Tp>
3123	inline constexpr bool is_class_v = is_class<_Tp>::value;
3124	template <typename _Tp>
3125	inline constexpr bool is_function_v = is_function<_Tp>::value;
3126	template <typename _Tp>
3127	inline constexpr bool is_reference_v = is_reference<_Tp>::value;
3128	template <typename _Tp>
3129	inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
3130	template <typename _Tp>
3131	inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
3132	template <typename _Tp>
3133	inline constexpr bool is_object_v = is_object<_Tp>::value;
3134	template <typename _Tp>
3135	inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
3136	template <typename _Tp>
3137	inline constexpr bool is_compound_v = is_compound<_Tp>::value;
3138	template <typename _Tp>
3139	inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
3140	template <typename _Tp>
3141	inline constexpr bool is_const_v = is_const<_Tp>::value;
3142	template <typename _Tp>
3143	inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
3144	template <typename _Tp>
3145	inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
3146	template <typename _Tp>
3147	inline constexpr bool is_trivially_copyable_v =
3148	is_trivially_copyable<_Tp>::value;
3149	template <typename _Tp>
3150	inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
3151	#pragma GCC diagnostic push
3152	#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
3153	template <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;
3156	template <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>
3161	inline constexpr bool is_empty_v = is_empty<_Tp>::value;
3162	template <typename _Tp>
3163	inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
3164	template <typename _Tp>
3165	inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
3166	template <typename _Tp>
3167	inline constexpr bool is_final_v = is_final<_Tp>::value;
3168	template <typename _Tp>
3169	inline constexpr bool is_signed_v = is_signed<_Tp>::value;
3170	template <typename _Tp>
3171	inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
3172	template <typename _Tp, typename... _Args>
3173	inline constexpr bool is_constructible_v =
3174	is_constructible<_Tp, _Args...>::value;
3175	template <typename _Tp>
3176	inline constexpr bool is_default_constructible_v =
3177	is_default_constructible<_Tp>::value;
3178	template <typename _Tp>
3179	inline constexpr bool is_copy_constructible_v =
3180	is_copy_constructible<_Tp>::value;
3181	template <typename _Tp>
3182	inline constexpr bool is_move_constructible_v =
3183	is_move_constructible<_Tp>::value;
3184	template <typename _Tp, typename _Up>
3185	inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
3186	template <typename _Tp>
3187	inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
3188	template <typename _Tp>
3189	inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
3190	template <typename _Tp>
3191	inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
3192	template <typename _Tp, typename... _Args>
3193	inline constexpr bool is_trivially_constructible_v =
3194	is_trivially_constructible<_Tp, _Args...>::value;
3195	template <typename _Tp>
3196	inline constexpr bool is_trivially_default_constructible_v =
3197	is_trivially_default_constructible<_Tp>::value;
3198	template <typename _Tp>
3199	inline constexpr bool is_trivially_copy_constructible_v =
3200	is_trivially_copy_constructible<_Tp>::value;
3201	template <typename _Tp>
3202	inline constexpr bool is_trivially_move_constructible_v =
3203	is_trivially_move_constructible<_Tp>::value;
3204	template <typename _Tp, typename _Up>
3205	inline constexpr bool is_trivially_assignable_v =
3206	is_trivially_assignable<_Tp, _Up>::value;
3207	template <typename _Tp>
3208	inline constexpr bool is_trivially_copy_assignable_v =
3209	is_trivially_copy_assignable<_Tp>::value;
3210	template <typename _Tp>
3211	inline constexpr bool is_trivially_move_assignable_v =
3212	is_trivially_move_assignable<_Tp>::value;
3213	template <typename _Tp>
3214	inline constexpr bool is_trivially_destructible_v =
3215	is_trivially_destructible<_Tp>::value;
3216	template <typename _Tp, typename... _Args>
3217	inline constexpr bool is_nothrow_constructible_v =
3218	is_nothrow_constructible<_Tp, _Args...>::value;
3219	template <typename _Tp>
3220	inline constexpr bool is_nothrow_default_constructible_v =
3221	is_nothrow_default_constructible<_Tp>::value;
3222	template <typename _Tp>
3223	inline constexpr bool is_nothrow_copy_constructible_v =
3224	is_nothrow_copy_constructible<_Tp>::value;
3225	template <typename _Tp>
3226	inline constexpr bool is_nothrow_move_constructible_v =
3227	is_nothrow_move_constructible<_Tp>::value;
3228	template <typename _Tp, typename _Up>
3229	inline constexpr bool is_nothrow_assignable_v =
3230	is_nothrow_assignable<_Tp, _Up>::value;
3231	template <typename _Tp>
3232	inline constexpr bool is_nothrow_copy_assignable_v =
3233	is_nothrow_copy_assignable<_Tp>::value;
3234	template <typename _Tp>
3235	inline constexpr bool is_nothrow_move_assignable_v =
3236	is_nothrow_move_assignable<_Tp>::value;
3237	template <typename _Tp>
3238	inline constexpr bool is_nothrow_destructible_v =
3239	is_nothrow_destructible<_Tp>::value;
3240	template <typename _Tp>
3241	inline constexpr bool has_virtual_destructor_v =
3242	has_virtual_destructor<_Tp>::value;
3243	template <typename _Tp>
3244	inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
3245	template <typename _Tp>
3246	inline constexpr size_t rank_v = rank<_Tp>::value;
3247	template <typename _Tp, unsigned _Idx = 0>
3248	inline constexpr size_t extent_v = extent<_Tp, _Idx>::value;
3249	#ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME
3250	template <typename _Tp, typename _Up>
3251	inline constexpr bool is_same_v = __is_same(_Tp, _Up);
3252	#else
3253	template <typename _Tp, typename _Up>
3254	inline constexpr bool is_same_v = std::is_same<_Tp, _Up>::value;
3255	#endif
3256	template <typename _Base, typename _Derived>
3257	inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
3258	template <typename _From, typename _To>
3259	inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
3260	template<typename _Fn, typename... _Args>
3261	inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
3262	template<typename _Fn, typename... _Args>
3263	inline constexpr bool is_nothrow_invocable_v
3264	= is_nothrow_invocable<_Fn, _Args...>::value;
3265	template<typename _Ret, typename _Fn, typename... _Args>
3266	inline constexpr bool is_invocable_r_v
3267	= is_invocable_r<_Ret, _Fn, _Args...>::value;
3268	template<typename _Ret, typename _Fn, typename... _Args>
3269	inline constexpr bool is_nothrow_invocable_r_v
3270	= is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
3271	/// @}
3272
3273	#ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP
3274	# define __cpp_lib_has_unique_object_representations 201606
3275	/// has_unique_object_representations
3276	template<typename _Tp>
3277	struct has_unique_object_representations
3278	: bool_constant<__has_unique_object_representations(
3279	remove_cv_t<remove_all_extents_t<_Tp>>
3280	)>
3281	{
3282	static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
3283	"template argument must be a complete class or an unbounded array");
3284	};
3285
3286	/// @ingroup variable_templates
3287	template<typename _Tp>
3288	inline constexpr bool has_unique_object_representations_v
3289	= has_unique_object_representations<_Tp>::value;
3290	#endif
3291
3292	#ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE
3293	# define __cpp_lib_is_aggregate 201703
3294	/// is_aggregate
3295	template<typename _Tp>
3296	struct is_aggregate
3297	: bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
3298	{ };
3299
3300	/// @ingroup variable_templates
3301	template<typename _Tp>
3302	inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
3303	#endif
3304	#endif // C++17
3305
3306	#if __cplusplus > 201703L
3307	#define __cpp_lib_remove_cvref 201711L
3308
3309	/// Remove references and cv-qualifiers.
3310	template<typename _Tp>
3311	struct remove_cvref
3312	: remove_cv<_Tp>
3313	{ };
3314
3315	template<typename _Tp>
3316	struct remove_cvref<_Tp&>
3317	: remove_cv<_Tp>
3318	{ };
3319
3320	template<typename _Tp>
3321	struct remove_cvref<_Tp&&>
3322	: remove_cv<_Tp>
3323	{ };
3324
3325	template<typename _Tp>
3326	using remove_cvref_t = typename remove_cvref<_Tp>::type;
3327
3328	#define __cpp_lib_type_identity 201806L
3329	/// Identity metafunction.
3330	template<typename _Tp>
3331	struct type_identity { using type = _Tp; };
3332
3333	template<typename _Tp>
3334	using type_identity_t = typename type_identity<_Tp>::type;
3335
3336	#define __cpp_lib_unwrap_ref 201811L
3337
3338	/// Unwrap a reference_wrapper
3339	template<typename _Tp>
3340	struct unwrap_reference { using type = _Tp; };
3341
3342	template<typename _Tp>
3343	struct unwrap_reference<reference_wrapper<_Tp>> { using type = _Tp&; };
3344
3345	template<typename _Tp>
3346	using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
3347
3348	/// Decay type and if it's a reference_wrapper, unwrap it
3349	template<typename _Tp>
3350	struct unwrap_ref_decay { using type = unwrap_reference_t<decay_t<_Tp>>; };
3351
3352	template<typename _Tp>
3353	using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
3354
3355	#define __cpp_lib_bounded_array_traits 201902L
3356
3357	/// True for a type that is an array of known bound.
3358	template<typename _Tp>
3359	struct is_bounded_array
3360	: public __is_array_known_bounds<_Tp>
3361	{ };
3362
3363	/// True for a type that is an array of unknown bound.
3364	template<typename _Tp>
3365	struct is_unbounded_array
3366	: public __is_array_unknown_bounds<_Tp>
3367	{ };
3368
3369	/// @ingroup variable_templates
3370	template<typename _Tp>
3371	inline constexpr bool is_bounded_array_v
3372	= is_bounded_array<_Tp>::value;
3373
3374	/// @ingroup variable_templates
3375	template<typename _Tp>
3376	inline constexpr bool is_unbounded_array_v
3377	= is_unbounded_array<_Tp>::value;
3378
3379	#if __cplusplus > 202002L
3380	#define __cpp_lib_is_scoped_enum 202011L
3381
3382	/// @since C++23
3383	//@{
3384
3385	template<typename _Tp>
3386	struct is_scoped_enum
3387	: false_type
3388	{ };
3389
3390	template<typename _Tp>
3391	requires __is_enum(_Tp)
3392	&& requires(_Tp __t) { __t = __t; } // fails if incomplete
3393	struct is_scoped_enum<_Tp>
3394	: bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
3395	{ };
3396
3397	// FIXME remove this partial specialization and use remove_cv_t<_Tp> above
3398	// when PR c++/99968 is fixed.
3399	template<typename _Tp>
3400	requires __is_enum(_Tp)
3401	&& requires(_Tp __t) { __t = __t; } // fails if incomplete
3402	struct is_scoped_enum<const _Tp>
3403	: bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }>
3404	{ };
3405
3406	/**
3407	* @ingroup variable_templates
3408	*/
3409	template<typename _Tp>
3410	inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
3411	#endif // C++23
3412
3413	#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
3414
3415	#define __cpp_lib_is_constant_evaluated 201811L
3416
3417	/// Returns true only when called during constant evaluation.
3418	constexpr inline bool
3419	is_constant_evaluated() noexcept
3420	{ return __builtin_is_constant_evaluated(); }
3421	/// @}
3422	#endif
3423
3424	/// @cond undocumented
3425	template<typename _From, typename _To>
3426	using __copy_cv = typename __match_cv_qualifiers<_From, _To>::__type;
3427
3428	template<typename _Xp, typename _Yp>
3429	using __cond_res
3430	= decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());
3431
3432	template<typename _Ap, typename _Bp, typename = void>
3433	struct __common_ref_impl
3434	{ };
3435
3436	// [meta.trans.other], COMMON-REF(A, B)
3437	template<typename _Ap, typename _Bp>
3438	using __common_ref = typename __common_ref_impl<_Ap, _Bp>::type;
3439
3440	// COND-RES(COPYCV(X, Y) &, COPYCV(Y, X) &)
3441	template<typename _Xp, typename _Yp>
3442	using __condres_cvref
3443	= __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>;
3444
3445	// If A and B are both lvalue reference types, ...
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>>
3450	{ };
3451
3452	// let C be remove_reference_t<COMMON-REF(X&, Y&)>&&
3453	template<typename _Xp, typename _Yp>
3454	using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&;
3455
3456	// If A and B are both rvalue reference types, ...
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>; };
3462
3463	// let D be COMMON-REF(const X&, Y&)
3464	template<typename _Xp, typename _Yp>
3465	using __common_ref_D = __common_ref<const _Xp&, _Yp&>;
3466
3467	// If A is an rvalue reference and B is an lvalue reference, ...
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>; };
3472
3473	// If A is an lvalue reference and B is an rvalue reference, ...
3474	template<typename _Xp, typename _Yp>
3475	struct __common_ref_impl<_Xp&, _Yp&&>
3476	: __common_ref_impl<_Yp&&, _Xp&>
3477	{ };
3478	/// @endcond
3479
3480	template<typename _Tp, typename _Up,
3481	template<typename> class _TQual, template<typename> class _UQual>
3482	struct basic_common_reference
3483	{ };
3484
3485	/// @cond undocumented
3486	template<typename _Tp>
3487	struct __xref
3488	{ template<typename _Up> using __type = __copy_cv<_Tp, _Up>; };
3489
3490	template<typename _Tp>
3491	struct __xref<_Tp&>
3492	{ template<typename _Up> using __type = __copy_cv<_Tp, _Up>&; };
3493
3494	template<typename _Tp>
3495	struct __xref<_Tp&&>
3496	{ template<typename _Up> using __type = __copy_cv<_Tp, _Up>&&; };
3497
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;
3504	/// @endcond
3505
3506	template<typename... _Tp>
3507	struct common_reference;
3508
3509	template<typename... _Tp>
3510	using common_reference_t = typename common_reference<_Tp...>::type;
3511
3512	// If sizeof...(T) is zero, there shall be no member type.
3513	template<>
3514	struct common_reference<>
3515	{ };
3516
3517	// If sizeof...(T) is one ...
3518	template<typename _Tp0>
3519	struct common_reference<_Tp0>
3520	{ using type = _Tp0; };
3521
3522	/// @cond undocumented
3523	template<typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void>
3524	struct __common_reference_impl
3525	: __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
3526	{ };
3527
3528	// If sizeof...(T) is two ...
3529	template<typename _Tp1, typename _Tp2>
3530	struct common_reference<_Tp1, _Tp2>
3531	: __common_reference_impl<_Tp1, _Tp2>
3532	{ };
3533
3534	// If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, ...
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&>; };
3539
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&&>; };
3544
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&&>; };
3549
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&>; };
3554
3555	// Otherwise, if basic_common_reference<...>::type is well-formed, ...
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>; };
3560
3561	// Otherwise, if COND-RES(T1, T2) is well-formed, ...
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>; };
3566
3567	// Otherwise, if common_type_t<T1, T2> is well-formed, ...
3568	template<typename _Tp1, typename _Tp2>
3569	struct __common_reference_impl<_Tp1, _Tp2, 4,
3570	void_t<common_type_t<_Tp1, _Tp2>>>
3571	{ using type = common_type_t<_Tp1, _Tp2>; };
3572
3573	// Otherwise, there shall be no member type.
3574	template<typename _Tp1, typename _Tp2>
3575	struct __common_reference_impl<_Tp1, _Tp2, 5, void>
3576	{ };
3577
3578	// Otherwise, if sizeof...(T) is greater than two, ...
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...>>
3583	{ };
3584
3585	// Reuse __common_type_fold for common_reference<T1, T2, 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...>
3591	{ };
3592	/// @endcond
3593
3594	#endif // C++2a
3595
3596	/// @} group metaprogramming
3597
3598	_GLIBCXX_END_NAMESPACE_VERSION
3599	} // namespace std
3600
3601	#endif // C++11
3602
3603	#endif // _GLIBCXX_TYPE_TRAITS
3604