libstdc++-v3/include/std/type_traits

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