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