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