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