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