libstdc++

type_traits
Go to the documentation of this file.
1 // C++11 <type_traits> -*- C++ -*-
2
3 // Copyright (C) 2007-2013 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file include/type_traits
26 * This is a Standard C++ Library header.
27 */
28
29 #ifndef _GLIBCXX_TYPE_TRAITS
30 #define _GLIBCXX_TYPE_TRAITS 1
31
32 #pragma GCC system_header
33
34 #if __cplusplus < 201103L
35 # include <bits/c++0x_warning.h>
36 #else
37
38 #include <bits/c++config.h>
39
40 namespace std _GLIBCXX_VISIBILITY(default)
41 {
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
43
44 /**
45 * @defgroup metaprogramming Metaprogramming
46 * @ingroup utilities
47 *
48 * Template utilities for compile-time introspection and modification,
49 * including type classification traits, type property inspection traits
50 * and type transformation traits.
51 *
52 * @{
53 */
54
55 /// integral_constant
56 template<typename _Tp, _Tp __v>
57 struct integral_constant
58 {
59 static constexpr _Tp value = __v;
60 typedef _Tp value_type;
61 typedef integral_constant<_Tp, __v> type;
62 constexpr operator value_type() { return value; }
63 };
64
65 template<typename _Tp, _Tp __v>
66 constexpr _Tp integral_constant<_Tp, __v>::value;
67
68 /// The type used as a compile-time boolean with true value.
69 typedef integral_constant<bool, true> true_type;
70
71 /// The type used as a compile-time boolean with false value.
72 typedef integral_constant<bool, false> false_type;
73
74 // Meta programming helper types.
75
76 template<bool, typename, typename>
77 struct conditional;
78
79 template<typename...>
80 struct __or_;
81
82 template<>
83 struct __or_<>
84 : public false_type
85 { };
86
87 template<typename _B1>
88 struct __or_<_B1>
89 : public _B1
90 { };
91
92 template<typename _B1, typename _B2>
93 struct __or_<_B1, _B2>
94 : public conditional<_B1::value, _B1, _B2>::type
95 { };
96
97 template<typename _B1, typename _B2, typename _B3, typename... _Bn>
98 struct __or_<_B1, _B2, _B3, _Bn...>
99 : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
100 { };
101
102 template<typename...>
103 struct __and_;
104
105 template<>
106 struct __and_<>
107 : public true_type
108 { };
109
110 template<typename _B1>
111 struct __and_<_B1>
112 : public _B1
113 { };
114
115 template<typename _B1, typename _B2>
116 struct __and_<_B1, _B2>
117 : public conditional<_B1::value, _B2, _B1>::type
118 { };
119
120 template<typename _B1, typename _B2, typename _B3, typename... _Bn>
121 struct __and_<_B1, _B2, _B3, _Bn...>
122 : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
123 { };
124
125 template<typename _Pp>
126 struct __not_
127 : public integral_constant<bool, !_Pp::value>
128 { };
129
130 struct __sfinae_types
131 {
132 typedef char __one;
133 typedef struct { char __arr[2]; } __two;
134 };
135
136 // For several sfinae-friendly trait implementations we transport both the
137 // result information (as the member type) and the failure information (no
138 // member type). This is very similar to std::enable_if, but we cannot use
139 // them, because we need to derive from them as an implementation detail.
140
141 template<typename _Tp>
142 struct __success_type
143 { typedef _Tp type; };
144
145 struct __failure_type
146 { };
147
148 // Primary type categories.
149
150 template<typename>
151 struct remove_cv;
152
153 template<typename>
154 struct __is_void_helper
155 : public false_type { };
156
157 template<>
158 struct __is_void_helper<void>
159 : public true_type { };
160
161 /// is_void
162 template<typename _Tp>
163 struct is_void
164 : public integral_constant<bool, (__is_void_helper<typename
165 remove_cv<_Tp>::type>::value)>
166 { };
167
168 template<typename>
169 struct __is_integral_helper
170 : public false_type { };
171
172 template<>
173 struct __is_integral_helper<bool>
174 : public true_type { };
175
176 template<>
177 struct __is_integral_helper<char>
178 : public true_type { };
179
180 template<>
181 struct __is_integral_helper<signed char>
182 : public true_type { };
183
184 template<>
185 struct __is_integral_helper<unsigned char>
186 : public true_type { };
187
188 #ifdef _GLIBCXX_USE_WCHAR_T
189 template<>
190 struct __is_integral_helper<wchar_t>
191 : public true_type { };
192 #endif
193
194 template<>
195 struct __is_integral_helper<char16_t>
196 : public true_type { };
197
198 template<>
199 struct __is_integral_helper<char32_t>
200 : public true_type { };
201
202 template<>
203 struct __is_integral_helper<short>
204 : public true_type { };
205
206 template<>
207 struct __is_integral_helper<unsigned short>
208 : public true_type { };
209
210 template<>
211 struct __is_integral_helper<int>
212 : public true_type { };
213
214 template<>
215 struct __is_integral_helper<unsigned int>
216 : public true_type { };
217
218 template<>
219 struct __is_integral_helper<long>
220 : public true_type { };
221
222 template<>
223 struct __is_integral_helper<unsigned long>
224 : public true_type { };
225
226 template<>
227 struct __is_integral_helper<long long>
228 : public true_type { };
229
230 template<>
231 struct __is_integral_helper<unsigned long long>
232 : public true_type { };
233
234 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
235 template<>
236 struct __is_integral_helper<__int128>
237 : public true_type { };
238
239 template<>
240 struct __is_integral_helper<unsigned __int128>
241 : public true_type { };
242 #endif
243
244 /// is_integral
245 template<typename _Tp>
246 struct is_integral
247 : public integral_constant<bool, (__is_integral_helper<typename
248 remove_cv<_Tp>::type>::value)>
249 { };
250
251 template<typename>
252 struct __is_floating_point_helper
253 : public false_type { };
254
255 template<>
256 struct __is_floating_point_helper<float>
257 : public true_type { };
258
259 template<>
260 struct __is_floating_point_helper<double>
261 : public true_type { };
262
263 template<>
264 struct __is_floating_point_helper<long double>
265 : public true_type { };
266
267 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128)
268 template<>
269 struct __is_floating_point_helper<__float128>
270 : public true_type { };
271 #endif
272
273 /// is_floating_point
274 template<typename _Tp>
275 struct is_floating_point
276 : public integral_constant<bool, (__is_floating_point_helper<typename
277 remove_cv<_Tp>::type>::value)>
278 { };
279
280 /// is_array
281 template<typename>
282 struct is_array
283 : public false_type { };
284
285 template<typename _Tp, std::size_t _Size>
286 struct is_array<_Tp[_Size]>
287 : public true_type { };
288
289 template<typename _Tp>
290 struct is_array<_Tp[]>
291 : public true_type { };
292
293 template<typename>
294 struct __is_pointer_helper
295 : public false_type { };
296
297 template<typename _Tp>
298 struct __is_pointer_helper<_Tp*>
299 : public true_type { };
300
301 /// is_pointer
302 template<typename _Tp>
303 struct is_pointer
304 : public integral_constant<bool, (__is_pointer_helper<typename
305 remove_cv<_Tp>::type>::value)>
306 { };
307
308 /// is_lvalue_reference
309 template<typename>
310 struct is_lvalue_reference
311 : public false_type { };
312
313 template<typename _Tp>
314 struct is_lvalue_reference<_Tp&>
315 : public true_type { };
316
317 /// is_rvalue_reference
318 template<typename>
319 struct is_rvalue_reference
320 : public false_type { };
321
322 template<typename _Tp>
323 struct is_rvalue_reference<_Tp&&>
324 : public true_type { };
325
326 template<typename>
327 struct is_function;
328
329 template<typename>
330 struct __is_member_object_pointer_helper
331 : public false_type { };
332
333 template<typename _Tp, typename _Cp>
334 struct __is_member_object_pointer_helper<_Tp _Cp::*>
335 : public integral_constant<bool, !is_function<_Tp>::value> { };
336
337 /// is_member_object_pointer
338 template<typename _Tp>
339 struct is_member_object_pointer
340 : public integral_constant<bool, (__is_member_object_pointer_helper<
341 typename remove_cv<_Tp>::type>::value)>
342 { };
343
344 template<typename>
345 struct __is_member_function_pointer_helper
346 : public false_type { };
347
348 template<typename _Tp, typename _Cp>
349 struct __is_member_function_pointer_helper<_Tp _Cp::*>
350 : public integral_constant<bool, is_function<_Tp>::value> { };
351
352 /// is_member_function_pointer
353 template<typename _Tp>
354 struct is_member_function_pointer
355 : public integral_constant<bool, (__is_member_function_pointer_helper<
356 typename remove_cv<_Tp>::type>::value)>
357 { };
358
359 /// is_enum
360 template<typename _Tp>
361 struct is_enum
362 : public integral_constant<bool, __is_enum(_Tp)>
363 { };
364
365 /// is_union
366 template<typename _Tp>
367 struct is_union
368 : public integral_constant<bool, __is_union(_Tp)>
369 { };
370
371 /// is_class
372 template<typename _Tp>
373 struct is_class
374 : public integral_constant<bool, __is_class(_Tp)>
375 { };
376
377 /// is_function
378 template<typename>
379 struct is_function
380 : public false_type { };
381
382 template<typename _Res, typename... _ArgTypes>
383 struct is_function<_Res(_ArgTypes...)>
384 : public true_type { };
385
386 template<typename _Res, typename... _ArgTypes>
387 struct is_function<_Res(_ArgTypes......)>
388 : public true_type { };
389
390 template<typename _Res, typename... _ArgTypes>
391 struct is_function<_Res(_ArgTypes...) const>
392 : public true_type { };
393
394 template<typename _Res, typename... _ArgTypes>
395 struct is_function<_Res(_ArgTypes......) const>
396 : public true_type { };
397
398 template<typename _Res, typename... _ArgTypes>
399 struct is_function<_Res(_ArgTypes...) volatile>
400 : public true_type { };
401
402 template<typename _Res, typename... _ArgTypes>
403 struct is_function<_Res(_ArgTypes......) volatile>
404 : public true_type { };
405
406 template<typename _Res, typename... _ArgTypes>
407 struct is_function<_Res(_ArgTypes...) const volatile>
408 : public true_type { };
409
410 template<typename _Res, typename... _ArgTypes>
411 struct is_function<_Res(_ArgTypes......) const volatile>
412 : public true_type { };
413
414 template<typename>
415 struct __is_nullptr_t_helper
416 : public false_type { };
417
418 template<>
419 struct __is_nullptr_t_helper<std::nullptr_t>
420 : public true_type { };
421
422 // __is_nullptr_t (extension).
423 template<typename _Tp>
424 struct __is_nullptr_t
425 : public integral_constant<bool, (__is_nullptr_t_helper<typename
426 remove_cv<_Tp>::type>::value)>
427 { };
428
429 // Composite type categories.
430
431 /// is_reference
432 template<typename _Tp>
433 struct is_reference
434 : public __or_<is_lvalue_reference<_Tp>,
435 is_rvalue_reference<_Tp>>::type
436 { };
437
438 /// is_arithmetic
439 template<typename _Tp>
440 struct is_arithmetic
441 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
442 { };
443
444 /// is_fundamental
445 template<typename _Tp>
446 struct is_fundamental
447 : public __or_<is_arithmetic<_Tp>, is_void<_Tp>>::type
448 { };
449
450 /// is_object
451 template<typename _Tp>
452 struct is_object
453 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
454 is_void<_Tp>>>::type
455 { };
456
457 template<typename>
458 struct is_member_pointer;
459
460 /// is_scalar
461 template<typename _Tp>
462 struct is_scalar
463 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
464 is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type
465 { };
466
467 /// is_compound
468 template<typename _Tp>
469 struct is_compound
470 : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
471
472 template<typename _Tp>
473 struct __is_member_pointer_helper
474 : public false_type { };
475
476 template<typename _Tp, typename _Cp>
477 struct __is_member_pointer_helper<_Tp _Cp::*>
478 : public true_type { };
479
480 /// is_member_pointer
481 template<typename _Tp>
482 struct is_member_pointer
483 : public integral_constant<bool, (__is_member_pointer_helper<
484 typename remove_cv<_Tp>::type>::value)>
485 { };
486
487 // Type properties.
488
489 /// is_const
490 template<typename>
491 struct is_const
492 : public false_type { };
493
494 template<typename _Tp>
495 struct is_const<_Tp const>
496 : public true_type { };
497
498 /// is_volatile
499 template<typename>
500 struct is_volatile
501 : public false_type { };
502
503 template<typename _Tp>
504 struct is_volatile<_Tp volatile>
505 : public true_type { };
506
507 /// is_trivial
508 template<typename _Tp>
509 struct is_trivial
510 : public integral_constant<bool, __is_trivial(_Tp)>
511 { };
512
513 // is_trivially_copyable (still unimplemented)
514
515 /// is_standard_layout
516 template<typename _Tp>
517 struct is_standard_layout
518 : public integral_constant<bool, __is_standard_layout(_Tp)>
519 { };
520
521 /// is_pod
522 // Could use is_standard_layout && is_trivial instead of the builtin.
523 template<typename _Tp>
524 struct is_pod
525 : public integral_constant<bool, __is_pod(_Tp)>
526 { };
527
528 /// is_literal_type
529 template<typename _Tp>
530 struct is_literal_type
531 : public integral_constant<bool, __is_literal_type(_Tp)>
532 { };
533
534 /// is_empty
535 template<typename _Tp>
536 struct is_empty
537 : public integral_constant<bool, __is_empty(_Tp)>
538 { };
539
540 /// is_polymorphic
541 template<typename _Tp>
542 struct is_polymorphic
543 : public integral_constant<bool, __is_polymorphic(_Tp)>
544 { };
545
546 /// is_abstract
547 template<typename _Tp>
548 struct is_abstract
549 : public integral_constant<bool, __is_abstract(_Tp)>
550 { };
551
552 template<typename _Tp,
553 bool = is_integral<_Tp>::value,
554 bool = is_floating_point<_Tp>::value>
555 struct __is_signed_helper
556 : public false_type { };
557
558 template<typename _Tp>
559 struct __is_signed_helper<_Tp, false, true>
560 : public true_type { };
561
562 template<typename _Tp>
563 struct __is_signed_helper<_Tp, true, false>
564 : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))>
565 { };
566
567 /// is_signed
568 template<typename _Tp>
569 struct is_signed
570 : public integral_constant<bool, __is_signed_helper<_Tp>::value>
571 { };
572
573 /// is_unsigned
574 template<typename _Tp>
575 struct is_unsigned
576 : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
577 { };
578
579
580 // Destructible and constructible type properties.
581
582 template<typename>
583 struct add_rvalue_reference;
584
585 /**
586 * @brief Utility to simplify expressions used in unevaluated operands
587 * @ingroup utilities
588 */
589 template<typename _Tp>
590 typename add_rvalue_reference<_Tp>::type declval() noexcept;
591
592 template<typename, unsigned = 0>
593 struct extent;
594
595 template<typename>
596 struct remove_all_extents;
597
598 template<typename _Tp>
599 struct __is_array_known_bounds
600 : public integral_constant<bool, (extent<_Tp>::value > 0)>
601 { };
602
603 template<typename _Tp>
604 struct __is_array_unknown_bounds
605 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
606 { };
607
608 // In N3290 is_destructible does not say anything about function
609 // types and abstract types, see LWG 2049. This implementation
610 // describes function types as non-destructible and all complete
611 // object types as destructible, iff the explicit destructor
612 // call expression is wellformed.
613 struct __do_is_destructible_impl
614 {
615 template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
616 static true_type __test(int);
617
618 template<typename>
619 static false_type __test(...);
620 };
621
622 template<typename _Tp>
623 struct __is_destructible_impl
624 : public __do_is_destructible_impl
625 {
626 typedef decltype(__test<_Tp>(0)) type;
627 };
628
629 template<typename _Tp,
630 bool = __or_<is_void<_Tp>,
631 __is_array_unknown_bounds<_Tp>,
632 is_function<_Tp>>::value,
633 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
634 struct __is_destructible_safe;
635
636 template<typename _Tp>
637 struct __is_destructible_safe<_Tp, false, false>
638 : public __is_destructible_impl<typename
639 remove_all_extents<_Tp>::type>::type
640 { };
641
642 template<typename _Tp>
643 struct __is_destructible_safe<_Tp, true, false>
644 : public false_type { };
645
646 template<typename _Tp>
647 struct __is_destructible_safe<_Tp, false, true>
648 : public true_type { };
649
650 /// is_destructible
651 template<typename _Tp>
652 struct is_destructible
653 : public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
654 { };
655
656 // is_nothrow_destructible requires that is_destructible is
657 // satisfied as well. We realize that by mimicing the
658 // implementation of is_destructible but refer to noexcept(expr)
659 // instead of decltype(expr).
660 struct __do_is_nt_destructible_impl
661 {
662 template<typename _Tp>
663 static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
664 __test(int);
665
666 template<typename>
667 static false_type __test(...);
668 };
669
670 template<typename _Tp>
671 struct __is_nt_destructible_impl
672 : public __do_is_nt_destructible_impl
673 {
674 typedef decltype(__test<_Tp>(0)) type;
675 };
676
677 template<typename _Tp,
678 bool = __or_<is_void<_Tp>,
679 __is_array_unknown_bounds<_Tp>,
680 is_function<_Tp>>::value,
681 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
682 struct __is_nt_destructible_safe;
683
684 template<typename _Tp>
685 struct __is_nt_destructible_safe<_Tp, false, false>
686 : public __is_nt_destructible_impl<typename
687 remove_all_extents<_Tp>::type>::type
688 { };
689
690 template<typename _Tp>
691 struct __is_nt_destructible_safe<_Tp, true, false>
692 : public false_type { };
693
694 template<typename _Tp>
695 struct __is_nt_destructible_safe<_Tp, false, true>
696 : public true_type { };
697
698 /// is_nothrow_destructible
699 template<typename _Tp>
700 struct is_nothrow_destructible
701 : public integral_constant<bool, (__is_nt_destructible_safe<_Tp>::value)>
702 { };
703
704 struct __do_is_default_constructible_impl
705 {
706 template<typename _Tp, typename = decltype(_Tp())>
707 static true_type __test(int);
708
709 template<typename>
710 static false_type __test(...);
711 };
712
713 template<typename _Tp>
714 struct __is_default_constructible_impl
715 : public __do_is_default_constructible_impl
716 {
717 typedef decltype(__test<_Tp>(0)) type;
718 };
719
720 template<typename _Tp>
721 struct __is_default_constructible_atom
722 : public __and_<__not_<is_void<_Tp>>,
723 __is_default_constructible_impl<_Tp>>::type
724 { };
725
726 template<typename _Tp, bool = is_array<_Tp>::value>
727 struct __is_default_constructible_safe;
728
729 // The following technique is a workaround for a current core language
730 // restriction, which does not allow for array types to occur in
731 // functional casts of the form T(). Complete arrays can be default-
732 // constructed, if the element type is default-constructible, but
733 // arrays with unknown bounds are not.
734 template<typename _Tp>
735 struct __is_default_constructible_safe<_Tp, true>
736 : public __and_<__is_array_known_bounds<_Tp>,
737 __is_default_constructible_atom<typename
738 remove_all_extents<_Tp>::type>>::type
739 { };
740
741 template<typename _Tp>
742 struct __is_default_constructible_safe<_Tp, false>
743 : public __is_default_constructible_atom<_Tp>::type
744 { };
745
746 /// is_default_constructible
747 template<typename _Tp>
748 struct is_default_constructible
749 : public integral_constant<bool, (__is_default_constructible_safe<
750 _Tp>::value)>
751 { };
752
753
754 // Implementation of is_constructible.
755
756 // The hardest part of this trait is the binary direct-initialization
757 // case, because we hit into a functional cast of the form T(arg).
758 // This implementation uses different strategies depending on the
759 // target type to reduce the test overhead as much as possible:
760 //
761 // a) For a reference target type, we use a static_cast expression
762 // modulo its extra cases.
763 //
764 // b) For a non-reference target type we use a ::new expression.
765 struct __do_is_static_castable_impl
766 {
767 template<typename _From, typename _To, typename
768 = decltype(static_cast<_To>(declval<_From>()))>
769 static true_type __test(int);
770
771 template<typename, typename>
772 static false_type __test(...);
773 };
774
775 template<typename _From, typename _To>
776 struct __is_static_castable_impl
777 : public __do_is_static_castable_impl
778 {
779 typedef decltype(__test<_From, _To>(0)) type;
780 };
781
782 template<typename _From, typename _To>
783 struct __is_static_castable_safe
784 : public __is_static_castable_impl<_From, _To>::type
785 { };
786
787 // __is_static_castable
788 template<typename _From, typename _To>
789 struct __is_static_castable
790 : public integral_constant<bool, (__is_static_castable_safe<
791 _From, _To>::value)>
792 { };
793
794 // Implementation for non-reference types. To meet the proper
795 // variable definition semantics, we also need to test for
796 // is_destructible in this case.
797 // This form should be simplified by a single expression:
798 // ::delete ::new _Tp(declval<_Arg>()), see c++/51222.
799 struct __do_is_direct_constructible_impl
800 {
801 template<typename _Tp, typename _Arg, typename
802 = decltype(::new _Tp(declval<_Arg>()))>
803 static true_type __test(int);
804
805 template<typename, typename>
806 static false_type __test(...);
807 };
808
809 template<typename _Tp, typename _Arg>
810 struct __is_direct_constructible_impl
811 : public __do_is_direct_constructible_impl
812 {
813 typedef decltype(__test<_Tp, _Arg>(0)) type;
814 };
815
816 template<typename _Tp, typename _Arg>
817 struct __is_direct_constructible_new_safe
818 : public __and_<is_destructible<_Tp>,
819 __is_direct_constructible_impl<_Tp, _Arg>>::type
820 { };
821
822 template<typename, typename>
823 struct is_same;
824
825 template<typename, typename>
826 struct is_base_of;
827
828 template<typename>
829 struct remove_reference;
830
831 template<typename _From, typename _To, bool
832 = __not_<__or_<is_void<_From>,
833 is_function<_From>>>::value>
834 struct __is_base_to_derived_ref;
835
836 // Detect whether we have a downcast situation during
837 // reference binding.
838 template<typename _From, typename _To>
839 struct __is_base_to_derived_ref<_From, _To, true>
840 {
841 typedef typename remove_cv<typename remove_reference<_From
842 >::type>::type __src_t;
843 typedef typename remove_cv<typename remove_reference<_To
844 >::type>::type __dst_t;
845 typedef __and_<__not_<is_same<__src_t, __dst_t>>,
846 is_base_of<__src_t, __dst_t>> type;
847 static constexpr bool value = type::value;
848 };
849
850 template<typename _From, typename _To>
851 struct __is_base_to_derived_ref<_From, _To, false>
852 : public false_type
853 { };
854
855 template<typename _From, typename _To, bool
856 = __and_<is_lvalue_reference<_From>,
857 is_rvalue_reference<_To>>::value>
858 struct __is_lvalue_to_rvalue_ref;
859
860 // Detect whether we have an lvalue of non-function type
861 // bound to a reference-compatible rvalue-reference.
862 template<typename _From, typename _To>
863 struct __is_lvalue_to_rvalue_ref<_From, _To, true>
864 {
865 typedef typename remove_cv<typename remove_reference<
866 _From>::type>::type __src_t;
867 typedef typename remove_cv<typename remove_reference<
868 _To>::type>::type __dst_t;
869 typedef __and_<__not_<is_function<__src_t>>,
870 __or_<is_same<__src_t, __dst_t>,
871 is_base_of<__dst_t, __src_t>>> type;
872 static constexpr bool value = type::value;
873 };
874
875 template<typename _From, typename _To>
876 struct __is_lvalue_to_rvalue_ref<_From, _To, false>
877 : public false_type
878 { };
879
880 // Here we handle direct-initialization to a reference type as
881 // equivalent to a static_cast modulo overshooting conversions.
882 // These are restricted to the following conversions:
883 // a) A base class value to a derived class reference
884 // b) An lvalue to an rvalue-reference of reference-compatible
885 // types that are not functions
886 template<typename _Tp, typename _Arg>
887 struct __is_direct_constructible_ref_cast
888 : public __and_<__is_static_castable<_Arg, _Tp>,
889 __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
890 __is_lvalue_to_rvalue_ref<_Arg, _Tp>
891 >>>::type
892 { };
893
894 template<typename _Tp, typename _Arg>
895 struct __is_direct_constructible_new
896 : public conditional<is_reference<_Tp>::value,
897 __is_direct_constructible_ref_cast<_Tp, _Arg>,
898 __is_direct_constructible_new_safe<_Tp, _Arg>
899 >::type
900 { };
901
902 template<typename _Tp, typename _Arg>
903 struct __is_direct_constructible
904 : public integral_constant<bool, (__is_direct_constructible_new<
905 _Tp, _Arg>::value)>
906 { };
907
908 // Since default-construction and binary direct-initialization have
909 // been handled separately, the implementation of the remaining
910 // n-ary construction cases is rather straightforward. We can use
911 // here a functional cast, because array types are excluded anyway
912 // and this form is never interpreted as a C cast.
913 struct __do_is_nary_constructible_impl
914 {
915 template<typename _Tp, typename... _Args, typename
916 = decltype(_Tp(declval<_Args>()...))>
917 static true_type __test(int);
918
919 template<typename, typename...>
920 static false_type __test(...);
921 };
922
923 template<typename _Tp, typename... _Args>
924 struct __is_nary_constructible_impl
925 : public __do_is_nary_constructible_impl
926 {
927 typedef decltype(__test<_Tp, _Args...>(0)) type;
928 };
929
930 template<typename _Tp, typename... _Args>
931 struct __is_nary_constructible
932 : public __is_nary_constructible_impl<_Tp, _Args...>::type
933 {
934 static_assert(sizeof...(_Args) > 1,
935 "Only useful for > 1 arguments");
936 };
937
938 template<typename _Tp, typename... _Args>
939 struct __is_constructible_impl
940 : public __is_nary_constructible<_Tp, _Args...>
941 { };
942
943 template<typename _Tp, typename _Arg>
944 struct __is_constructible_impl<_Tp, _Arg>
945 : public __is_direct_constructible<_Tp, _Arg>
946 { };
947
948 template<typename _Tp>
949 struct __is_constructible_impl<_Tp>
950 : public is_default_constructible<_Tp>
951 { };
952
953 /// is_constructible
954 template<typename _Tp, typename... _Args>
955 struct is_constructible
956 : public integral_constant<bool, (__is_constructible_impl<_Tp,
957 _Args...>::value)>
958 { };
959
960 template<typename _Tp, bool = is_void<_Tp>::value>
961 struct __is_copy_constructible_impl;
962
963 template<typename _Tp>
964 struct __is_copy_constructible_impl<_Tp, true>
965 : public false_type { };
966
967 template<typename _Tp>
968 struct __is_copy_constructible_impl<_Tp, false>
969 : public is_constructible<_Tp, const _Tp&>
970 { };
971
972 /// is_copy_constructible
973 template<typename _Tp>
974 struct is_copy_constructible
975 : public __is_copy_constructible_impl<_Tp>
976 { };
977
978 template<typename _Tp, bool = is_void<_Tp>::value>
979 struct __is_move_constructible_impl;
980
981 template<typename _Tp>
982 struct __is_move_constructible_impl<_Tp, true>
983 : public false_type { };
984
985 template<typename _Tp>
986 struct __is_move_constructible_impl<_Tp, false>
987 : public is_constructible<_Tp, _Tp&&>
988 { };
989
990 /// is_move_constructible
991 template<typename _Tp>
992 struct is_move_constructible
993 : public __is_move_constructible_impl<_Tp>
994 { };
995
996 template<typename _Tp>
997 struct __is_nt_default_constructible_atom
998 : public integral_constant<bool, noexcept(_Tp())>
999 { };
1000
1001 template<typename _Tp, bool = is_array<_Tp>::value>
1002 struct __is_nt_default_constructible_impl;
1003
1004 template<typename _Tp>
1005 struct __is_nt_default_constructible_impl<_Tp, true>
1006 : public __and_<__is_array_known_bounds<_Tp>,
1007 __is_nt_default_constructible_atom<typename
1008 remove_all_extents<_Tp>::type>>::type
1009 { };
1010
1011 template<typename _Tp>
1012 struct __is_nt_default_constructible_impl<_Tp, false>
1013 : public __is_nt_default_constructible_atom<_Tp>
1014 { };
1015
1016 /// is_nothrow_default_constructible
1017 template<typename _Tp>
1018 struct is_nothrow_default_constructible
1019 : public __and_<is_default_constructible<_Tp>,
1020 __is_nt_default_constructible_impl<_Tp>>::type
1021 { };
1022
1023 template<typename _Tp, typename... _Args>
1024 struct __is_nt_constructible_impl
1025 : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
1026 { };
1027
1028 template<typename _Tp, typename _Arg>
1029 struct __is_nt_constructible_impl<_Tp, _Arg>
1030 : public integral_constant<bool,
1031 noexcept(static_cast<_Tp>(declval<_Arg>()))>
1032 { };
1033
1034 template<typename _Tp>
1035 struct __is_nt_constructible_impl<_Tp>
1036 : public is_nothrow_default_constructible<_Tp>
1037 { };
1038
1039 /// is_nothrow_constructible
1040 template<typename _Tp, typename... _Args>
1041 struct is_nothrow_constructible
1042 : public __and_<is_constructible<_Tp, _Args...>,
1043 __is_nt_constructible_impl<_Tp, _Args...>>::type
1044 { };
1045
1046 template<typename _Tp, bool = is_void<_Tp>::value>
1047 struct __is_nothrow_copy_constructible_impl;
1048
1049 template<typename _Tp>
1050 struct __is_nothrow_copy_constructible_impl<_Tp, true>
1051 : public false_type { };
1052
1053 template<typename _Tp>
1054 struct __is_nothrow_copy_constructible_impl<_Tp, false>
1055 : public is_nothrow_constructible<_Tp, const _Tp&>
1056 { };
1057
1058 /// is_nothrow_copy_constructible
1059 template<typename _Tp>
1060 struct is_nothrow_copy_constructible
1061 : public __is_nothrow_copy_constructible_impl<_Tp>
1062 { };
1063
1064 template<typename _Tp, bool = is_void<_Tp>::value>
1065 struct __is_nothrow_move_constructible_impl;
1066
1067 template<typename _Tp>
1068 struct __is_nothrow_move_constructible_impl<_Tp, true>
1069 : public false_type { };
1070
1071 template<typename _Tp>
1072 struct __is_nothrow_move_constructible_impl<_Tp, false>
1073 : public is_nothrow_constructible<_Tp, _Tp&&>
1074 { };
1075
1076 /// is_nothrow_move_constructible
1077 template<typename _Tp>
1078 struct is_nothrow_move_constructible
1079 : public __is_nothrow_move_constructible_impl<_Tp>
1080 { };
1081
1082 template<typename _Tp, typename _Up>
1083 class __is_assignable_helper
1084 : public __sfinae_types
1085 {
1086 template<typename _Tp1, typename _Up1>
1087 static decltype(declval<_Tp1>() = declval<_Up1>(), __one())
1088 __test(int);
1089
1090 template<typename, typename>
1091 static __two __test(...);
1092
1093 public:
1094 static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1;
1095 };
1096
1097 /// is_assignable
1098 template<typename _Tp, typename _Up>
1099 struct is_assignable
1100 : public integral_constant<bool,
1101 __is_assignable_helper<_Tp, _Up>::value>
1102 { };
1103
1104 template<typename _Tp, bool = is_void<_Tp>::value>
1105 struct __is_copy_assignable_impl;
1106
1107 template<typename _Tp>
1108 struct __is_copy_assignable_impl<_Tp, true>
1109 : public false_type { };
1110
1111 template<typename _Tp>
1112 struct __is_copy_assignable_impl<_Tp, false>
1113 : public is_assignable<_Tp&, const _Tp&>
1114 { };
1115
1116 /// is_copy_assignable
1117 template<typename _Tp>
1118 struct is_copy_assignable
1119 : public __is_copy_assignable_impl<_Tp>
1120 { };
1121
1122 template<typename _Tp, bool = is_void<_Tp>::value>
1123 struct __is_move_assignable_impl;
1124
1125 template<typename _Tp>
1126 struct __is_move_assignable_impl<_Tp, true>
1127 : public false_type { };
1128
1129 template<typename _Tp>
1130 struct __is_move_assignable_impl<_Tp, false>
1131 : public is_assignable<_Tp&, _Tp&&>
1132 { };
1133
1134 /// is_move_assignable
1135 template<typename _Tp>
1136 struct is_move_assignable
1137 : public __is_move_assignable_impl<_Tp>
1138 { };
1139
1140 template<typename _Tp, typename _Up>
1141 struct __is_nt_assignable_impl
1142 : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
1143 { };
1144
1145 /// is_nothrow_assignable
1146 template<typename _Tp, typename _Up>
1147 struct is_nothrow_assignable
1148 : public __and_<is_assignable<_Tp, _Up>,
1149 __is_nt_assignable_impl<_Tp, _Up>>::type
1150 { };
1151
1152 template<typename _Tp, bool = is_void<_Tp>::value>
1153 struct __is_nt_copy_assignable_impl;
1154
1155 template<typename _Tp>
1156 struct __is_nt_copy_assignable_impl<_Tp, true>
1157 : public false_type { };
1158
1159 template<typename _Tp>
1160 struct __is_nt_copy_assignable_impl<_Tp, false>
1161 : public is_nothrow_assignable<_Tp&, const _Tp&>
1162 { };
1163
1164 /// is_nothrow_copy_assignable
1165 template<typename _Tp>
1166 struct is_nothrow_copy_assignable
1167 : public __is_nt_copy_assignable_impl<_Tp>
1168 { };
1169
1170 template<typename _Tp, bool = is_void<_Tp>::value>
1171 struct __is_nt_move_assignable_impl;
1172
1173 template<typename _Tp>
1174 struct __is_nt_move_assignable_impl<_Tp, true>
1175 : public false_type { };
1176
1177 template<typename _Tp>
1178 struct __is_nt_move_assignable_impl<_Tp, false>
1179 : public is_nothrow_assignable<_Tp&, _Tp&&>
1180 { };
1181
1182 /// is_nothrow_move_assignable
1183 template<typename _Tp>
1184 struct is_nothrow_move_assignable
1185 : public __is_nt_move_assignable_impl<_Tp>
1186 { };
1187
1188 /// is_trivially_constructible (still unimplemented)
1189
1190 /// is_trivially_default_constructible (still unimplemented)
1191
1192 /// is_trivially_copy_constructible (still unimplemented)
1193
1194 /// is_trivially_move_constructible (still unimplemented)
1195
1196 /// is_trivially_assignable (still unimplemented)
1197
1198 /// is_trivially_copy_assignable (still unimplemented)
1199
1200 /// is_trivially_move_assignable (still unimplemented)
1201
1202 /// is_trivially_destructible
1203 template<typename _Tp>
1204 struct is_trivially_destructible
1205 : public __and_<is_destructible<_Tp>, integral_constant<bool,
1206 __has_trivial_destructor(_Tp)>>::type
1207 { };
1208
1209 /// has_trivial_default_constructor (temporary legacy)
1210 template<typename _Tp>
1211 struct has_trivial_default_constructor
1212 : public integral_constant<bool, __has_trivial_constructor(_Tp)>
1213 { };
1214
1215 /// has_trivial_copy_constructor (temporary legacy)
1216 template<typename _Tp>
1217 struct has_trivial_copy_constructor
1218 : public integral_constant<bool, __has_trivial_copy(_Tp)>
1219 { };
1220
1221 /// has_trivial_copy_assign (temporary legacy)
1222 template<typename _Tp>
1223 struct has_trivial_copy_assign
1224 : public integral_constant<bool, __has_trivial_assign(_Tp)>
1225 { };
1226
1227 /// has_virtual_destructor
1228 template<typename _Tp>
1229 struct has_virtual_destructor
1230 : public integral_constant<bool, __has_virtual_destructor(_Tp)>
1231 { };
1232
1233
1234 // type property queries.
1235
1236 /// alignment_of
1237 template<typename _Tp>
1238 struct alignment_of
1239 : public integral_constant<std::size_t, __alignof__(_Tp)> { };
1240
1241 /// rank
1242 template<typename>
1243 struct rank
1244 : public integral_constant<std::size_t, 0> { };
1245
1246 template<typename _Tp, std::size_t _Size>
1247 struct rank<_Tp[_Size]>
1248 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1249
1250 template<typename _Tp>
1251 struct rank<_Tp[]>
1252 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
1253
1254 /// extent
1255 template<typename, unsigned _Uint>
1256 struct extent
1257 : public integral_constant<std::size_t, 0> { };
1258
1259 template<typename _Tp, unsigned _Uint, std::size_t _Size>
1260 struct extent<_Tp[_Size], _Uint>
1261 : public integral_constant<std::size_t,
1262 _Uint == 0 ? _Size : extent<_Tp,
1263 _Uint - 1>::value>
1264 { };
1265
1266 template<typename _Tp, unsigned _Uint>
1267 struct extent<_Tp[], _Uint>
1268 : public integral_constant<std::size_t,
1269 _Uint == 0 ? 0 : extent<_Tp,
1270 _Uint - 1>::value>
1271 { };
1272
1273
1274 // Type relations.
1275
1276 /// is_same
1277 template<typename, typename>
1278 struct is_same
1279 : public false_type { };
1280
1281 template<typename _Tp>
1282 struct is_same<_Tp, _Tp>
1283 : public true_type { };
1284
1285 /// is_base_of
1286 template<typename _Base, typename _Derived>
1287 struct is_base_of
1288 : public integral_constant<bool, __is_base_of(_Base, _Derived)>
1289 { };
1290
1291 template<typename _From, typename _To,
1292 bool = __or_<is_void<_From>, is_function<_To>,
1293 is_array<_To>>::value>
1294 struct __is_convertible_helper
1295 { static constexpr bool value = is_void<_To>::value; };
1296
1297 template<typename _From, typename _To>
1298 class __is_convertible_helper<_From, _To, false>
1299 : public __sfinae_types
1300 {
1301 template<typename _To1>
1302 static void __test_aux(_To1);
1303
1304 template<typename _From1, typename _To1>
1305 static decltype(__test_aux<_To1>(std::declval<_From1>()), __one())
1306 __test(int);
1307
1308 template<typename, typename>
1309 static __two __test(...);
1310
1311 public:
1312 static constexpr bool value = sizeof(__test<_From, _To>(0)) == 1;
1313 };
1314
1315 /// is_convertible
1316 template<typename _From, typename _To>
1317 struct is_convertible
1318 : public integral_constant<bool,
1319 __is_convertible_helper<_From, _To>::value>
1320 { };
1321
1322
1323 // Const-volatile modifications.
1324
1325 /// remove_const
1326 template<typename _Tp>
1327 struct remove_const
1328 { typedef _Tp type; };
1329
1330 template<typename _Tp>
1331 struct remove_const<_Tp const>
1332 { typedef _Tp type; };
1333
1334 /// remove_volatile
1335 template<typename _Tp>
1336 struct remove_volatile
1337 { typedef _Tp type; };
1338
1339 template<typename _Tp>
1340 struct remove_volatile<_Tp volatile>
1341 { typedef _Tp type; };
1342
1343 /// remove_cv
1344 template<typename _Tp>
1345 struct remove_cv
1346 {
1347 typedef typename
1348 remove_const<typename remove_volatile<_Tp>::type>::type type;
1349 };
1350
1351 /// add_const
1352 template<typename _Tp>
1353 struct add_const
1354 { typedef _Tp const type; };
1355
1356 /// add_volatile
1357 template<typename _Tp>
1358 struct add_volatile
1359 { typedef _Tp volatile type; };
1360
1361 /// add_cv
1362 template<typename _Tp>
1363 struct add_cv
1364 {
1365 typedef typename
1366 add_const<typename add_volatile<_Tp>::type>::type type;
1367 };
1368
1369
1370 // Reference transformations.
1371
1372 /// remove_reference
1373 template<typename _Tp>
1374 struct remove_reference
1375 { typedef _Tp type; };
1376
1377 template<typename _Tp>
1378 struct remove_reference<_Tp&>
1379 { typedef _Tp type; };
1380
1381 template<typename _Tp>
1382 struct remove_reference<_Tp&&>
1383 { typedef _Tp type; };
1384
1385 template<typename _Tp,
1386 bool = __and_<__not_<is_reference<_Tp>>,
1387 __not_<is_void<_Tp>>>::value,
1388 bool = is_rvalue_reference<_Tp>::value>
1389 struct __add_lvalue_reference_helper
1390 { typedef _Tp type; };
1391
1392 template<typename _Tp>
1393 struct __add_lvalue_reference_helper<_Tp, true, false>
1394 { typedef _Tp& type; };
1395
1396 template<typename _Tp>
1397 struct __add_lvalue_reference_helper<_Tp, false, true>
1398 { typedef typename remove_reference<_Tp>::type& type; };
1399
1400 /// add_lvalue_reference
1401 template<typename _Tp>
1402 struct add_lvalue_reference
1403 : public __add_lvalue_reference_helper<_Tp>
1404 { };
1405
1406 template<typename _Tp,
1407 bool = __and_<__not_<is_reference<_Tp>>,
1408 __not_<is_void<_Tp>>>::value>
1409 struct __add_rvalue_reference_helper
1410 { typedef _Tp type; };
1411
1412 template<typename _Tp>
1413 struct __add_rvalue_reference_helper<_Tp, true>
1414 { typedef _Tp&& type; };
1415
1416 /// add_rvalue_reference
1417 template<typename _Tp>
1418 struct add_rvalue_reference
1419 : public __add_rvalue_reference_helper<_Tp>
1420 { };
1421
1422
1423 // Sign modifications.
1424
1425 // Utility for constructing identically cv-qualified types.
1426 template<typename _Unqualified, bool _IsConst, bool _IsVol>
1427 struct __cv_selector;
1428
1429 template<typename _Unqualified>
1430 struct __cv_selector<_Unqualified, false, false>
1431 { typedef _Unqualified __type; };
1432
1433 template<typename _Unqualified>
1434 struct __cv_selector<_Unqualified, false, true>
1435 { typedef volatile _Unqualified __type; };
1436
1437 template<typename _Unqualified>
1438 struct __cv_selector<_Unqualified, true, false>
1439 { typedef const _Unqualified __type; };
1440
1441 template<typename _Unqualified>
1442 struct __cv_selector<_Unqualified, true, true>
1443 { typedef const volatile _Unqualified __type; };
1444
1445 template<typename _Qualified, typename _Unqualified,
1446 bool _IsConst = is_const<_Qualified>::value,
1447 bool _IsVol = is_volatile<_Qualified>::value>
1448 class __match_cv_qualifiers
1449 {
1450 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
1451
1452 public:
1453 typedef typename __match::__type __type;
1454 };
1455
1456 // Utility for finding the unsigned versions of signed integral types.
1457 template<typename _Tp>
1458 struct __make_unsigned
1459 { typedef _Tp __type; };
1460
1461 template<>
1462 struct __make_unsigned<char>
1463 { typedef unsigned char __type; };
1464
1465 template<>
1466 struct __make_unsigned<signed char>
1467 { typedef unsigned char __type; };
1468
1469 template<>
1470 struct __make_unsigned<short>
1471 { typedef unsigned short __type; };
1472
1473 template<>
1474 struct __make_unsigned<int>
1475 { typedef unsigned int __type; };
1476
1477 template<>
1478 struct __make_unsigned<long>
1479 { typedef unsigned long __type; };
1480
1481 template<>
1482 struct __make_unsigned<long long>
1483 { typedef unsigned long long __type; };
1484
1485 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
1486 template<>
1487 struct __make_unsigned<__int128>
1488 { typedef unsigned __int128 __type; };
1489 #endif
1490
1491 // Select between integral and enum: not possible to be both.
1492 template<typename _Tp,
1493 bool _IsInt = is_integral<_Tp>::value,
1494 bool _IsEnum = is_enum<_Tp>::value>
1495 class __make_unsigned_selector;
1496
1497 template<typename _Tp>
1498 class __make_unsigned_selector<_Tp, true, false>
1499 {
1500 typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
1501 typedef typename __unsignedt::__type __unsigned_type;
1502 typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
1503
1504 public:
1505 typedef typename __cv_unsigned::__type __type;
1506 };
1507
1508 template<typename _Tp>
1509 class __make_unsigned_selector<_Tp, false, true>
1510 {
1511 // With -fshort-enums, an enum may be as small as a char.
1512 typedef unsigned char __smallest;
1513 static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
1514 static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
1515 static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
1516 typedef conditional<__b2, unsigned int, unsigned long> __cond2;
1517 typedef typename __cond2::type __cond2_type;
1518 typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
1519 typedef typename __cond1::type __cond1_type;
1520
1521 public:
1522 typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
1523 };
1524
1525 // Given an integral/enum type, return the corresponding unsigned
1526 // integer type.
1527 // Primary template.
1528 /// make_unsigned
1529 template<typename _Tp>
1530 struct make_unsigned
1531 { typedef typename __make_unsigned_selector<_Tp>::__type type; };
1532
1533 // Integral, but don't define.
1534 template<>
1535 struct make_unsigned<bool>;
1536
1537
1538 // Utility for finding the signed versions of unsigned integral types.
1539 template<typename _Tp>
1540 struct __make_signed
1541 { typedef _Tp __type; };
1542
1543 template<>
1544 struct __make_signed<char>
1545 { typedef signed char __type; };
1546
1547 template<>
1548 struct __make_signed<unsigned char>
1549 { typedef signed char __type; };
1550
1551 template<>
1552 struct __make_signed<unsigned short>
1553 { typedef signed short __type; };
1554
1555 template<>
1556 struct __make_signed<unsigned int>
1557 { typedef signed int __type; };
1558
1559 template<>
1560 struct __make_signed<unsigned long>
1561 { typedef signed long __type; };
1562
1563 template<>
1564 struct __make_signed<unsigned long long>
1565 { typedef signed long long __type; };
1566
1567 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_INT128)
1568 template<>
1569 struct __make_signed<unsigned __int128>
1570 { typedef __int128 __type; };
1571 #endif
1572
1573 // Select between integral and enum: not possible to be both.
1574 template<typename _Tp,
1575 bool _IsInt = is_integral<_Tp>::value,
1576 bool _IsEnum = is_enum<_Tp>::value>
1577 class __make_signed_selector;
1578
1579 template<typename _Tp>
1580 class __make_signed_selector<_Tp, true, false>
1581 {
1582 typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
1583 typedef typename __signedt::__type __signed_type;
1584 typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
1585
1586 public:
1587 typedef typename __cv_signed::__type __type;
1588 };
1589
1590 template<typename _Tp>
1591 class __make_signed_selector<_Tp, false, true>
1592 {
1593 // With -fshort-enums, an enum may be as small as a char.
1594 typedef signed char __smallest;
1595 static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
1596 static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
1597 static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
1598 typedef conditional<__b2, signed int, signed long> __cond2;
1599 typedef typename __cond2::type __cond2_type;
1600 typedef conditional<__b1, signed short, __cond2_type> __cond1;
1601 typedef typename __cond1::type __cond1_type;
1602
1603 public:
1604 typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
1605 };
1606
1607 // Given an integral/enum type, return the corresponding signed
1608 // integer type.
1609 // Primary template.
1610 /// make_signed
1611 template<typename _Tp>
1612 struct make_signed
1613 { typedef typename __make_signed_selector<_Tp>::__type type; };
1614
1615 // Integral, but don't define.
1616 template<>
1617 struct make_signed<bool>;
1618
1619
1620 // Array modifications.
1621
1622 /// remove_extent
1623 template<typename _Tp>
1624 struct remove_extent
1625 { typedef _Tp type; };
1626
1627 template<typename _Tp, std::size_t _Size>
1628 struct remove_extent<_Tp[_Size]>
1629 { typedef _Tp type; };
1630
1631 template<typename _Tp>
1632 struct remove_extent<_Tp[]>
1633 { typedef _Tp type; };
1634
1635 /// remove_all_extents
1636 template<typename _Tp>
1637 struct remove_all_extents
1638 { typedef _Tp type; };
1639
1640 template<typename _Tp, std::size_t _Size>
1641 struct remove_all_extents<_Tp[_Size]>
1642 { typedef typename remove_all_extents<_Tp>::type type; };
1643
1644 template<typename _Tp>
1645 struct remove_all_extents<_Tp[]>
1646 { typedef typename remove_all_extents<_Tp>::type type; };
1647
1648
1649 // Pointer modifications.
1650
1651 template<typename _Tp, typename>
1652 struct __remove_pointer_helper
1653 { typedef _Tp type; };
1654
1655 template<typename _Tp, typename _Up>
1656 struct __remove_pointer_helper<_Tp, _Up*>
1657 { typedef _Up type; };
1658
1659 /// remove_pointer
1660 template<typename _Tp>
1661 struct remove_pointer
1662 : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
1663 { };
1664
1665 /// add_pointer
1666 template<typename _Tp>
1667 struct add_pointer
1668 { typedef typename remove_reference<_Tp>::type* type; };
1669
1670
1671 template<std::size_t _Len>
1672 struct __aligned_storage_msa
1673 {
1674 union __type
1675 {
1676 unsigned char __data[_Len];
1677 struct __attribute__((__aligned__)) { } __align;
1678 };
1679 };
1680
1681 /**
1682 * @brief Alignment type.
1683 *
1684 * The value of _Align is a default-alignment which shall be the
1685 * most stringent alignment requirement for any C++ object type
1686 * whose size is no greater than _Len (3.9). The member typedef
1687 * type shall be a POD type suitable for use as uninitialized
1688 * storage for any object whose size is at most _Len and whose
1689 * alignment is a divisor of _Align.
1690 */
1691 template<std::size_t _Len, std::size_t _Align =
1692 __alignof__(typename __aligned_storage_msa<_Len>::__type)>
1693 struct aligned_storage
1694 {
1695 union type
1696 {
1697 unsigned char __data[_Len];
1698 struct __attribute__((__aligned__((_Align)))) { } __align;
1699 };
1700 };
1701
1702
1703 // Decay trait for arrays and functions, used for perfect forwarding
1704 // in make_pair, make_tuple, etc.
1705 template<typename _Up,
1706 bool _IsArray = is_array<_Up>::value,
1707 bool _IsFunction = is_function<_Up>::value>
1708 struct __decay_selector;
1709
1710 // NB: DR 705.
1711 template<typename _Up>
1712 struct __decay_selector<_Up, false, false>
1713 { typedef typename remove_cv<_Up>::type __type; };
1714
1715 template<typename _Up>
1716 struct __decay_selector<_Up, true, false>
1717 { typedef typename remove_extent<_Up>::type* __type; };
1718
1719 template<typename _Up>
1720 struct __decay_selector<_Up, false, true>
1721 { typedef typename add_pointer<_Up>::type __type; };
1722
1723 /// decay
1724 template<typename _Tp>
1725 class decay
1726 {
1727 typedef typename remove_reference<_Tp>::type __remove_type;
1728
1729 public:
1730 typedef typename __decay_selector<__remove_type>::__type type;
1731 };
1732
1733 template<typename _Tp>
1734 class reference_wrapper;
1735
1736 // Helper which adds a reference to a type when given a reference_wrapper
1737 template<typename _Tp>
1738 struct __strip_reference_wrapper
1739 {
1740 typedef _Tp __type;
1741 };
1742
1743 template<typename _Tp>
1744 struct __strip_reference_wrapper<reference_wrapper<_Tp> >
1745 {
1746 typedef _Tp& __type;
1747 };
1748
1749 template<typename _Tp>
1750 struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
1751 {
1752 typedef _Tp& __type;
1753 };
1754
1755 template<typename _Tp>
1756 struct __decay_and_strip
1757 {
1758 typedef typename __strip_reference_wrapper<
1759 typename decay<_Tp>::type>::__type __type;
1760 };
1761
1762
1763 // Primary template.
1764 /// Define a member typedef @c type only if a boolean constant is true.
1765 template<bool, typename _Tp = void>
1766 struct enable_if
1767 { };
1768
1769 // Partial specialization for true.
1770 template<typename _Tp>
1771 struct enable_if<true, _Tp>
1772 { typedef _Tp type; };
1773
1774 template<typename... _Cond>
1775 using _Require = typename enable_if<__and_<_Cond...>::value>::type;
1776
1777 // Primary template.
1778 /// Define a member typedef @c type to one of two argument types.
1779 template<bool _Cond, typename _Iftrue, typename _Iffalse>
1780 struct conditional
1781 { typedef _Iftrue type; };
1782
1783 // Partial specialization for false.
1784 template<typename _Iftrue, typename _Iffalse>
1785 struct conditional<false, _Iftrue, _Iffalse>
1786 { typedef _Iffalse type; };
1787
1788 /// common_type
1789 template<typename... _Tp>
1790 struct common_type;
1791
1792 // Sfinae-friendly common_type implementation:
1793
1794 struct __do_common_type_impl
1795 {
1796 template<typename _Tp, typename _Up>
1797 static __success_type<typename decay<decltype
1798 (true ? std::declval<_Tp>()
1799 : std::declval<_Up>())>::type> _S_test(int);
1800
1801 template<typename, typename>
1802 static __failure_type _S_test(...);
1803 };
1804
1805 template<typename _Tp, typename _Up>
1806 struct __common_type_impl
1807 : private __do_common_type_impl
1808 {
1809 typedef decltype(_S_test<_Tp, _Up>(0)) type;
1810 };
1811
1812 struct __do_member_type_wrapper
1813 {
1814 template<typename _Tp>
1815 static __success_type<typename _Tp::type> _S_test(int);
1816
1817 template<typename>
1818 static __failure_type _S_test(...);
1819 };
1820
1821 template<typename _Tp>
1822 struct __member_type_wrapper
1823 : private __do_member_type_wrapper
1824 {
1825 typedef decltype(_S_test<_Tp>(0)) type;
1826 };
1827
1828 template<typename _CTp, typename... _Args>
1829 struct __expanded_common_type_wrapper
1830 {
1831 typedef common_type<typename _CTp::type, _Args...> type;
1832 };
1833
1834 template<typename... _Args>
1835 struct __expanded_common_type_wrapper<__failure_type, _Args...>
1836 { typedef __failure_type type; };
1837
1838 template<typename _Tp>
1839 struct common_type<_Tp>
1840 { typedef typename decay<_Tp>::type type; };
1841
1842 template<typename _Tp, typename _Up>
1843 struct common_type<_Tp, _Up>
1844 : public __common_type_impl<_Tp, _Up>::type
1845 { };
1846
1847 template<typename _Tp, typename _Up, typename... _Vp>
1848 struct common_type<_Tp, _Up, _Vp...>
1849 : public __expanded_common_type_wrapper<typename __member_type_wrapper<
1850 common_type<_Tp, _Up>>::type, _Vp...>::type
1851 { };
1852
1853 /// The underlying type of an enum.
1854 template<typename _Tp>
1855 struct underlying_type
1856 {
1857 typedef __underlying_type(_Tp) type;
1858 };
1859
1860 template<typename _Tp>
1861 struct __declval_protector
1862 {
1863 static const bool __stop = false;
1864 static typename add_rvalue_reference<_Tp>::type __delegate();
1865 };
1866
1867 template<typename _Tp>
1868 inline typename add_rvalue_reference<_Tp>::type
1869 declval() noexcept
1870 {
1871 static_assert(__declval_protector<_Tp>::__stop,
1872 "declval() must not be used!");
1873 return __declval_protector<_Tp>::__delegate();
1874 }
1875
1876 /// result_of
1877 template<typename _Signature>
1878 class result_of;
1879
1880 // Sfinae-friendly result_of implementation:
1881
1882 // [func.require] paragraph 1 bullet 1:
1883 struct __result_of_memfun_ref_impl
1884 {
1885 template<typename _Fp, typename _Tp1, typename... _Args>
1886 static __success_type<decltype(
1887 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
1888 )> _S_test(int);
1889
1890 template<typename...>
1891 static __failure_type _S_test(...);
1892 };
1893
1894 template<typename _MemPtr, typename _Arg, typename... _Args>
1895 struct __result_of_memfun_ref
1896 : private __result_of_memfun_ref_impl
1897 {
1898 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
1899 };
1900
1901 // [func.require] paragraph 1 bullet 2:
1902 struct __result_of_memfun_deref_impl
1903 {
1904 template<typename _Fp, typename _Tp1, typename... _Args>
1905 static __success_type<decltype(
1906 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
1907 )> _S_test(int);
1908
1909 template<typename...>
1910 static __failure_type _S_test(...);
1911 };
1912
1913 template<typename _MemPtr, typename _Arg, typename... _Args>
1914 struct __result_of_memfun_deref
1915 : private __result_of_memfun_deref_impl
1916 {
1917 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
1918 };
1919
1920 // [func.require] paragraph 1 bullet 3:
1921 struct __result_of_memobj_ref_impl
1922 {
1923 template<typename _Fp, typename _Tp1>
1924 static __success_type<decltype(
1925 std::declval<_Tp1>().*std::declval<_Fp>()
1926 )> _S_test(int);
1927
1928 template<typename, typename>
1929 static __failure_type _S_test(...);
1930 };
1931
1932 template<typename _MemPtr, typename _Arg>
1933 struct __result_of_memobj_ref
1934 : private __result_of_memobj_ref_impl
1935 {
1936 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
1937 };
1938
1939 // [func.require] paragraph 1 bullet 4:
1940 struct __result_of_memobj_deref_impl
1941 {
1942 template<typename _Fp, typename _Tp1>
1943 static __success_type<decltype(
1944 (*std::declval<_Tp1>()).*std::declval<_Fp>()
1945 )> _S_test(int);
1946
1947 template<typename, typename>
1948 static __failure_type _S_test(...);
1949 };
1950
1951 template<typename _MemPtr, typename _Arg>
1952 struct __result_of_memobj_deref
1953 : private __result_of_memobj_deref_impl
1954 {
1955 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
1956 };
1957
1958 template<typename _MemPtr, typename _Arg>
1959 struct __result_of_memobj;
1960
1961 template<typename _Res, typename _Class, typename _Arg>
1962 struct __result_of_memobj<_Res _Class::*, _Arg>
1963 {
1964 typedef typename remove_cv<typename remove_reference<
1965 _Arg>::type>::type _Argval;
1966 typedef _Res _Class::* _MemPtr;
1967 typedef typename conditional<__or_<is_same<_Argval, _Class>,
1968 is_base_of<_Class, _Argval>>::value,
1969 __result_of_memobj_ref<_MemPtr, _Arg>,
1970 __result_of_memobj_deref<_MemPtr, _Arg>
1971 >::type::type type;
1972 };
1973
1974 template<typename _MemPtr, typename _Arg, typename... _Args>
1975 struct __result_of_memfun;
1976
1977 template<typename _Res, typename _Class, typename _Arg, typename... _Args>
1978 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
1979 {
1980 typedef typename remove_cv<typename remove_reference<
1981 _Arg>::type>::type _Argval;
1982 typedef _Res _Class::* _MemPtr;
1983 typedef typename conditional<__or_<is_same<_Argval, _Class>,
1984 is_base_of<_Class, _Argval>>::value,
1985 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
1986 __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
1987 >::type::type type;
1988 };
1989
1990 template<bool, bool, typename _Functor, typename... _ArgTypes>
1991 struct __result_of_impl
1992 {
1993 typedef __failure_type type;
1994 };
1995
1996 template<typename _MemPtr, typename _Arg>
1997 struct __result_of_impl<true, false, _MemPtr, _Arg>
1998 : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
1999 { };
2000
2001 template<typename _MemPtr, typename _Arg, typename... _Args>
2002 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
2003 : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
2004 { };
2005
2006 // [func.require] paragraph 1 bullet 5:
2007 struct __result_of_other_impl
2008 {
2009 template<typename _Fn, typename... _Args>
2010 static __success_type<decltype(
2011 std::declval<_Fn>()(std::declval<_Args>()...)
2012 )> _S_test(int);
2013
2014 template<typename...>
2015 static __failure_type _S_test(...);
2016 };
2017
2018 template<typename _Functor, typename... _ArgTypes>
2019 struct __result_of_impl<false, false, _Functor, _ArgTypes...>
2020 : private __result_of_other_impl
2021 {
2022 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
2023 };
2024
2025 template<typename _Functor, typename... _ArgTypes>
2026 struct result_of<_Functor(_ArgTypes...)>
2027 : public __result_of_impl<
2028 is_member_object_pointer<
2029 typename remove_reference<_Functor>::type
2030 >::value,
2031 is_member_function_pointer<
2032 typename remove_reference<_Functor>::type
2033 >::value,
2034 _Functor, _ArgTypes...
2035 >::type
2036 { };
2037
2038 /// @} group metaprogramming
2039
2040 /**
2041 * Use SFINAE to determine if the type _Tp has a publicly-accessible
2042 * member type _NTYPE.
2043 */
2044 #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \
2045 template<typename _Tp> \
2046 class __has_##_NTYPE##_helper \
2047 : __sfinae_types \
2048 { \
2049 template<typename _Up> \
2050 struct _Wrap_type \
2051 { }; \
2052 \
2053 template<typename _Up> \
2054 static __one __test(_Wrap_type<typename _Up::_NTYPE>*); \
2055 \
2056 template<typename _Up> \
2057 static __two __test(...); \
2058 \
2059 public: \
2060 static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; \
2061 }; \
2062 \
2063 template<typename _Tp> \
2064 struct __has_##_NTYPE \
2065 : integral_constant<bool, __has_##_NTYPE##_helper \
2066 <typename remove_cv<_Tp>::type>::value> \
2067 { };
2068
2069 _GLIBCXX_END_NAMESPACE_VERSION
2070 } // namespace std
2071
2072 #endif // C++11
2073
2074 #endif // _GLIBCXX_TYPE_TRAITS