OSDN Git Service

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