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