libstdc++-v3/include/std/type_traits

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