i686-linux-gnu-4.7/usr/include/c++/4.7/type_traits

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