Where Online Learning is simpler!
The C and C++ Include Header Files
/usr/include/c++/13/type_traits
$ cat -n /usr/include/c++/13/type_traits 1 // C++11 <type_traits> -*- C++ -*- 2 3 // Copyright (C) 2007-2023 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 template<typename _Tp> 45 class reference_wrapper; 46 47 /** 48 * @defgroup metaprogramming Metaprogramming 49 * @ingroup utilities 50 * 51 * Template utilities for compile-time introspection and modification, 52 * including type classification traits, type property inspection traits 53 * and type transformation traits. 54 * 55 * @since C++11 56 * 57 * @{ 58 */ 59 60 /// integral_constant 61 template<typename _Tp, _Tp __v> 62 struct integral_constant 63 { 64 static constexpr _Tp value = __v; 65 typedef _Tp value_type; 66 typedef integral_constant<_Tp, __v> type; 67 constexpr operator value_type() const noexcept { return value; } 68 #if __cplusplus > 201103L 69 70 #define __cpp_lib_integral_constant_callable 201304L 71 72 constexpr value_type operator()() const noexcept { return value; } 73 #endif 74 }; 75 76 #if ! __cpp_inline_variables 77 template<typename _Tp, _Tp __v> 78 constexpr _Tp integral_constant<_Tp, __v>::value; 79 #endif 80 81 /// The type used as a compile-time boolean with true value. 82 using true_type = integral_constant<bool, true>; 83 84 /// The type used as a compile-time boolean with false value. 85 using false_type = integral_constant<bool, false>; 86 87 /// @cond undocumented 88 /// bool_constant for C++11 89 template<bool __v> 90 using __bool_constant = integral_constant<bool, __v>; 91 /// @endcond 92 93 #if __cplusplus >= 201703L 94 # define __cpp_lib_bool_constant 201505L 95 /// Alias template for compile-time boolean constant types. 96 /// @since C++17 97 template<bool __v> 98 using bool_constant = integral_constant<bool, __v>; 99 #endif 100 101 // Metaprogramming helper types. 102 103 // Primary template. 104 /// Define a member typedef `type` only if a boolean constant is true. 105 template<bool, typename _Tp = void> 106 struct enable_if 107 { }; 108 109 // Partial specialization for true. 110 template<typename _Tp> 111 struct enable_if<true, _Tp> 112 { typedef _Tp type; }; 113 114 // __enable_if_t (std::enable_if_t for C++11) 115 template<bool _Cond, typename _Tp = void> 116 using __enable_if_t = typename enable_if<_Cond, _Tp>::type; 117 118 template<bool> 119 struct __conditional 120 { 121 template<typename _Tp, typename> 122 using type = _Tp; 123 }; 124 125 template<> 126 struct __conditional<false> 127 { 128 template<typename, typename _Up> 129 using type = _Up; 130 }; 131 132 // More efficient version of std::conditional_t for internal use (and C++11) 133 template<bool _Cond, typename _If, typename _Else> 134 using __conditional_t 135 = typename __conditional<_Cond>::template type<_If, _Else>; 136 137 /// @cond undocumented 138 template <typename _Type> 139 struct __type_identity 140 { using type = _Type; }; 141 142 template<typename _Tp> 143 using __type_identity_t = typename __type_identity<_Tp>::type; 144 145 namespace __detail 146 { 147 // A variadic alias template that resolves to its first argument. 148 template<typename _Tp, typename...> 149 using __first_t = _Tp; 150 151 // These are deliberately not defined. 152 template<typename... _Bn> 153 auto __or_fn(int) -> __first_t<false_type, 154 __enable_if_t<!bool(_Bn::value)>...>; 155 156 template<typename... _Bn> 157 auto __or_fn(...) -> true_type; 158 159 template<typename... _Bn> 160 auto __and_fn(int) -> __first_t<true_type, 161 __enable_if_t<bool(_Bn::value)>...>; 162 163 template<typename... _Bn> 164 auto __and_fn(...) -> false_type; 165 } // namespace detail 166 167 // Like C++17 std::dis/conjunction, but usable in C++11 and resolves 168 // to either true_type or false_type which allows for a more efficient 169 // implementation that avoids recursive class template instantiation. 170 template<typename... _Bn> 171 struct __or_ 172 : decltype(__detail::__or_fn<_Bn...>(0)) 173 { }; 174 175 template<typename... _Bn> 176 struct __and_ 177 : decltype(__detail::__and_fn<_Bn...>(0)) 178 { }; 179 180 template<typename _Pp> 181 struct __not_ 182 : __bool_constant<!bool(_Pp::value)> 183 { }; 184 /// @endcond 185 186 #if __cplusplus >= 201703L 187 188 /// @cond undocumented 189 template<typename... _Bn> 190 inline constexpr bool __or_v = __or_<_Bn...>::value; 191 template<typename... _Bn> 192 inline constexpr bool __and_v = __and_<_Bn...>::value; 193 194 namespace __detail 195 { 196 template<typename /* = void */, typename _B1, typename... _Bn> 197 struct __disjunction_impl 198 { using type = _B1; }; 199 200 template<typename _B1, typename _B2, typename... _Bn> 201 struct __disjunction_impl<__enable_if_t<!bool(_B1::value)>, _B1, _B2, _Bn...> 202 { using type = typename __disjunction_impl<void, _B2, _Bn...>::type; }; 203 204 template<typename /* = void */, typename _B1, typename... _Bn> 205 struct __conjunction_impl 206 { using type = _B1; }; 207 208 template<typename _B1, typename _B2, typename... _Bn> 209 struct __conjunction_impl<__enable_if_t<bool(_B1::value)>, _B1, _B2, _Bn...> 210 { using type = typename __conjunction_impl<void, _B2, _Bn...>::type; }; 211 } // namespace __detail 212 /// @endcond 213 214 #define __cpp_lib_logical_traits 201510L 215 216 template<typename... _Bn> 217 struct conjunction 218 : __detail::__conjunction_impl<void, _Bn...>::type 219 { }; 220 221 template<> 222 struct conjunction<> 223 : true_type 224 { }; 225 226 template<typename... _Bn> 227 struct disjunction 228 : __detail::__disjunction_impl<void, _Bn...>::type 229 { }; 230 231 template<> 232 struct disjunction<> 233 : false_type 234 { }; 235 236 template<typename _Pp> 237 struct negation 238 : __not_<_Pp>::type 239 { }; 240 241 /** @ingroup variable_templates 242 * @{ 243 */ 244 template<typename... _Bn> 245 inline constexpr bool conjunction_v = conjunction<_Bn...>::value; 246 247 template<typename... _Bn> 248 inline constexpr bool disjunction_v = disjunction<_Bn...>::value; 249 250 template<typename _Pp> 251 inline constexpr bool negation_v = negation<_Pp>::value; 252 /// @} 253 254 #endif // C++17 255 256 // Forward declarations 257 template<typename> 258 struct is_reference; 259 template<typename> 260 struct is_function; 261 template<typename> 262 struct is_void; 263 template<typename> 264 struct remove_cv; 265 template<typename> 266 struct is_const; 267 268 /// @cond undocumented 269 template<typename> 270 struct __is_array_unknown_bounds; 271 272 // Helper functions that return false_type for incomplete classes, 273 // incomplete unions and arrays of known bound from those. 274 275 template <typename _Tp, size_t = sizeof(_Tp)> 276 constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) 277 { return {}; } 278 279 template <typename _TypeIdentity, 280 typename _NestedType = typename _TypeIdentity::type> 281 constexpr typename __or_< 282 is_reference<_NestedType>, 283 is_function<_NestedType>, 284 is_void<_NestedType>, 285 __is_array_unknown_bounds<_NestedType> 286 >::type __is_complete_or_unbounded(_TypeIdentity) 287 { return {}; } 288 289 // __remove_cv_t (std::remove_cv_t for C++11). 290 template<typename _Tp> 291 using __remove_cv_t = typename remove_cv<_Tp>::type; 292 /// @endcond 293 294 // Primary type categories. 295 296 /// is_void 297 template<typename _Tp> 298 struct is_void 299 : public false_type { }; 300 301 template<> 302 struct is_void<void> 303 : public true_type { }; 304 305 template<> 306 struct is_void<const void> 307 : public true_type { }; 308 309 template<> 310 struct is_void<volatile void> 311 : public true_type { }; 312 313 template<> 314 struct is_void<const volatile void> 315 : public true_type { }; 316 317 /// @cond undocumented 318 template<typename> 319 struct __is_integral_helper 320 : public false_type { }; 321 322 template<> 323 struct __is_integral_helper<bool> 324 : public true_type { }; 325 326 template<> 327 struct __is_integral_helper<char> 328 : public true_type { }; 329 330 template<> 331 struct __is_integral_helper<signed char> 332 : public true_type { }; 333 334 template<> 335 struct __is_integral_helper<unsigned char> 336 : public true_type { }; 337 338 // We want is_integral<wchar_t> to be true (and make_signed/unsigned to work) 339 // even when libc doesn't provide working <wchar.h> and related functions, 340 // so don't check _GLIBCXX_USE_WCHAR_T here. 341 template<> 342 struct __is_integral_helper<wchar_t> 343 : public true_type { }; 344 345 #ifdef _GLIBCXX_USE_CHAR8_T 346 template<> 347 struct __is_integral_helper<char8_t> 348 : public true_type { }; 349 #endif 350 351 template<> 352 struct __is_integral_helper<char16_t> 353 : public true_type { }; 354 355 template<> 356 struct __is_integral_helper<char32_t> 357 : public true_type { }; 358 359 template<> 360 struct __is_integral_helper<short> 361 : public true_type { }; 362 363 template<> 364 struct __is_integral_helper<unsigned short> 365 : public true_type { }; 366 367 template<> 368 struct __is_integral_helper<int> 369 : public true_type { }; 370 371 template<> 372 struct __is_integral_helper<unsigned int> 373 : public true_type { }; 374 375 template<> 376 struct __is_integral_helper<long> 377 : public true_type { }; 378 379 template<> 380 struct __is_integral_helper<unsigned long> 381 : public true_type { }; 382 383 template<> 384 struct __is_integral_helper<long long> 385 : public true_type { }; 386 387 template<> 388 struct __is_integral_helper<unsigned long long> 389 : public true_type { }; 390 391 // Conditionalizing on __STRICT_ANSI__ here will break any port that 392 // uses one of these types for size_t. 393 #if defined(__GLIBCXX_TYPE_INT_N_0) 394 __extension__ 395 template<> 396 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_0> 397 : public true_type { }; 398 399 __extension__ 400 template<> 401 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_0> 402 : public true_type { }; 403 #endif 404 #if defined(__GLIBCXX_TYPE_INT_N_1) 405 __extension__ 406 template<> 407 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_1> 408 : public true_type { }; 409 410 __extension__ 411 template<> 412 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_1> 413 : public true_type { }; 414 #endif 415 #if defined(__GLIBCXX_TYPE_INT_N_2) 416 __extension__ 417 template<> 418 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_2> 419 : public true_type { }; 420 421 __extension__ 422 template<> 423 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_2> 424 : public true_type { }; 425 #endif 426 #if defined(__GLIBCXX_TYPE_INT_N_3) 427 __extension__ 428 template<> 429 struct __is_integral_helper<__GLIBCXX_TYPE_INT_N_3> 430 : public true_type { }; 431 432 __extension__ 433 template<> 434 struct __is_integral_helper<unsigned __GLIBCXX_TYPE_INT_N_3> 435 : public true_type { }; 436 #endif 437 /// @endcond 438 439 /// is_integral 440 template<typename _Tp> 441 struct is_integral 442 : public __is_integral_helper<__remove_cv_t<_Tp>>::type 443 { }; 444 445 /// @cond undocumented 446 template<typename> 447 struct __is_floating_point_helper 448 : public false_type { }; 449 450 template<> 451 struct __is_floating_point_helper<float> 452 : public true_type { }; 453 454 template<> 455 struct __is_floating_point_helper<double> 456 : public true_type { }; 457 458 template<> 459 struct __is_floating_point_helper<long double> 460 : public true_type { }; 461 462 #ifdef __STDCPP_FLOAT16_T__ 463 template<> 464 struct __is_floating_point_helper<_Float16> 465 : public true_type { }; 466 #endif 467 468 #ifdef __STDCPP_FLOAT32_T__ 469 template<> 470 struct __is_floating_point_helper<_Float32> 471 : public true_type { }; 472 #endif 473 474 #ifdef __STDCPP_FLOAT64_T__ 475 template<> 476 struct __is_floating_point_helper<_Float64> 477 : public true_type { }; 478 #endif 479 480 #ifdef __STDCPP_FLOAT128_T__ 481 template<> 482 struct __is_floating_point_helper<_Float128> 483 : public true_type { }; 484 #endif 485 486 #ifdef __STDCPP_BFLOAT16_T__ 487 template<> 488 struct __is_floating_point_helper<__gnu_cxx::__bfloat16_t> 489 : public true_type { }; 490 #endif 491 492 #if !defined(__STRICT_ANSI__) && defined(_GLIBCXX_USE_FLOAT128) && !defined(__CUDACC__) 493 template<> 494 struct __is_floating_point_helper<__float128> 495 : public true_type { }; 496 #endif 497 /// @endcond 498 499 /// is_floating_point 500 template<typename _Tp> 501 struct is_floating_point 502 : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type 503 { }; 504 505 /// is_array 506 template<typename> 507 struct is_array 508 : public false_type { }; 509 510 template<typename _Tp, std::size_t _Size> 511 struct is_array<_Tp[_Size]> 512 : public true_type { }; 513 514 template<typename _Tp> 515 struct is_array<_Tp[]> 516 : public true_type { }; 517 518 template<typename> 519 struct __is_pointer_helper 520 : public false_type { }; 521 522 template<typename _Tp> 523 struct __is_pointer_helper<_Tp*> 524 : public true_type { }; 525 526 /// is_pointer 527 template<typename _Tp> 528 struct is_pointer 529 : public __is_pointer_helper<__remove_cv_t<_Tp>>::type 530 { }; 531 532 /// is_lvalue_reference 533 template<typename> 534 struct is_lvalue_reference 535 : public false_type { }; 536 537 template<typename _Tp> 538 struct is_lvalue_reference<_Tp&> 539 : public true_type { }; 540 541 /// is_rvalue_reference 542 template<typename> 543 struct is_rvalue_reference 544 : public false_type { }; 545 546 template<typename _Tp> 547 struct is_rvalue_reference<_Tp&&> 548 : public true_type { }; 549 550 template<typename> 551 struct __is_member_object_pointer_helper 552 : public false_type { }; 553 554 template<typename _Tp, typename _Cp> 555 struct __is_member_object_pointer_helper<_Tp _Cp::*> 556 : public __not_<is_function<_Tp>>::type { }; 557 558 /// is_member_object_pointer 559 template<typename _Tp> 560 struct is_member_object_pointer 561 : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type 562 { }; 563 564 template<typename> 565 struct __is_member_function_pointer_helper 566 : public false_type { }; 567 568 template<typename _Tp, typename _Cp> 569 struct __is_member_function_pointer_helper<_Tp _Cp::*> 570 : public is_function<_Tp>::type { }; 571 572 /// is_member_function_pointer 573 template<typename _Tp> 574 struct is_member_function_pointer 575 : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type 576 { }; 577 578 /// is_enum 579 template<typename _Tp> 580 struct is_enum 581 : public integral_constant<bool, __is_enum(_Tp)> 582 { }; 583 584 /// is_union 585 template<typename _Tp> 586 struct is_union 587 : public integral_constant<bool, __is_union(_Tp)> 588 { }; 589 590 /// is_class 591 template<typename _Tp> 592 struct is_class 593 : public integral_constant<bool, __is_class(_Tp)> 594 { }; 595 596 /// is_function 597 template<typename _Tp> 598 struct is_function 599 : public __bool_constant<!is_const<const _Tp>::value> { }; 600 601 template<typename _Tp> 602 struct is_function<_Tp&> 603 : public false_type { }; 604 605 template<typename _Tp> 606 struct is_function<_Tp&&> 607 : public false_type { }; 608 609 #define __cpp_lib_is_null_pointer 201309L 610 611 /// is_null_pointer (LWG 2247). 612 template<typename _Tp> 613 struct is_null_pointer 614 : public false_type { }; 615 616 template<> 617 struct is_null_pointer<std::nullptr_t> 618 : public true_type { }; 619 620 template<> 621 struct is_null_pointer<const std::nullptr_t> 622 : public true_type { }; 623 624 template<> 625 struct is_null_pointer<volatile std::nullptr_t> 626 : public true_type { }; 627 628 template<> 629 struct is_null_pointer<const volatile std::nullptr_t> 630 : public true_type { }; 631 632 /// __is_nullptr_t (deprecated extension). 633 /// @deprecated Non-standard. Use `is_null_pointer` instead. 634 template<typename _Tp> 635 struct __is_nullptr_t 636 : public is_null_pointer<_Tp> 637 { } _GLIBCXX_DEPRECATED_SUGGEST("std::is_null_pointer"); 638 639 // Composite type categories. 640 641 /// is_reference 642 template<typename _Tp> 643 struct is_reference 644 : public false_type 645 { }; 646 647 template<typename _Tp> 648 struct is_reference<_Tp&> 649 : public true_type 650 { }; 651 652 template<typename _Tp> 653 struct is_reference<_Tp&&> 654 : public true_type 655 { }; 656 657 /// is_arithmetic 658 template<typename _Tp> 659 struct is_arithmetic 660 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type 661 { }; 662 663 /// is_fundamental 664 template<typename _Tp> 665 struct is_fundamental 666 : public __or_<is_arithmetic<_Tp>, is_void<_Tp>, 667 is_null_pointer<_Tp>>::type 668 { }; 669 670 /// is_object 671 template<typename _Tp> 672 struct is_object 673 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>, 674 is_void<_Tp>>>::type 675 { }; 676 677 template<typename> 678 struct is_member_pointer; 679 680 /// is_scalar 681 template<typename _Tp> 682 struct is_scalar 683 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>, 684 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type 685 { }; 686 687 /// is_compound 688 template<typename _Tp> 689 struct is_compound 690 : public __not_<is_fundamental<_Tp>>::type { }; 691 692 /// @cond undocumented 693 template<typename _Tp> 694 struct __is_member_pointer_helper 695 : public false_type { }; 696 697 template<typename _Tp, typename _Cp> 698 struct __is_member_pointer_helper<_Tp _Cp::*> 699 : public true_type { }; 700 /// @endcond 701 702 /// is_member_pointer 703 template<typename _Tp> 704 struct is_member_pointer 705 : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type 706 { }; 707 708 template<typename, typename> 709 struct is_same; 710 711 /// @cond undocumented 712 template<typename _Tp, typename... _Types> 713 using __is_one_of = __or_<is_same<_Tp, _Types>...>; 714 715 // Check if a type is one of the signed integer types. 716 __extension__ 717 template<typename _Tp> 718 using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, 719 signed char, signed short, signed int, signed long, 720 signed long long 721 #if defined(__GLIBCXX_TYPE_INT_N_0) 722 , signed __GLIBCXX_TYPE_INT_N_0 723 #endif 724 #if defined(__GLIBCXX_TYPE_INT_N_1) 725 , signed __GLIBCXX_TYPE_INT_N_1 726 #endif 727 #if defined(__GLIBCXX_TYPE_INT_N_2) 728 , signed __GLIBCXX_TYPE_INT_N_2 729 #endif 730 #if defined(__GLIBCXX_TYPE_INT_N_3) 731 , signed __GLIBCXX_TYPE_INT_N_3 732 #endif 733 >; 734 735 // Check if a type is one of the unsigned integer types. 736 __extension__ 737 template<typename _Tp> 738 using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, 739 unsigned char, unsigned short, unsigned int, unsigned long, 740 unsigned long long 741 #if defined(__GLIBCXX_TYPE_INT_N_0) 742 , unsigned __GLIBCXX_TYPE_INT_N_0 743 #endif 744 #if defined(__GLIBCXX_TYPE_INT_N_1) 745 , unsigned __GLIBCXX_TYPE_INT_N_1 746 #endif 747 #if defined(__GLIBCXX_TYPE_INT_N_2) 748 , unsigned __GLIBCXX_TYPE_INT_N_2 749 #endif 750 #if defined(__GLIBCXX_TYPE_INT_N_3) 751 , unsigned __GLIBCXX_TYPE_INT_N_3 752 #endif 753 >; 754 755 // Check if a type is one of the signed or unsigned integer types. 756 template<typename _Tp> 757 using __is_standard_integer 758 = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; 759 760 // __void_t (std::void_t for C++11) 761 template<typename...> using __void_t = void; 762 /// @endcond 763 764 // Type properties. 765 766 /// is_const 767 template<typename> 768 struct is_const 769 : public false_type { }; 770 771 template<typename _Tp> 772 struct is_const<_Tp const> 773 : public true_type { }; 774 775 /// is_volatile 776 template<typename> 777 struct is_volatile 778 : public false_type { }; 779 780 template<typename _Tp> 781 struct is_volatile<_Tp volatile> 782 : public true_type { }; 783 784 /// is_trivial 785 template<typename _Tp> 786 struct is_trivial 787 : public integral_constant<bool, __is_trivial(_Tp)> 788 { 789 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 790 "template argument must be a complete class or an unbounded array"); 791 }; 792 793 /// is_trivially_copyable 794 template<typename _Tp> 795 struct is_trivially_copyable 796 : public integral_constant<bool, __is_trivially_copyable(_Tp)> 797 { 798 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 799 "template argument must be a complete class or an unbounded array"); 800 }; 801 802 /// is_standard_layout 803 template<typename _Tp> 804 struct is_standard_layout 805 : public integral_constant<bool, __is_standard_layout(_Tp)> 806 { 807 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 808 "template argument must be a complete class or an unbounded array"); 809 }; 810 811 /** is_pod 812 * @deprecated Deprecated in C++20. 813 * Use `is_standard_layout && is_trivial` instead. 814 */ 815 // Could use is_standard_layout && is_trivial instead of the builtin. 816 template<typename _Tp> 817 struct 818 _GLIBCXX20_DEPRECATED_SUGGEST("is_standard_layout && is_trivial") 819 is_pod 820 : public integral_constant<bool, __is_pod(_Tp)> 821 { 822 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 823 "template argument must be a complete class or an unbounded array"); 824 }; 825 826 /** is_literal_type 827 * @deprecated Deprecated in C++17, removed in C++20. 828 * The idea of a literal type isn't useful. 829 */ 830 template<typename _Tp> 831 struct 832 _GLIBCXX17_DEPRECATED 833 is_literal_type 834 : public integral_constant<bool, __is_literal_type(_Tp)> 835 { 836 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 837 "template argument must be a complete class or an unbounded array"); 838 }; 839 840 /// is_empty 841 template<typename _Tp> 842 struct is_empty 843 : public integral_constant<bool, __is_empty(_Tp)> 844 { }; 845 846 /// is_polymorphic 847 template<typename _Tp> 848 struct is_polymorphic 849 : public integral_constant<bool, __is_polymorphic(_Tp)> 850 { }; 851 852 #if __cplusplus >= 201402L 853 #define __cpp_lib_is_final 201402L 854 /// is_final 855 /// @since C++14 856 template<typename _Tp> 857 struct is_final 858 : public integral_constant<bool, __is_final(_Tp)> 859 { }; 860 #endif 861 862 /// is_abstract 863 template<typename _Tp> 864 struct is_abstract 865 : public integral_constant<bool, __is_abstract(_Tp)> 866 { }; 867 868 /// @cond undocumented 869 template<typename _Tp, 870 bool = is_arithmetic<_Tp>::value> 871 struct __is_signed_helper 872 : public false_type { }; 873 874 template<typename _Tp> 875 struct __is_signed_helper<_Tp, true> 876 : public integral_constant<bool, _Tp(-1) < _Tp(0)> 877 { }; 878 /// @endcond 879 880 /// is_signed 881 template<typename _Tp> 882 struct is_signed 883 : public __is_signed_helper<_Tp>::type 884 { }; 885 886 /// is_unsigned 887 template<typename _Tp> 888 struct is_unsigned 889 : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type 890 { }; 891 892 /// @cond undocumented 893 template<typename _Tp, typename _Up = _Tp&&> 894 _Up 895 __declval(int); 896 897 template<typename _Tp> 898 _Tp 899 __declval(long); 900 /// @endcond 901 902 template<typename _Tp> 903 auto declval() noexcept -> decltype(__declval<_Tp>(0)); 904 905 template<typename> 906 struct remove_all_extents; 907 908 /// @cond undocumented 909 template<typename _Tp> 910 struct __is_array_known_bounds 911 : public false_type 912 { }; 913 914 template<typename _Tp, size_t _Size> 915 struct __is_array_known_bounds<_Tp[_Size]> 916 : public true_type 917 { }; 918 919 template<typename _Tp> 920 struct __is_array_unknown_bounds 921 : public false_type 922 { }; 923 924 template<typename _Tp> 925 struct __is_array_unknown_bounds<_Tp[]> 926 : public true_type 927 { }; 928 929 // Destructible and constructible type properties. 930 931 // In N3290 is_destructible does not say anything about function 932 // types and abstract types, see LWG 2049. This implementation 933 // describes function types as non-destructible and all complete 934 // object types as destructible, iff the explicit destructor 935 // call expression is wellformed. 936 struct __do_is_destructible_impl 937 { 938 template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())> 939 static true_type __test(int); 940 941 template<typename> 942 static false_type __test(...); 943 }; 944 945 template<typename _Tp> 946 struct __is_destructible_impl 947 : public __do_is_destructible_impl 948 { 949 typedef decltype(__test<_Tp>(0)) type; 950 }; 951 952 template<typename _Tp, 953 bool = __or_<is_void<_Tp>, 954 __is_array_unknown_bounds<_Tp>, 955 is_function<_Tp>>::value, 956 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> 957 struct __is_destructible_safe; 958 959 template<typename _Tp> 960 struct __is_destructible_safe<_Tp, false, false> 961 : public __is_destructible_impl<typename 962 remove_all_extents<_Tp>::type>::type 963 { }; 964 965 template<typename _Tp> 966 struct __is_destructible_safe<_Tp, true, false> 967 : public false_type { }; 968 969 template<typename _Tp> 970 struct __is_destructible_safe<_Tp, false, true> 971 : public true_type { }; 972 /// @endcond 973 974 /// is_destructible 975 template<typename _Tp> 976 struct is_destructible 977 : public __is_destructible_safe<_Tp>::type 978 { 979 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 980 "template argument must be a complete class or an unbounded array"); 981 }; 982 983 /// @cond undocumented 984 985 // is_nothrow_destructible requires that is_destructible is 986 // satisfied as well. We realize that by mimicing the 987 // implementation of is_destructible but refer to noexcept(expr) 988 // instead of decltype(expr). 989 struct __do_is_nt_destructible_impl 990 { 991 template<typename _Tp> 992 static __bool_constant<noexcept(declval<_Tp&>().~_Tp())> 993 __test(int); 994 995 template<typename> 996 static false_type __test(...); 997 }; 998 999 template<typename _Tp> 1000 struct __is_nt_destructible_impl 1001 : public __do_is_nt_destructible_impl 1002 { 1003 typedef decltype(__test<_Tp>(0)) type; 1004 }; 1005 1006 template<typename _Tp, 1007 bool = __or_<is_void<_Tp>, 1008 __is_array_unknown_bounds<_Tp>, 1009 is_function<_Tp>>::value, 1010 bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value> 1011 struct __is_nt_destructible_safe; 1012 1013 template<typename _Tp> 1014 struct __is_nt_destructible_safe<_Tp, false, false> 1015 : public __is_nt_destructible_impl<typename 1016 remove_all_extents<_Tp>::type>::type 1017 { }; 1018 1019 template<typename _Tp> 1020 struct __is_nt_destructible_safe<_Tp, true, false> 1021 : public false_type { }; 1022 1023 template<typename _Tp> 1024 struct __is_nt_destructible_safe<_Tp, false, true> 1025 : public true_type { }; 1026 /// @endcond 1027 1028 /// is_nothrow_destructible 1029 template<typename _Tp> 1030 struct is_nothrow_destructible 1031 : public __is_nt_destructible_safe<_Tp>::type 1032 { 1033 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1034 "template argument must be a complete class or an unbounded array"); 1035 }; 1036 1037 /// @cond undocumented 1038 template<typename _Tp, typename... _Args> 1039 using __is_constructible_impl 1040 = __bool_constant<__is_constructible(_Tp, _Args...)>; 1041 /// @endcond 1042 1043 /// is_constructible 1044 template<typename _Tp, typename... _Args> 1045 struct is_constructible 1046 : public __is_constructible_impl<_Tp, _Args...> 1047 { 1048 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1049 "template argument must be a complete class or an unbounded array"); 1050 }; 1051 1052 /// is_default_constructible 1053 template<typename _Tp> 1054 struct is_default_constructible 1055 : public __is_constructible_impl<_Tp> 1056 { 1057 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1058 "template argument must be a complete class or an unbounded array"); 1059 }; 1060 1061 /// @cond undocumented 1062 template<typename _Tp, typename = void> 1063 struct __add_lvalue_reference_helper 1064 { using type = _Tp; }; 1065 1066 template<typename _Tp> 1067 struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> 1068 { using type = _Tp&; }; 1069 1070 template<typename _Tp> 1071 using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; 1072 /// @endcond 1073 1074 /// is_copy_constructible 1075 template<typename _Tp> 1076 struct is_copy_constructible 1077 : public __is_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>> 1078 { 1079 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1080 "template argument must be a complete class or an unbounded array"); 1081 }; 1082 1083 /// @cond undocumented 1084 template<typename _Tp, typename = void> 1085 struct __add_rvalue_reference_helper 1086 { using type = _Tp; }; 1087 1088 template<typename _Tp> 1089 struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> 1090 { using type = _Tp&&; }; 1091 1092 template<typename _Tp> 1093 using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; 1094 /// @endcond 1095 1096 /// is_move_constructible 1097 template<typename _Tp> 1098 struct is_move_constructible 1099 : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> 1100 { 1101 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1102 "template argument must be a complete class or an unbounded array"); 1103 }; 1104 1105 /// @cond undocumented 1106 template<typename _Tp, typename... _Args> 1107 using __is_nothrow_constructible_impl 1108 = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; 1109 /// @endcond 1110 1111 /// is_nothrow_constructible 1112 template<typename _Tp, typename... _Args> 1113 struct is_nothrow_constructible 1114 : public __is_nothrow_constructible_impl<_Tp, _Args...> 1115 { 1116 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1117 "template argument must be a complete class or an unbounded array"); 1118 }; 1119 1120 /// is_nothrow_default_constructible 1121 template<typename _Tp> 1122 struct is_nothrow_default_constructible 1123 : public __is_nothrow_constructible_impl<_Tp> 1124 { 1125 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1126 "template argument must be a complete class or an unbounded array"); 1127 }; 1128 1129 /// is_nothrow_copy_constructible 1130 template<typename _Tp> 1131 struct is_nothrow_copy_constructible 1132 : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>> 1133 { 1134 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1135 "template argument must be a complete class or an unbounded array"); 1136 }; 1137 1138 /// is_nothrow_move_constructible 1139 template<typename _Tp> 1140 struct is_nothrow_move_constructible 1141 : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> 1142 { 1143 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1144 "template argument must be a complete class or an unbounded array"); 1145 }; 1146 1147 /// @cond undocumented 1148 template<typename _Tp, typename _Up> 1149 using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; 1150 /// @endcond 1151 1152 /// is_assignable 1153 template<typename _Tp, typename _Up> 1154 struct is_assignable 1155 : public __is_assignable_impl<_Tp, _Up> 1156 { 1157 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1158 "template argument must be a complete class or an unbounded array"); 1159 }; 1160 1161 /// is_copy_assignable 1162 template<typename _Tp> 1163 struct is_copy_assignable 1164 : public __is_assignable_impl<__add_lval_ref_t<_Tp>, 1165 __add_lval_ref_t<const _Tp>> 1166 { 1167 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1168 "template argument must be a complete class or an unbounded array"); 1169 }; 1170 1171 /// is_move_assignable 1172 template<typename _Tp> 1173 struct is_move_assignable 1174 : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> 1175 { 1176 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1177 "template argument must be a complete class or an unbounded array"); 1178 }; 1179 1180 /// @cond undocumented 1181 template<typename _Tp, typename _Up> 1182 using __is_nothrow_assignable_impl 1183 = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; 1184 /// @endcond 1185 1186 /// is_nothrow_assignable 1187 template<typename _Tp, typename _Up> 1188 struct is_nothrow_assignable 1189 : public __is_nothrow_assignable_impl<_Tp, _Up> 1190 { 1191 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1192 "template argument must be a complete class or an unbounded array"); 1193 }; 1194 1195 /// is_nothrow_copy_assignable 1196 template<typename _Tp> 1197 struct is_nothrow_copy_assignable 1198 : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, 1199 __add_lval_ref_t<const _Tp>> 1200 { 1201 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1202 "template argument must be a complete class or an unbounded array"); 1203 }; 1204 1205 /// is_nothrow_move_assignable 1206 template<typename _Tp> 1207 struct is_nothrow_move_assignable 1208 : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, 1209 __add_rval_ref_t<_Tp>> 1210 { 1211 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1212 "template argument must be a complete class or an unbounded array"); 1213 }; 1214 1215 /// @cond undocumented 1216 template<typename _Tp, typename... _Args> 1217 using __is_trivially_constructible_impl 1218 = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; 1219 /// @endcond 1220 1221 /// is_trivially_constructible 1222 template<typename _Tp, typename... _Args> 1223 struct is_trivially_constructible 1224 : public __is_trivially_constructible_impl<_Tp, _Args...> 1225 { 1226 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1227 "template argument must be a complete class or an unbounded array"); 1228 }; 1229 1230 /// is_trivially_default_constructible 1231 template<typename _Tp> 1232 struct is_trivially_default_constructible 1233 : public __is_trivially_constructible_impl<_Tp> 1234 { 1235 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1236 "template argument must be a complete class or an unbounded array"); 1237 }; 1238 1239 struct __do_is_implicitly_default_constructible_impl 1240 { 1241 template <typename _Tp> 1242 static void __helper(const _Tp&); 1243 1244 template <typename _Tp> 1245 static true_type __test(const _Tp&, 1246 decltype(__helper<const _Tp&>({}))* = 0); 1247 1248 static false_type __test(...); 1249 }; 1250 1251 template<typename _Tp> 1252 struct __is_implicitly_default_constructible_impl 1253 : public __do_is_implicitly_default_constructible_impl 1254 { 1255 typedef decltype(__test(declval<_Tp>())) type; 1256 }; 1257 1258 template<typename _Tp> 1259 struct __is_implicitly_default_constructible_safe 1260 : public __is_implicitly_default_constructible_impl<_Tp>::type 1261 { }; 1262 1263 template <typename _Tp> 1264 struct __is_implicitly_default_constructible 1265 : public __and_<__is_constructible_impl<_Tp>, 1266 __is_implicitly_default_constructible_safe<_Tp>>::type 1267 { }; 1268 1269 /// is_trivially_copy_constructible 1270 template<typename _Tp> 1271 struct is_trivially_copy_constructible 1272 : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>> 1273 { 1274 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1275 "template argument must be a complete class or an unbounded array"); 1276 }; 1277 1278 /// is_trivially_move_constructible 1279 template<typename _Tp> 1280 struct is_trivially_move_constructible 1281 : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> 1282 { 1283 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1284 "template argument must be a complete class or an unbounded array"); 1285 }; 1286 1287 /// @cond undocumented 1288 template<typename _Tp, typename _Up> 1289 using __is_trivially_assignable_impl 1290 = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; 1291 /// @endcond 1292 1293 /// is_trivially_assignable 1294 template<typename _Tp, typename _Up> 1295 struct is_trivially_assignable 1296 : public __is_trivially_assignable_impl<_Tp, _Up> 1297 { 1298 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1299 "template argument must be a complete class or an unbounded array"); 1300 }; 1301 1302 /// is_trivially_copy_assignable 1303 template<typename _Tp> 1304 struct is_trivially_copy_assignable 1305 : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, 1306 __add_lval_ref_t<const _Tp>> 1307 { 1308 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1309 "template argument must be a complete class or an unbounded array"); 1310 }; 1311 1312 /// is_trivially_move_assignable 1313 template<typename _Tp> 1314 struct is_trivially_move_assignable 1315 : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, 1316 __add_rval_ref_t<_Tp>> 1317 { 1318 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1319 "template argument must be a complete class or an unbounded array"); 1320 }; 1321 1322 /// is_trivially_destructible 1323 template<typename _Tp> 1324 struct is_trivially_destructible 1325 : public __and_<__is_destructible_safe<_Tp>, 1326 __bool_constant<__has_trivial_destructor(_Tp)>>::type 1327 { 1328 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1329 "template argument must be a complete class or an unbounded array"); 1330 }; 1331 1332 1333 /// has_virtual_destructor 1334 template<typename _Tp> 1335 struct has_virtual_destructor 1336 : public integral_constant<bool, __has_virtual_destructor(_Tp)> 1337 { 1338 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1339 "template argument must be a complete class or an unbounded array"); 1340 }; 1341 1342 1343 // type property queries. 1344 1345 /// alignment_of 1346 template<typename _Tp> 1347 struct alignment_of 1348 : public integral_constant<std::size_t, alignof(_Tp)> 1349 { 1350 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 1351 "template argument must be a complete class or an unbounded array"); 1352 }; 1353 1354 /// rank 1355 template<typename> 1356 struct rank 1357 : public integral_constant<std::size_t, 0> { }; 1358 1359 template<typename _Tp, std::size_t _Size> 1360 struct rank<_Tp[_Size]> 1361 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; 1362 1363 template<typename _Tp> 1364 struct rank<_Tp[]> 1365 : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; 1366 1367 /// extent 1368 template<typename, unsigned _Uint = 0> 1369 struct extent 1370 : public integral_constant<size_t, 0> { }; 1371 1372 template<typename _Tp, size_t _Size> 1373 struct extent<_Tp[_Size], 0> 1374 : public integral_constant<size_t, _Size> { }; 1375 1376 template<typename _Tp, unsigned _Uint, size_t _Size> 1377 struct extent<_Tp[_Size], _Uint> 1378 : public extent<_Tp, _Uint - 1>::type { }; 1379 1380 template<typename _Tp> 1381 struct extent<_Tp[], 0> 1382 : public integral_constant<size_t, 0> { }; 1383 1384 template<typename _Tp, unsigned _Uint> 1385 struct extent<_Tp[], _Uint> 1386 : public extent<_Tp, _Uint - 1>::type { }; 1387 1388 1389 // Type relations. 1390 1391 /// is_same 1392 template<typename _Tp, typename _Up> 1393 struct is_same 1394 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME 1395 : public integral_constant<bool, __is_same(_Tp, _Up)> 1396 #else 1397 : public false_type 1398 #endif 1399 { }; 1400 1401 #ifndef _GLIBCXX_HAVE_BUILTIN_IS_SAME 1402 template<typename _Tp> 1403 struct is_same<_Tp, _Tp> 1404 : public true_type 1405 { }; 1406 #endif 1407 1408 /// is_base_of 1409 template<typename _Base, typename _Derived> 1410 struct is_base_of 1411 : public integral_constant<bool, __is_base_of(_Base, _Derived)> 1412 { }; 1413 1414 #if __has_builtin(__is_convertible) 1415 template<typename _From, typename _To> 1416 struct is_convertible 1417 : public __bool_constant<__is_convertible(_From, _To)> 1418 { }; 1419 #else 1420 template<typename _From, typename _To, 1421 bool = __or_<is_void<_From>, is_function<_To>, 1422 is_array<_To>>::value> 1423 struct __is_convertible_helper 1424 { 1425 typedef typename is_void<_To>::type type; 1426 }; 1427 1428 #pragma GCC diagnostic push 1429 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" 1430 template<typename _From, typename _To> 1431 class __is_convertible_helper<_From, _To, false> 1432 { 1433 template<typename _To1> 1434 static void __test_aux(_To1) noexcept; 1435 1436 template<typename _From1, typename _To1, 1437 typename = decltype(__test_aux<_To1>(std::declval<_From1>()))> 1438 static true_type 1439 __test(int); 1440 1441 template<typename, typename> 1442 static false_type 1443 __test(...); 1444 1445 public: 1446 typedef decltype(__test<_From, _To>(0)) type; 1447 }; 1448 #pragma GCC diagnostic pop 1449 1450 /// is_convertible 1451 template<typename _From, typename _To> 1452 struct is_convertible 1453 : public __is_convertible_helper<_From, _To>::type 1454 { }; 1455 #endif 1456 1457 // helper trait for unique_ptr<T[]>, shared_ptr<T[]>, and span<T, N> 1458 template<typename _ToElementType, typename _FromElementType> 1459 using __is_array_convertible 1460 = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; 1461 1462 #if __cplusplus >= 202002L 1463 #define __cpp_lib_is_nothrow_convertible 201806L 1464 1465 #if __has_builtin(__is_nothrow_convertible) 1466 /// is_nothrow_convertible_v 1467 template<typename _From, typename _To> 1468 inline constexpr bool is_nothrow_convertible_v 1469 = __is_nothrow_convertible(_From, _To); 1470 1471 /// is_nothrow_convertible 1472 template<typename _From, typename _To> 1473 struct is_nothrow_convertible 1474 : public bool_constant<is_nothrow_convertible_v<_From, _To>> 1475 { }; 1476 #else 1477 template<typename _From, typename _To, 1478 bool = __or_<is_void<_From>, is_function<_To>, 1479 is_array<_To>>::value> 1480 struct __is_nt_convertible_helper 1481 : is_void<_To> 1482 { }; 1483 1484 #pragma GCC diagnostic push 1485 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" 1486 template<typename _From, typename _To> 1487 class __is_nt_convertible_helper<_From, _To, false> 1488 { 1489 template<typename _To1> 1490 static void __test_aux(_To1) noexcept; 1491 1492 template<typename _From1, typename _To1> 1493 static 1494 __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))> 1495 __test(int); 1496 1497 template<typename, typename> 1498 static false_type 1499 __test(...); 1500 1501 public: 1502 using type = decltype(__test<_From, _To>(0)); 1503 }; 1504 #pragma GCC diagnostic pop 1505 1506 /// is_nothrow_convertible 1507 template<typename _From, typename _To> 1508 struct is_nothrow_convertible 1509 : public __is_nt_convertible_helper<_From, _To>::type 1510 { }; 1511 1512 /// is_nothrow_convertible_v 1513 template<typename _From, typename _To> 1514 inline constexpr bool is_nothrow_convertible_v 1515 = is_nothrow_convertible<_From, _To>::value; 1516 #endif 1517 #endif // C++2a 1518 1519 // Const-volatile modifications. 1520 1521 /// remove_const 1522 template<typename _Tp> 1523 struct remove_const 1524 { typedef _Tp type; }; 1525 1526 template<typename _Tp> 1527 struct remove_const<_Tp const> 1528 { typedef _Tp type; }; 1529 1530 /// remove_volatile 1531 template<typename _Tp> 1532 struct remove_volatile 1533 { typedef _Tp type; }; 1534 1535 template<typename _Tp> 1536 struct remove_volatile<_Tp volatile> 1537 { typedef _Tp type; }; 1538 1539 /// remove_cv 1540 #if __has_builtin(__remove_cv) 1541 template<typename _Tp> 1542 struct remove_cv 1543 { using type = __remove_cv(_Tp); }; 1544 #else 1545 template<typename _Tp> 1546 struct remove_cv 1547 { using type = _Tp; }; 1548 1549 template<typename _Tp> 1550 struct remove_cv<const _Tp> 1551 { using type = _Tp; }; 1552 1553 template<typename _Tp> 1554 struct remove_cv<volatile _Tp> 1555 { using type = _Tp; }; 1556 1557 template<typename _Tp> 1558 struct remove_cv<const volatile _Tp> 1559 { using type = _Tp; }; 1560 #endif 1561 1562 /// add_const 1563 template<typename _Tp> 1564 struct add_const 1565 { using type = _Tp const; }; 1566 1567 /// add_volatile 1568 template<typename _Tp> 1569 struct add_volatile 1570 { using type = _Tp volatile; }; 1571 1572 /// add_cv 1573 template<typename _Tp> 1574 struct add_cv 1575 { using type = _Tp const volatile; }; 1576 1577 #if __cplusplus > 201103L 1578 1579 #define __cpp_lib_transformation_trait_aliases 201304L 1580 1581 /// Alias template for remove_const 1582 template<typename _Tp> 1583 using remove_const_t = typename remove_const<_Tp>::type; 1584 1585 /// Alias template for remove_volatile 1586 template<typename _Tp> 1587 using remove_volatile_t = typename remove_volatile<_Tp>::type; 1588 1589 /// Alias template for remove_cv 1590 template<typename _Tp> 1591 using remove_cv_t = typename remove_cv<_Tp>::type; 1592 1593 /// Alias template for add_const 1594 template<typename _Tp> 1595 using add_const_t = typename add_const<_Tp>::type; 1596 1597 /// Alias template for add_volatile 1598 template<typename _Tp> 1599 using add_volatile_t = typename add_volatile<_Tp>::type; 1600 1601 /// Alias template for add_cv 1602 template<typename _Tp> 1603 using add_cv_t = typename add_cv<_Tp>::type; 1604 #endif 1605 1606 // Reference transformations. 1607 1608 /// remove_reference 1609 #if __has_builtin(__remove_reference) 1610 template<typename _Tp> 1611 struct remove_reference 1612 { using type = __remove_reference(_Tp); }; 1613 #else 1614 template<typename _Tp> 1615 struct remove_reference 1616 { using type = _Tp; }; 1617 1618 template<typename _Tp> 1619 struct remove_reference<_Tp&> 1620 { using type = _Tp; }; 1621 1622 template<typename _Tp> 1623 struct remove_reference<_Tp&&> 1624 { using type = _Tp; }; 1625 #endif 1626 1627 /// add_lvalue_reference 1628 template<typename _Tp> 1629 struct add_lvalue_reference 1630 { using type = __add_lval_ref_t<_Tp>; }; 1631 1632 /// add_rvalue_reference 1633 template<typename _Tp> 1634 struct add_rvalue_reference 1635 { using type = __add_rval_ref_t<_Tp>; }; 1636 1637 #if __cplusplus > 201103L 1638 /// Alias template for remove_reference 1639 template<typename _Tp> 1640 using remove_reference_t = typename remove_reference<_Tp>::type; 1641 1642 /// Alias template for add_lvalue_reference 1643 template<typename _Tp> 1644 using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; 1645 1646 /// Alias template for add_rvalue_reference 1647 template<typename _Tp> 1648 using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; 1649 #endif 1650 1651 // Sign modifications. 1652 1653 /// @cond undocumented 1654 1655 // Utility for constructing identically cv-qualified types. 1656 template<typename _Unqualified, bool _IsConst, bool _IsVol> 1657 struct __cv_selector; 1658 1659 template<typename _Unqualified> 1660 struct __cv_selector<_Unqualified, false, false> 1661 { typedef _Unqualified __type; }; 1662 1663 template<typename _Unqualified> 1664 struct __cv_selector<_Unqualified, false, true> 1665 { typedef volatile _Unqualified __type; }; 1666 1667 template<typename _Unqualified> 1668 struct __cv_selector<_Unqualified, true, false> 1669 { typedef const _Unqualified __type; }; 1670 1671 template<typename _Unqualified> 1672 struct __cv_selector<_Unqualified, true, true> 1673 { typedef const volatile _Unqualified __type; }; 1674 1675 template<typename _Qualified, typename _Unqualified, 1676 bool _IsConst = is_const<_Qualified>::value, 1677 bool _IsVol = is_volatile<_Qualified>::value> 1678 class __match_cv_qualifiers 1679 { 1680 typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; 1681 1682 public: 1683 typedef typename __match::__type __type; 1684 }; 1685 1686 // Utility for finding the unsigned versions of signed integral types. 1687 template<typename _Tp> 1688 struct __make_unsigned 1689 { typedef _Tp __type; }; 1690 1691 template<> 1692 struct __make_unsigned<char> 1693 { typedef unsigned char __type; }; 1694 1695 template<> 1696 struct __make_unsigned<signed char> 1697 { typedef unsigned char __type; }; 1698 1699 template<> 1700 struct __make_unsigned<short> 1701 { typedef unsigned short __type; }; 1702 1703 template<> 1704 struct __make_unsigned<int> 1705 { typedef unsigned int __type; }; 1706 1707 template<> 1708 struct __make_unsigned<long> 1709 { typedef unsigned long __type; }; 1710 1711 template<> 1712 struct __make_unsigned<long long> 1713 { typedef unsigned long long __type; }; 1714 1715 #if defined(__GLIBCXX_TYPE_INT_N_0) 1716 __extension__ 1717 template<> 1718 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_0> 1719 { typedef unsigned __GLIBCXX_TYPE_INT_N_0 __type; }; 1720 #endif 1721 #if defined(__GLIBCXX_TYPE_INT_N_1) 1722 __extension__ 1723 template<> 1724 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_1> 1725 { typedef unsigned __GLIBCXX_TYPE_INT_N_1 __type; }; 1726 #endif 1727 #if defined(__GLIBCXX_TYPE_INT_N_2) 1728 __extension__ 1729 template<> 1730 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_2> 1731 { typedef unsigned __GLIBCXX_TYPE_INT_N_2 __type; }; 1732 #endif 1733 #if defined(__GLIBCXX_TYPE_INT_N_3) 1734 __extension__ 1735 template<> 1736 struct __make_unsigned<__GLIBCXX_TYPE_INT_N_3> 1737 { typedef unsigned __GLIBCXX_TYPE_INT_N_3 __type; }; 1738 #endif 1739 1740 // Select between integral and enum: not possible to be both. 1741 template<typename _Tp, 1742 bool _IsInt = is_integral<_Tp>::value, 1743 bool _IsEnum = is_enum<_Tp>::value> 1744 class __make_unsigned_selector; 1745 1746 template<typename _Tp> 1747 class __make_unsigned_selector<_Tp, true, false> 1748 { 1749 using __unsigned_type 1750 = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; 1751 1752 public: 1753 using __type 1754 = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; 1755 }; 1756 1757 class __make_unsigned_selector_base 1758 { 1759 protected: 1760 template<typename...> struct _List { }; 1761 1762 template<typename _Tp, typename... _Up> 1763 struct _List<_Tp, _Up...> : _List<_Up...> 1764 { static constexpr size_t __size = sizeof(_Tp); }; 1765 1766 template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)> 1767 struct __select; 1768 1769 template<size_t _Sz, typename _Uint, typename... _UInts> 1770 struct __select<_Sz, _List<_Uint, _UInts...>, true> 1771 { using __type = _Uint; }; 1772 1773 template<size_t _Sz, typename _Uint, typename... _UInts> 1774 struct __select<_Sz, _List<_Uint, _UInts...>, false> 1775 : __select<_Sz, _List<_UInts...>> 1776 { }; 1777 }; 1778 1779 // Choose unsigned integer type with the smallest rank and same size as _Tp 1780 template<typename _Tp> 1781 class __make_unsigned_selector<_Tp, false, true> 1782 : __make_unsigned_selector_base 1783 { 1784 // With -fshort-enums, an enum may be as small as a char. 1785 using _UInts = _List<unsigned char, unsigned short, unsigned int, 1786 unsigned long, unsigned long long>; 1787 1788 using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type; 1789 1790 public: 1791 using __type 1792 = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; 1793 }; 1794 1795 // wchar_t, char8_t, char16_t and char32_t are integral types but are 1796 // neither signed integer types nor unsigned integer types, so must be 1797 // transformed to the unsigned integer type with the smallest rank. 1798 // Use the partial specialization for enumeration types to do that. 1799 template<> 1800 struct __make_unsigned<wchar_t> 1801 { 1802 using __type 1803 = typename __make_unsigned_selector<wchar_t, false, true>::__type; 1804 }; 1805 1806 #ifdef _GLIBCXX_USE_CHAR8_T 1807 template<> 1808 struct __make_unsigned<char8_t> 1809 { 1810 using __type 1811 = typename __make_unsigned_selector<char8_t, false, true>::__type; 1812 }; 1813 #endif 1814 1815 template<> 1816 struct __make_unsigned<char16_t> 1817 { 1818 using __type 1819 = typename __make_unsigned_selector<char16_t, false, true>::__type; 1820 }; 1821 1822 template<> 1823 struct __make_unsigned<char32_t> 1824 { 1825 using __type 1826 = typename __make_unsigned_selector<char32_t, false, true>::__type; 1827 }; 1828 /// @endcond 1829 1830 // Given an integral/enum type, return the corresponding unsigned 1831 // integer type. 1832 // Primary template. 1833 /// make_unsigned 1834 template<typename _Tp> 1835 struct make_unsigned 1836 { typedef typename __make_unsigned_selector<_Tp>::__type type; }; 1837 1838 // Integral, but don't define. 1839 template<> struct make_unsigned<bool>; 1840 template<> struct make_unsigned<bool const>; 1841 template<> struct make_unsigned<bool volatile>; 1842 template<> struct make_unsigned<bool const volatile>; 1843 1844 /// @cond undocumented 1845 1846 // Utility for finding the signed versions of unsigned integral types. 1847 template<typename _Tp> 1848 struct __make_signed 1849 { typedef _Tp __type; }; 1850 1851 template<> 1852 struct __make_signed<char> 1853 { typedef signed char __type; }; 1854 1855 template<> 1856 struct __make_signed<unsigned char> 1857 { typedef signed char __type; }; 1858 1859 template<> 1860 struct __make_signed<unsigned short> 1861 { typedef signed short __type; }; 1862 1863 template<> 1864 struct __make_signed<unsigned int> 1865 { typedef signed int __type; }; 1866 1867 template<> 1868 struct __make_signed<unsigned long> 1869 { typedef signed long __type; }; 1870 1871 template<> 1872 struct __make_signed<unsigned long long> 1873 { typedef signed long long __type; }; 1874 1875 #if defined(__GLIBCXX_TYPE_INT_N_0) 1876 __extension__ 1877 template<> 1878 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_0> 1879 { typedef __GLIBCXX_TYPE_INT_N_0 __type; }; 1880 #endif 1881 #if defined(__GLIBCXX_TYPE_INT_N_1) 1882 __extension__ 1883 template<> 1884 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_1> 1885 { typedef __GLIBCXX_TYPE_INT_N_1 __type; }; 1886 #endif 1887 #if defined(__GLIBCXX_TYPE_INT_N_2) 1888 __extension__ 1889 template<> 1890 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_2> 1891 { typedef __GLIBCXX_TYPE_INT_N_2 __type; }; 1892 #endif 1893 #if defined(__GLIBCXX_TYPE_INT_N_3) 1894 __extension__ 1895 template<> 1896 struct __make_signed<unsigned __GLIBCXX_TYPE_INT_N_3> 1897 { typedef __GLIBCXX_TYPE_INT_N_3 __type; }; 1898 #endif 1899 1900 // Select between integral and enum: not possible to be both. 1901 template<typename _Tp, 1902 bool _IsInt = is_integral<_Tp>::value, 1903 bool _IsEnum = is_enum<_Tp>::value> 1904 class __make_signed_selector; 1905 1906 template<typename _Tp> 1907 class __make_signed_selector<_Tp, true, false> 1908 { 1909 using __signed_type 1910 = typename __make_signed<__remove_cv_t<_Tp>>::__type; 1911 1912 public: 1913 using __type 1914 = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; 1915 }; 1916 1917 // Choose signed integer type with the smallest rank and same size as _Tp 1918 template<typename _Tp> 1919 class __make_signed_selector<_Tp, false, true> 1920 { 1921 typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; 1922 1923 public: 1924 typedef typename __make_signed_selector<__unsigned_type>::__type __type; 1925 }; 1926 1927 // wchar_t, char16_t and char32_t are integral types but are neither 1928 // signed integer types nor unsigned integer types, so must be 1929 // transformed to the signed integer type with the smallest rank. 1930 // Use the partial specialization for enumeration types to do that. 1931 template<> 1932 struct __make_signed<wchar_t> 1933 { 1934 using __type 1935 = typename __make_signed_selector<wchar_t, false, true>::__type; 1936 }; 1937 1938 #if defined(_GLIBCXX_USE_CHAR8_T) 1939 template<> 1940 struct __make_signed<char8_t> 1941 { 1942 using __type 1943 = typename __make_signed_selector<char8_t, false, true>::__type; 1944 }; 1945 #endif 1946 1947 template<> 1948 struct __make_signed<char16_t> 1949 { 1950 using __type 1951 = typename __make_signed_selector<char16_t, false, true>::__type; 1952 }; 1953 1954 template<> 1955 struct __make_signed<char32_t> 1956 { 1957 using __type 1958 = typename __make_signed_selector<char32_t, false, true>::__type; 1959 }; 1960 /// @endcond 1961 1962 // Given an integral/enum type, return the corresponding signed 1963 // integer type. 1964 // Primary template. 1965 /// make_signed 1966 template<typename _Tp> 1967 struct make_signed 1968 { typedef typename __make_signed_selector<_Tp>::__type type; }; 1969 1970 // Integral, but don't define. 1971 template<> struct make_signed<bool>; 1972 template<> struct make_signed<bool const>; 1973 template<> struct make_signed<bool volatile>; 1974 template<> struct make_signed<bool const volatile>; 1975 1976 #if __cplusplus > 201103L 1977 /// Alias template for make_signed 1978 template<typename _Tp> 1979 using make_signed_t = typename make_signed<_Tp>::type; 1980 1981 /// Alias template for make_unsigned 1982 template<typename _Tp> 1983 using make_unsigned_t = typename make_unsigned<_Tp>::type; 1984 #endif 1985 1986 // Array modifications. 1987 1988 /// remove_extent 1989 template<typename _Tp> 1990 struct remove_extent 1991 { typedef _Tp type; }; 1992 1993 template<typename _Tp, std::size_t _Size> 1994 struct remove_extent<_Tp[_Size]> 1995 { typedef _Tp type; }; 1996 1997 template<typename _Tp> 1998 struct remove_extent<_Tp[]> 1999 { typedef _Tp type; }; 2000 2001 /// remove_all_extents 2002 template<typename _Tp> 2003 struct remove_all_extents 2004 { typedef _Tp type; }; 2005 2006 template<typename _Tp, std::size_t _Size> 2007 struct remove_all_extents<_Tp[_Size]> 2008 { typedef typename remove_all_extents<_Tp>::type type; }; 2009 2010 template<typename _Tp> 2011 struct remove_all_extents<_Tp[]> 2012 { typedef typename remove_all_extents<_Tp>::type type; }; 2013 2014 #if __cplusplus > 201103L 2015 /// Alias template for remove_extent 2016 template<typename _Tp> 2017 using remove_extent_t = typename remove_extent<_Tp>::type; 2018 2019 /// Alias template for remove_all_extents 2020 template<typename _Tp> 2021 using remove_all_extents_t = typename remove_all_extents<_Tp>::type; 2022 #endif 2023 2024 // Pointer modifications. 2025 2026 template<typename _Tp, typename> 2027 struct __remove_pointer_helper 2028 { typedef _Tp type; }; 2029 2030 template<typename _Tp, typename _Up> 2031 struct __remove_pointer_helper<_Tp, _Up*> 2032 { typedef _Up type; }; 2033 2034 /// remove_pointer 2035 template<typename _Tp> 2036 struct remove_pointer 2037 : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> 2038 { }; 2039 2040 template<typename _Tp, typename = void> 2041 struct __add_pointer_helper 2042 { using type = _Tp; }; 2043 2044 template<typename _Tp> 2045 struct __add_pointer_helper<_Tp, __void_t<_Tp*>> 2046 { using type = _Tp*; }; 2047 2048 /// add_pointer 2049 template<typename _Tp> 2050 struct add_pointer 2051 : public __add_pointer_helper<_Tp> 2052 { }; 2053 2054 template<typename _Tp> 2055 struct add_pointer<_Tp&> 2056 { using type = _Tp*; }; 2057 2058 template<typename _Tp> 2059 struct add_pointer<_Tp&&> 2060 { using type = _Tp*; }; 2061 2062 #if __cplusplus > 201103L 2063 /// Alias template for remove_pointer 2064 template<typename _Tp> 2065 using remove_pointer_t = typename remove_pointer<_Tp>::type; 2066 2067 /// Alias template for add_pointer 2068 template<typename _Tp> 2069 using add_pointer_t = typename add_pointer<_Tp>::type; 2070 #endif 2071 2072 template<std::size_t _Len> 2073 struct __aligned_storage_msa 2074 { 2075 union __type 2076 { 2077 unsigned char __data[_Len]; 2078 struct __attribute__((__aligned__)) { } __align; 2079 }; 2080 }; 2081 2082 /** 2083 * @brief Alignment type. 2084 * 2085 * The value of _Align is a default-alignment which shall be the 2086 * most stringent alignment requirement for any C++ object type 2087 * whose size is no greater than _Len (3.9). The member typedef 2088 * type shall be a POD type suitable for use as uninitialized 2089 * storage for any object whose size is at most _Len and whose 2090 * alignment is a divisor of _Align. 2091 * 2092 * @deprecated Deprecated in C++23. Uses can be replaced by an 2093 * array std::byte[_Len] declared with alignas(_Align). 2094 */ 2095 template<std::size_t _Len, std::size_t _Align = 2096 __alignof__(typename __aligned_storage_msa<_Len>::__type)> 2097 struct 2098 _GLIBCXX23_DEPRECATED 2099 aligned_storage 2100 { 2101 union type 2102 { 2103 unsigned char __data[_Len]; 2104 struct __attribute__((__aligned__((_Align)))) { } __align; 2105 }; 2106 }; 2107 2108 template <typename... _Types> 2109 struct __strictest_alignment 2110 { 2111 static const size_t _S_alignment = 0; 2112 static const size_t _S_size = 0; 2113 }; 2114 2115 template <typename _Tp, typename... _Types> 2116 struct __strictest_alignment<_Tp, _Types...> 2117 { 2118 static const size_t _S_alignment = 2119 alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment 2120 ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; 2121 static const size_t _S_size = 2122 sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size 2123 ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; 2124 }; 2125 2126 #pragma GCC diagnostic push 2127 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 2128 2129 /** 2130 * @brief Provide aligned storage for types. 2131 * 2132 * [meta.trans.other] 2133 * 2134 * Provides aligned storage for any of the provided types of at 2135 * least size _Len. 2136 * 2137 * @see aligned_storage 2138 * 2139 * @deprecated Deprecated in C++23. 2140 */ 2141 template <size_t _Len, typename... _Types> 2142 struct 2143 _GLIBCXX23_DEPRECATED 2144 aligned_union 2145 { 2146 private: 2147 static_assert(sizeof...(_Types) != 0, "At least one type is required"); 2148 2149 using __strictest = __strictest_alignment<_Types...>; 2150 static const size_t _S_len = _Len > __strictest::_S_size 2151 ? _Len : __strictest::_S_size; 2152 public: 2153 /// The value of the strictest alignment of _Types. 2154 static const size_t alignment_value = __strictest::_S_alignment; 2155 /// The storage. 2156 typedef typename aligned_storage<_S_len, alignment_value>::type type; 2157 }; 2158 2159 template <size_t _Len, typename... _Types> 2160 const size_t aligned_union<_Len, _Types...>::alignment_value; 2161 #pragma GCC diagnostic pop 2162 2163 /// @cond undocumented 2164 2165 // Decay trait for arrays and functions, used for perfect forwarding 2166 // in make_pair, make_tuple, etc. 2167 template<typename _Up> 2168 struct __decay_selector 2169 : __conditional_t<is_const<const _Up>::value, // false for functions 2170 remove_cv<_Up>, // N.B. DR 705. 2171 add_pointer<_Up>> // function decays to pointer 2172 { }; 2173 2174 template<typename _Up, size_t _Nm> 2175 struct __decay_selector<_Up[_Nm]> 2176 { using type = _Up*; }; 2177 2178 template<typename _Up> 2179 struct __decay_selector<_Up[]> 2180 { using type = _Up*; }; 2181 2182 /// @endcond 2183 2184 /// decay 2185 template<typename _Tp> 2186 struct decay 2187 { using type = typename __decay_selector<_Tp>::type; }; 2188 2189 template<typename _Tp> 2190 struct decay<_Tp&> 2191 { using type = typename __decay_selector<_Tp>::type; }; 2192 2193 template<typename _Tp> 2194 struct decay<_Tp&&> 2195 { using type = typename __decay_selector<_Tp>::type; }; 2196 2197 /// @cond undocumented 2198 2199 // Helper which adds a reference to a type when given a reference_wrapper 2200 template<typename _Tp> 2201 struct __strip_reference_wrapper 2202 { 2203 typedef _Tp __type; 2204 }; 2205 2206 template<typename _Tp> 2207 struct __strip_reference_wrapper<reference_wrapper<_Tp> > 2208 { 2209 typedef _Tp& __type; 2210 }; 2211 2212 // __decay_t (std::decay_t for C++11). 2213 template<typename _Tp> 2214 using __decay_t = typename decay<_Tp>::type; 2215 2216 template<typename _Tp> 2217 using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; 2218 /// @endcond 2219 2220 /// @cond undocumented 2221 2222 // Helper for SFINAE constraints 2223 template<typename... _Cond> 2224 using _Require = __enable_if_t<__and_<_Cond...>::value>; 2225 2226 // __remove_cvref_t (std::remove_cvref_t for C++11). 2227 template<typename _Tp> 2228 using __remove_cvref_t 2229 = typename remove_cv<typename remove_reference<_Tp>::type>::type; 2230 /// @endcond 2231 2232 // Primary template. 2233 /// Define a member typedef @c type to one of two argument types. 2234 template<bool _Cond, typename _Iftrue, typename _Iffalse> 2235 struct conditional 2236 { typedef _Iftrue type; }; 2237 2238 // Partial specialization for false. 2239 template<typename _Iftrue, typename _Iffalse> 2240 struct conditional<false, _Iftrue, _Iffalse> 2241 { typedef _Iffalse type; }; 2242 2243 /// common_type 2244 template<typename... _Tp> 2245 struct common_type; 2246 2247 // Sfinae-friendly common_type implementation: 2248 2249 /// @cond undocumented 2250 2251 // For several sfinae-friendly trait implementations we transport both the 2252 // result information (as the member type) and the failure information (no 2253 // member type). This is very similar to std::enable_if, but we cannot use 2254 // that, because we need to derive from them as an implementation detail. 2255 2256 template<typename _Tp> 2257 struct __success_type 2258 { typedef _Tp type; }; 2259 2260 struct __failure_type 2261 { }; 2262 2263 struct __do_common_type_impl 2264 { 2265 template<typename _Tp, typename _Up> 2266 using __cond_t 2267 = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); 2268 2269 // if decay_t<decltype(false ? declval<D1>() : declval<D2>())> 2270 // denotes a valid type, let C denote that type. 2271 template<typename _Tp, typename _Up> 2272 static __success_type<__decay_t<__cond_t<_Tp, _Up>>> 2273 _S_test(int); 2274 2275 #if __cplusplus > 201703L 2276 // Otherwise, if COND-RES(CREF(D1), CREF(D2)) denotes a type, 2277 // let C denote the type decay_t<COND-RES(CREF(D1), CREF(D2))>. 2278 template<typename _Tp, typename _Up> 2279 static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>> 2280 _S_test_2(int); 2281 #endif 2282 2283 template<typename, typename> 2284 static __failure_type 2285 _S_test_2(...); 2286 2287 template<typename _Tp, typename _Up> 2288 static decltype(_S_test_2<_Tp, _Up>(0)) 2289 _S_test(...); 2290 }; 2291 2292 // If sizeof...(T) is zero, there shall be no member type. 2293 template<> 2294 struct common_type<> 2295 { }; 2296 2297 // If sizeof...(T) is one, the same type, if any, as common_type_t<T0, T0>. 2298 template<typename _Tp0> 2299 struct common_type<_Tp0> 2300 : public common_type<_Tp0, _Tp0> 2301 { }; 2302 2303 // If sizeof...(T) is two, ... 2304 template<typename _Tp1, typename _Tp2, 2305 typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>> 2306 struct __common_type_impl 2307 { 2308 // If is_same_v<T1, D1> is false or is_same_v<T2, D2> is false, 2309 // let C denote the same type, if any, as common_type_t<D1, D2>. 2310 using type = common_type<_Dp1, _Dp2>; 2311 }; 2312 2313 template<typename _Tp1, typename _Tp2> 2314 struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> 2315 : private __do_common_type_impl 2316 { 2317 // Otherwise, if decay_t<decltype(false ? declval<D1>() : declval<D2>())> 2318 // denotes a valid type, let C denote that type. 2319 using type = decltype(_S_test<_Tp1, _Tp2>(0)); 2320 }; 2321 2322 // If sizeof...(T) is two, ... 2323 template<typename _Tp1, typename _Tp2> 2324 struct common_type<_Tp1, _Tp2> 2325 : public __common_type_impl<_Tp1, _Tp2>::type 2326 { }; 2327 2328 template<typename...> 2329 struct __common_type_pack 2330 { }; 2331 2332 template<typename, typename, typename = void> 2333 struct __common_type_fold; 2334 2335 // If sizeof...(T) is greater than two, ... 2336 template<typename _Tp1, typename _Tp2, typename... _Rp> 2337 struct common_type<_Tp1, _Tp2, _Rp...> 2338 : public __common_type_fold<common_type<_Tp1, _Tp2>, 2339 __common_type_pack<_Rp...>> 2340 { }; 2341 2342 // Let C denote the same type, if any, as common_type_t<T1, T2>. 2343 // If there is such a type C, type shall denote the same type, if any, 2344 // as common_type_t<C, R...>. 2345 template<typename _CTp, typename... _Rp> 2346 struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, 2347 __void_t<typename _CTp::type>> 2348 : public common_type<typename _CTp::type, _Rp...> 2349 { }; 2350 2351 // Otherwise, there shall be no member type. 2352 template<typename _CTp, typename _Rp> 2353 struct __common_type_fold<_CTp, _Rp, void> 2354 { }; 2355 2356 template<typename _Tp, bool = is_enum<_Tp>::value> 2357 struct __underlying_type_impl 2358 { 2359 using type = __underlying_type(_Tp); 2360 }; 2361 2362 template<typename _Tp> 2363 struct __underlying_type_impl<_Tp, false> 2364 { }; 2365 /// @endcond 2366 2367 /// The underlying type of an enum. 2368 template<typename _Tp> 2369 struct underlying_type 2370 : public __underlying_type_impl<_Tp> 2371 { }; 2372 2373 /// @cond undocumented 2374 template<typename _Tp> 2375 struct __declval_protector 2376 { 2377 static const bool __stop = false; 2378 }; 2379 /// @endcond 2380 2381 /** Utility to simplify expressions used in unevaluated operands 2382 * @since C++11 2383 * @ingroup utilities 2384 */ 2385 template<typename _Tp> 2386 auto declval() noexcept -> decltype(__declval<_Tp>(0)) 2387 { 2388 static_assert(__declval_protector<_Tp>::__stop, 2389 "declval() must not be used!"); 2390 return __declval<_Tp>(0); 2391 } 2392 2393 /// result_of 2394 template<typename _Signature> 2395 struct result_of; 2396 2397 // Sfinae-friendly result_of implementation: 2398 2399 #define __cpp_lib_result_of_sfinae 201210L 2400 2401 /// @cond undocumented 2402 struct __invoke_memfun_ref { }; 2403 struct __invoke_memfun_deref { }; 2404 struct __invoke_memobj_ref { }; 2405 struct __invoke_memobj_deref { }; 2406 struct __invoke_other { }; 2407 2408 // Associate a tag type with a specialization of __success_type. 2409 template<typename _Tp, typename _Tag> 2410 struct __result_of_success : __success_type<_Tp> 2411 { using __invoke_type = _Tag; }; 2412 2413 // [func.require] paragraph 1 bullet 1: 2414 struct __result_of_memfun_ref_impl 2415 { 2416 template<typename _Fp, typename _Tp1, typename... _Args> 2417 static __result_of_success<decltype( 2418 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...) 2419 ), __invoke_memfun_ref> _S_test(int); 2420 2421 template<typename...> 2422 static __failure_type _S_test(...); 2423 }; 2424 2425 template<typename _MemPtr, typename _Arg, typename... _Args> 2426 struct __result_of_memfun_ref 2427 : private __result_of_memfun_ref_impl 2428 { 2429 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; 2430 }; 2431 2432 // [func.require] paragraph 1 bullet 2: 2433 struct __result_of_memfun_deref_impl 2434 { 2435 template<typename _Fp, typename _Tp1, typename... _Args> 2436 static __result_of_success<decltype( 2437 ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...) 2438 ), __invoke_memfun_deref> _S_test(int); 2439 2440 template<typename...> 2441 static __failure_type _S_test(...); 2442 }; 2443 2444 template<typename _MemPtr, typename _Arg, typename... _Args> 2445 struct __result_of_memfun_deref 2446 : private __result_of_memfun_deref_impl 2447 { 2448 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; 2449 }; 2450 2451 // [func.require] paragraph 1 bullet 3: 2452 struct __result_of_memobj_ref_impl 2453 { 2454 template<typename _Fp, typename _Tp1> 2455 static __result_of_success<decltype( 2456 std::declval<_Tp1>().*std::declval<_Fp>() 2457 ), __invoke_memobj_ref> _S_test(int); 2458 2459 template<typename, typename> 2460 static __failure_type _S_test(...); 2461 }; 2462 2463 template<typename _MemPtr, typename _Arg> 2464 struct __result_of_memobj_ref 2465 : private __result_of_memobj_ref_impl 2466 { 2467 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; 2468 }; 2469 2470 // [func.require] paragraph 1 bullet 4: 2471 struct __result_of_memobj_deref_impl 2472 { 2473 template<typename _Fp, typename _Tp1> 2474 static __result_of_success<decltype( 2475 (*std::declval<_Tp1>()).*std::declval<_Fp>() 2476 ), __invoke_memobj_deref> _S_test(int); 2477 2478 template<typename, typename> 2479 static __failure_type _S_test(...); 2480 }; 2481 2482 template<typename _MemPtr, typename _Arg> 2483 struct __result_of_memobj_deref 2484 : private __result_of_memobj_deref_impl 2485 { 2486 typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; 2487 }; 2488 2489 template<typename _MemPtr, typename _Arg> 2490 struct __result_of_memobj; 2491 2492 template<typename _Res, typename _Class, typename _Arg> 2493 struct __result_of_memobj<_Res _Class::*, _Arg> 2494 { 2495 typedef __remove_cvref_t<_Arg> _Argval; 2496 typedef _Res _Class::* _MemPtr; 2497 typedef typename __conditional_t<__or_<is_same<_Argval, _Class>, 2498 is_base_of<_Class, _Argval>>::value, 2499 __result_of_memobj_ref<_MemPtr, _Arg>, 2500 __result_of_memobj_deref<_MemPtr, _Arg> 2501 >::type type; 2502 }; 2503 2504 template<typename _MemPtr, typename _Arg, typename... _Args> 2505 struct __result_of_memfun; 2506 2507 template<typename _Res, typename _Class, typename _Arg, typename... _Args> 2508 struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> 2509 { 2510 typedef typename remove_reference<_Arg>::type _Argval; 2511 typedef _Res _Class::* _MemPtr; 2512 typedef typename __conditional_t<is_base_of<_Class, _Argval>::value, 2513 __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, 2514 __result_of_memfun_deref<_MemPtr, _Arg, _Args...> 2515 >::type type; 2516 }; 2517 2518 // _GLIBCXX_RESOLVE_LIB_DEFECTS 2519 // 2219. INVOKE-ing a pointer to member with a reference_wrapper 2520 // as the object expression 2521 2522 // Used by result_of, invoke etc. to unwrap a reference_wrapper. 2523 template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>> 2524 struct __inv_unwrap 2525 { 2526 using type = _Tp; 2527 }; 2528 2529 template<typename _Tp, typename _Up> 2530 struct __inv_unwrap<_Tp, reference_wrapper<_Up>> 2531 { 2532 using type = _Up&; 2533 }; 2534 2535 template<bool, bool, typename _Functor, typename... _ArgTypes> 2536 struct __result_of_impl 2537 { 2538 typedef __failure_type type; 2539 }; 2540 2541 template<typename _MemPtr, typename _Arg> 2542 struct __result_of_impl<true, false, _MemPtr, _Arg> 2543 : public __result_of_memobj<__decay_t<_MemPtr>, 2544 typename __inv_unwrap<_Arg>::type> 2545 { }; 2546 2547 template<typename _MemPtr, typename _Arg, typename... _Args> 2548 struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...> 2549 : public __result_of_memfun<__decay_t<_MemPtr>, 2550 typename __inv_unwrap<_Arg>::type, _Args...> 2551 { }; 2552 2553 // [func.require] paragraph 1 bullet 5: 2554 struct __result_of_other_impl 2555 { 2556 template<typename _Fn, typename... _Args> 2557 static __result_of_success<decltype( 2558 std::declval<_Fn>()(std::declval<_Args>()...) 2559 ), __invoke_other> _S_test(int); 2560 2561 template<typename...> 2562 static __failure_type _S_test(...); 2563 }; 2564 2565 template<typename _Functor, typename... _ArgTypes> 2566 struct __result_of_impl<false, false, _Functor, _ArgTypes...> 2567 : private __result_of_other_impl 2568 { 2569 typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; 2570 }; 2571 2572 // __invoke_result (std::invoke_result for C++11) 2573 template<typename _Functor, typename... _ArgTypes> 2574 struct __invoke_result 2575 : public __result_of_impl< 2576 is_member_object_pointer< 2577 typename remove_reference<_Functor>::type 2578 >::value, 2579 is_member_function_pointer< 2580 typename remove_reference<_Functor>::type 2581 >::value, 2582 _Functor, _ArgTypes... 2583 >::type 2584 { }; 2585 /// @endcond 2586 2587 template<typename _Functor, typename... _ArgTypes> 2588 struct result_of<_Functor(_ArgTypes...)> 2589 : public __invoke_result<_Functor, _ArgTypes...> 2590 { } _GLIBCXX17_DEPRECATED_SUGGEST("std::invoke_result"); 2591 2592 #if __cplusplus >= 201402L 2593 #pragma GCC diagnostic push 2594 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 2595 /// Alias template for aligned_storage 2596 template<size_t _Len, size_t _Align = 2597 __alignof__(typename __aligned_storage_msa<_Len>::__type)> 2598 using aligned_storage_t _GLIBCXX23_DEPRECATED = typename aligned_storage<_Len, _Align>::type; 2599 2600 template <size_t _Len, typename... _Types> 2601 using aligned_union_t _GLIBCXX23_DEPRECATED = typename aligned_union<_Len, _Types...>::type; 2602 #pragma GCC diagnostic pop 2603 2604 /// Alias template for decay 2605 template<typename _Tp> 2606 using decay_t = typename decay<_Tp>::type; 2607 2608 /// Alias template for enable_if 2609 template<bool _Cond, typename _Tp = void> 2610 using enable_if_t = typename enable_if<_Cond, _Tp>::type; 2611 2612 /// Alias template for conditional 2613 template<bool _Cond, typename _Iftrue, typename _Iffalse> 2614 using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; 2615 2616 /// Alias template for common_type 2617 template<typename... _Tp> 2618 using common_type_t = typename common_type<_Tp...>::type; 2619 2620 /// Alias template for underlying_type 2621 template<typename _Tp> 2622 using underlying_type_t = typename underlying_type<_Tp>::type; 2623 2624 /// Alias template for result_of 2625 template<typename _Tp> 2626 using result_of_t = typename result_of<_Tp>::type; 2627 #endif // C++14 2628 2629 #if __cplusplus >= 201703L || !defined(__STRICT_ANSI__) // c++17 or gnu++11 2630 #define __cpp_lib_void_t 201411L 2631 /// A metafunction that always yields void, used for detecting valid types. 2632 template<typename...> using void_t = void; 2633 #endif 2634 2635 /// @cond undocumented 2636 2637 // Detection idiom. 2638 // Detect whether _Op<_Args...> is a valid type, use default _Def if not. 2639 2640 #if __cpp_concepts 2641 // Implementation of the detection idiom (negative case). 2642 template<typename _Def, template<typename...> class _Op, typename... _Args> 2643 struct __detected_or 2644 { 2645 using type = _Def; 2646 using __is_detected = false_type; 2647 }; 2648 2649 // Implementation of the detection idiom (positive case). 2650 template<typename _Def, template<typename...> class _Op, typename... _Args> 2651 requires requires { typename _Op<_Args...>; } 2652 struct __detected_or<_Def, _Op, _Args...> 2653 { 2654 using type = _Op<_Args...>; 2655 using __is_detected = true_type; 2656 }; 2657 #else 2658 /// Implementation of the detection idiom (negative case). 2659 template<typename _Default, typename _AlwaysVoid, 2660 template<typename...> class _Op, typename... _Args> 2661 struct __detector 2662 { 2663 using type = _Default; 2664 using __is_detected = false_type; 2665 }; 2666 2667 /// Implementation of the detection idiom (positive case). 2668 template<typename _Default, template<typename...> class _Op, 2669 typename... _Args> 2670 struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> 2671 { 2672 using type = _Op<_Args...>; 2673 using __is_detected = true_type; 2674 }; 2675 2676 template<typename _Default, template<typename...> class _Op, 2677 typename... _Args> 2678 using __detected_or = __detector<_Default, void, _Op, _Args...>; 2679 #endif // __cpp_concepts 2680 2681 // _Op<_Args...> if that is a valid type, otherwise _Default. 2682 template<typename _Default, template<typename...> class _Op, 2683 typename... _Args> 2684 using __detected_or_t 2685 = typename __detected_or<_Default, _Op, _Args...>::type; 2686 2687 /** 2688 * Use SFINAE to determine if the type _Tp has a publicly-accessible 2689 * member type _NTYPE. 2690 */ 2691 #define _GLIBCXX_HAS_NESTED_TYPE(_NTYPE) \ 2692 template<typename _Tp, typename = __void_t<>> \ 2693 struct __has_##_NTYPE \ 2694 : false_type \ 2695 { }; \ 2696 template<typename _Tp> \ 2697 struct __has_##_NTYPE<_Tp, __void_t<typename _Tp::_NTYPE>> \ 2698 : true_type \ 2699 { }; 2700 2701 template <typename _Tp> 2702 struct __is_swappable; 2703 2704 template <typename _Tp> 2705 struct __is_nothrow_swappable; 2706 2707 template<typename> 2708 struct __is_tuple_like_impl : false_type 2709 { }; 2710 2711 // Internal type trait that allows us to sfinae-protect tuple_cat. 2712 template<typename _Tp> 2713 struct __is_tuple_like 2714 : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type 2715 { }; 2716 /// @endcond 2717 2718 template<typename _Tp> 2719 _GLIBCXX20_CONSTEXPR 2720 inline 2721 _Require<__not_<__is_tuple_like<_Tp>>, 2722 is_move_constructible<_Tp>, 2723 is_move_assignable<_Tp>> 2724 swap(_Tp&, _Tp&) 2725 noexcept(__and_<is_nothrow_move_constructible<_Tp>, 2726 is_nothrow_move_assignable<_Tp>>::value); 2727 2728 template<typename _Tp, size_t _Nm> 2729 _GLIBCXX20_CONSTEXPR 2730 inline 2731 __enable_if_t<__is_swappable<_Tp>::value> 2732 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) 2733 noexcept(__is_nothrow_swappable<_Tp>::value); 2734 2735 /// @cond undocumented 2736 namespace __swappable_details { 2737 using std::swap; 2738 2739 struct __do_is_swappable_impl 2740 { 2741 template<typename _Tp, typename 2742 = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))> 2743 static true_type __test(int); 2744 2745 template<typename> 2746 static false_type __test(...); 2747 }; 2748 2749 struct __do_is_nothrow_swappable_impl 2750 { 2751 template<typename _Tp> 2752 static __bool_constant< 2753 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) 2754 > __test(int); 2755 2756 template<typename> 2757 static false_type __test(...); 2758 }; 2759 2760 } // namespace __swappable_details 2761 2762 template<typename _Tp> 2763 struct __is_swappable_impl 2764 : public __swappable_details::__do_is_swappable_impl 2765 { 2766 typedef decltype(__test<_Tp>(0)) type; 2767 }; 2768 2769 template<typename _Tp> 2770 struct __is_nothrow_swappable_impl 2771 : public __swappable_details::__do_is_nothrow_swappable_impl 2772 { 2773 typedef decltype(__test<_Tp>(0)) type; 2774 }; 2775 2776 template<typename _Tp> 2777 struct __is_swappable 2778 : public __is_swappable_impl<_Tp>::type 2779 { }; 2780 2781 template<typename _Tp> 2782 struct __is_nothrow_swappable 2783 : public __is_nothrow_swappable_impl<_Tp>::type 2784 { }; 2785 /// @endcond 2786 2787 #if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11 2788 #define __cpp_lib_is_swappable 201603L 2789 /// Metafunctions used for detecting swappable types: p0185r1 2790 2791 /// is_swappable 2792 template<typename _Tp> 2793 struct is_swappable 2794 : public __is_swappable_impl<_Tp>::type 2795 { 2796 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 2797 "template argument must be a complete class or an unbounded array"); 2798 }; 2799 2800 /// is_nothrow_swappable 2801 template<typename _Tp> 2802 struct is_nothrow_swappable 2803 : public __is_nothrow_swappable_impl<_Tp>::type 2804 { 2805 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 2806 "template argument must be a complete class or an unbounded array"); 2807 }; 2808 2809 #if __cplusplus >= 201402L 2810 /// is_swappable_v 2811 template<typename _Tp> 2812 _GLIBCXX17_INLINE constexpr bool is_swappable_v = 2813 is_swappable<_Tp>::value; 2814 2815 /// is_nothrow_swappable_v 2816 template<typename _Tp> 2817 _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_v = 2818 is_nothrow_swappable<_Tp>::value; 2819 #endif // __cplusplus >= 201402L 2820 2821 /// @cond undocumented 2822 namespace __swappable_with_details { 2823 using std::swap; 2824 2825 struct __do_is_swappable_with_impl 2826 { 2827 template<typename _Tp, typename _Up, typename 2828 = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())), 2829 typename 2830 = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> 2831 static true_type __test(int); 2832 2833 template<typename, typename> 2834 static false_type __test(...); 2835 }; 2836 2837 struct __do_is_nothrow_swappable_with_impl 2838 { 2839 template<typename _Tp, typename _Up> 2840 static __bool_constant< 2841 noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) 2842 && 2843 noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) 2844 > __test(int); 2845 2846 template<typename, typename> 2847 static false_type __test(...); 2848 }; 2849 2850 } // namespace __swappable_with_details 2851 2852 template<typename _Tp, typename _Up> 2853 struct __is_swappable_with_impl 2854 : public __swappable_with_details::__do_is_swappable_with_impl 2855 { 2856 typedef decltype(__test<_Tp, _Up>(0)) type; 2857 }; 2858 2859 // Optimization for the homogenous lvalue case, not required: 2860 template<typename _Tp> 2861 struct __is_swappable_with_impl<_Tp&, _Tp&> 2862 : public __swappable_details::__do_is_swappable_impl 2863 { 2864 typedef decltype(__test<_Tp&>(0)) type; 2865 }; 2866 2867 template<typename _Tp, typename _Up> 2868 struct __is_nothrow_swappable_with_impl 2869 : public __swappable_with_details::__do_is_nothrow_swappable_with_impl 2870 { 2871 typedef decltype(__test<_Tp, _Up>(0)) type; 2872 }; 2873 2874 // Optimization for the homogenous lvalue case, not required: 2875 template<typename _Tp> 2876 struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> 2877 : public __swappable_details::__do_is_nothrow_swappable_impl 2878 { 2879 typedef decltype(__test<_Tp&>(0)) type; 2880 }; 2881 /// @endcond 2882 2883 /// is_swappable_with 2884 template<typename _Tp, typename _Up> 2885 struct is_swappable_with 2886 : public __is_swappable_with_impl<_Tp, _Up>::type 2887 { 2888 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 2889 "first template argument must be a complete class or an unbounded array"); 2890 static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), 2891 "second template argument must be a complete class or an unbounded array"); 2892 }; 2893 2894 /// is_nothrow_swappable_with 2895 template<typename _Tp, typename _Up> 2896 struct is_nothrow_swappable_with 2897 : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type 2898 { 2899 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 2900 "first template argument must be a complete class or an unbounded array"); 2901 static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), 2902 "second template argument must be a complete class or an unbounded array"); 2903 }; 2904 2905 #if __cplusplus >= 201402L 2906 /// is_swappable_with_v 2907 template<typename _Tp, typename _Up> 2908 _GLIBCXX17_INLINE constexpr bool is_swappable_with_v = 2909 is_swappable_with<_Tp, _Up>::value; 2910 2911 /// is_nothrow_swappable_with_v 2912 template<typename _Tp, typename _Up> 2913 _GLIBCXX17_INLINE constexpr bool is_nothrow_swappable_with_v = 2914 is_nothrow_swappable_with<_Tp, _Up>::value; 2915 #endif // __cplusplus >= 201402L 2916 2917 #endif// c++1z or gnu++11 2918 2919 /// @cond undocumented 2920 2921 // __is_invocable (std::is_invocable for C++11) 2922 2923 // The primary template is used for invalid INVOKE expressions. 2924 template<typename _Result, typename _Ret, 2925 bool = is_void<_Ret>::value, typename = void> 2926 struct __is_invocable_impl 2927 : false_type 2928 { 2929 using __nothrow_conv = false_type; // For is_nothrow_invocable_r 2930 }; 2931 2932 // Used for valid INVOKE and INVOKE<void> expressions. 2933 template<typename _Result, typename _Ret> 2934 struct __is_invocable_impl<_Result, _Ret, 2935 /* is_void<_Ret> = */ true, 2936 __void_t<typename _Result::type>> 2937 : true_type 2938 { 2939 using __nothrow_conv = true_type; // For is_nothrow_invocable_r 2940 }; 2941 2942 #pragma GCC diagnostic push 2943 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" 2944 // Used for INVOKE<R> expressions to check the implicit conversion to R. 2945 template<typename _Result, typename _Ret> 2946 struct __is_invocable_impl<_Result, _Ret, 2947 /* is_void<_Ret> = */ false, 2948 __void_t<typename _Result::type>> 2949 { 2950 private: 2951 // The type of the INVOKE expression. 2952 using _Res_t = typename _Result::type; 2953 2954 // Unlike declval, this doesn't add_rvalue_reference, so it respects 2955 // guaranteed copy elision. 2956 static _Res_t _S_get() noexcept; 2957 2958 // Used to check if _Res_t can implicitly convert to _Tp. 2959 template<typename _Tp> 2960 static void _S_conv(__type_identity_t<_Tp>) noexcept; 2961 2962 // This overload is viable if INVOKE(f, args...) can convert to _Tp. 2963 template<typename _Tp, 2964 bool _Nothrow = noexcept(_S_conv<_Tp>(_S_get())), 2965 typename = decltype(_S_conv<_Tp>(_S_get())), 2966 #if __has_builtin(__reference_converts_from_temporary) 2967 bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t) 2968 #else 2969 bool _Dangle = false 2970 #endif 2971 > 2972 static __bool_constant<_Nothrow && !_Dangle> 2973 _S_test(int); 2974 2975 template<typename _Tp, bool = false> 2976 static false_type 2977 _S_test(...); 2978 2979 public: 2980 // For is_invocable_r 2981 using type = decltype(_S_test<_Ret, /* Nothrow = */ true>(1)); 2982 2983 // For is_nothrow_invocable_r 2984 using __nothrow_conv = decltype(_S_test<_Ret>(1)); 2985 }; 2986 #pragma GCC diagnostic pop 2987 2988 template<typename _Fn, typename... _ArgTypes> 2989 struct __is_invocable 2990 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type 2991 { }; 2992 2993 template<typename _Fn, typename _Tp, typename... _Args> 2994 constexpr bool __call_is_nt(__invoke_memfun_ref) 2995 { 2996 using _Up = typename __inv_unwrap<_Tp>::type; 2997 return noexcept((std::declval<_Up>().*std::declval<_Fn>())( 2998 std::declval<_Args>()...)); 2999 } 3000 3001 template<typename _Fn, typename _Tp, typename... _Args> 3002 constexpr bool __call_is_nt(__invoke_memfun_deref) 3003 { 3004 return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( 3005 std::declval<_Args>()...)); 3006 } 3007 3008 template<typename _Fn, typename _Tp> 3009 constexpr bool __call_is_nt(__invoke_memobj_ref) 3010 { 3011 using _Up = typename __inv_unwrap<_Tp>::type; 3012 return noexcept(std::declval<_Up>().*std::declval<_Fn>()); 3013 } 3014 3015 template<typename _Fn, typename _Tp> 3016 constexpr bool __call_is_nt(__invoke_memobj_deref) 3017 { 3018 return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); 3019 } 3020 3021 template<typename _Fn, typename... _Args> 3022 constexpr bool __call_is_nt(__invoke_other) 3023 { 3024 return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); 3025 } 3026 3027 template<typename _Result, typename _Fn, typename... _Args> 3028 struct __call_is_nothrow 3029 : __bool_constant< 3030 std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) 3031 > 3032 { }; 3033 3034 template<typename _Fn, typename... _Args> 3035 using __call_is_nothrow_ 3036 = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; 3037 3038 // __is_nothrow_invocable (std::is_nothrow_invocable for C++11) 3039 template<typename _Fn, typename... _Args> 3040 struct __is_nothrow_invocable 3041 : __and_<__is_invocable<_Fn, _Args...>, 3042 __call_is_nothrow_<_Fn, _Args...>>::type 3043 { }; 3044 3045 #pragma GCC diagnostic push 3046 #pragma GCC diagnostic ignored "-Wctor-dtor-privacy" 3047 struct __nonesuchbase {}; 3048 struct __nonesuch : private __nonesuchbase { 3049 ~__nonesuch() = delete; 3050 __nonesuch(__nonesuch const&) = delete; 3051 void operator=(__nonesuch const&) = delete; 3052 }; 3053 #pragma GCC diagnostic pop 3054 /// @endcond 3055 3056 #if __cplusplus >= 201703L 3057 # define __cpp_lib_is_invocable 201703L 3058 3059 /// std::invoke_result 3060 template<typename _Functor, typename... _ArgTypes> 3061 struct invoke_result 3062 : public __invoke_result<_Functor, _ArgTypes...> 3063 { 3064 static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), 3065 "_Functor must be a complete class or an unbounded array"); 3066 static_assert((std::__is_complete_or_unbounded( 3067 __type_identity<_ArgTypes>{}) && ...), 3068 "each argument type must be a complete class or an unbounded array"); 3069 }; 3070 3071 /// std::invoke_result_t 3072 template<typename _Fn, typename... _Args> 3073 using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; 3074 3075 /// std::is_invocable 3076 template<typename _Fn, typename... _ArgTypes> 3077 struct is_invocable 3078 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type 3079 { 3080 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), 3081 "_Fn must be a complete class or an unbounded array"); 3082 static_assert((std::__is_complete_or_unbounded( 3083 __type_identity<_ArgTypes>{}) && ...), 3084 "each argument type must be a complete class or an unbounded array"); 3085 }; 3086 3087 /// std::is_invocable_r 3088 template<typename _Ret, typename _Fn, typename... _ArgTypes> 3089 struct is_invocable_r 3090 : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type 3091 { 3092 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), 3093 "_Fn must be a complete class or an unbounded array"); 3094 static_assert((std::__is_complete_or_unbounded( 3095 __type_identity<_ArgTypes>{}) && ...), 3096 "each argument type must be a complete class or an unbounded array"); 3097 static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), 3098 "_Ret must be a complete class or an unbounded array"); 3099 }; 3100 3101 /// std::is_nothrow_invocable 3102 template<typename _Fn, typename... _ArgTypes> 3103 struct is_nothrow_invocable 3104 : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, 3105 __call_is_nothrow_<_Fn, _ArgTypes...>>::type 3106 { 3107 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), 3108 "_Fn must be a complete class or an unbounded array"); 3109 static_assert((std::__is_complete_or_unbounded( 3110 __type_identity<_ArgTypes>{}) && ...), 3111 "each argument type must be a complete class or an unbounded array"); 3112 }; 3113 3114 /// @cond undocumented 3115 // This checks that the INVOKE<R> expression is well-formed and that the 3116 // conversion to R does not throw. It does *not* check whether the INVOKE 3117 // expression itself can throw. That is done by __call_is_nothrow_ instead. 3118 template<typename _Result, typename _Ret> 3119 using __is_nt_invocable_impl 3120 = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; 3121 /// @endcond 3122 3123 /// std::is_nothrow_invocable_r 3124 template<typename _Ret, typename _Fn, typename... _ArgTypes> 3125 struct is_nothrow_invocable_r 3126 : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, 3127 __call_is_nothrow_<_Fn, _ArgTypes...>>::type 3128 { 3129 static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), 3130 "_Fn must be a complete class or an unbounded array"); 3131 static_assert((std::__is_complete_or_unbounded( 3132 __type_identity<_ArgTypes>{}) && ...), 3133 "each argument type must be a complete class or an unbounded array"); 3134 static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), 3135 "_Ret must be a complete class or an unbounded array"); 3136 }; 3137 #endif // C++17 3138 3139 #if __cplusplus >= 201703L 3140 # define __cpp_lib_type_trait_variable_templates 201510L 3141 /** 3142 * @defgroup variable_templates Variable templates for type traits 3143 * @ingroup metaprogramming 3144 * 3145 * Each variable `is_xxx_v<T>` is a boolean constant with the same value 3146 * as the `value` member of the corresponding type trait `is_xxx<T>`. 3147 * 3148 * @since C++17 unless noted otherwise. 3149 */ 3150 3151 /** 3152 * @{ 3153 * @ingroup variable_templates 3154 */ 3155 template <typename _Tp> 3156 inline constexpr bool is_void_v = is_void<_Tp>::value; 3157 template <typename _Tp> 3158 inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; 3159 template <typename _Tp> 3160 inline constexpr bool is_integral_v = is_integral<_Tp>::value; 3161 template <typename _Tp> 3162 inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; 3163 3164 template <typename _Tp> 3165 inline constexpr bool is_array_v = false; 3166 template <typename _Tp> 3167 inline constexpr bool is_array_v<_Tp[]> = true; 3168 template <typename _Tp, size_t _Num> 3169 inline constexpr bool is_array_v<_Tp[_Num]> = true; 3170 3171 template <typename _Tp> 3172 inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; 3173 template <typename _Tp> 3174 inline constexpr bool is_lvalue_reference_v = false; 3175 template <typename _Tp> 3176 inline constexpr bool is_lvalue_reference_v<_Tp&> = true; 3177 template <typename _Tp> 3178 inline constexpr bool is_rvalue_reference_v = false; 3179 template <typename _Tp> 3180 inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; 3181 template <typename _Tp> 3182 inline constexpr bool is_member_object_pointer_v = 3183 is_member_object_pointer<_Tp>::value; 3184 template <typename _Tp> 3185 inline constexpr bool is_member_function_pointer_v = 3186 is_member_function_pointer<_Tp>::value; 3187 template <typename _Tp> 3188 inline constexpr bool is_enum_v = __is_enum(_Tp); 3189 template <typename _Tp> 3190 inline constexpr bool is_union_v = __is_union(_Tp); 3191 template <typename _Tp> 3192 inline constexpr bool is_class_v = __is_class(_Tp); 3193 template <typename _Tp> 3194 inline constexpr bool is_function_v = is_function<_Tp>::value; 3195 template <typename _Tp> 3196 inline constexpr bool is_reference_v = false; 3197 template <typename _Tp> 3198 inline constexpr bool is_reference_v<_Tp&> = true; 3199 template <typename _Tp> 3200 inline constexpr bool is_reference_v<_Tp&&> = true; 3201 template <typename _Tp> 3202 inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; 3203 template <typename _Tp> 3204 inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; 3205 template <typename _Tp> 3206 inline constexpr bool is_object_v = is_object<_Tp>::value; 3207 template <typename _Tp> 3208 inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; 3209 template <typename _Tp> 3210 inline constexpr bool is_compound_v = is_compound<_Tp>::value; 3211 template <typename _Tp> 3212 inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; 3213 template <typename _Tp> 3214 inline constexpr bool is_const_v = false; 3215 template <typename _Tp> 3216 inline constexpr bool is_const_v<const _Tp> = true; 3217 template <typename _Tp> 3218 inline constexpr bool is_volatile_v = false; 3219 template <typename _Tp> 3220 inline constexpr bool is_volatile_v<volatile _Tp> = true; 3221 3222 template <typename _Tp> 3223 inline constexpr bool is_trivial_v = __is_trivial(_Tp); 3224 template <typename _Tp> 3225 inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); 3226 template <typename _Tp> 3227 inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); 3228 template <typename _Tp> 3229 _GLIBCXX20_DEPRECATED_SUGGEST("is_standard_layout_v && is_trivial_v") 3230 inline constexpr bool is_pod_v = __is_pod(_Tp); 3231 template <typename _Tp> 3232 _GLIBCXX17_DEPRECATED 3233 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); 3234 template <typename _Tp> 3235 inline constexpr bool is_empty_v = __is_empty(_Tp); 3236 template <typename _Tp> 3237 inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); 3238 template <typename _Tp> 3239 inline constexpr bool is_abstract_v = __is_abstract(_Tp); 3240 template <typename _Tp> 3241 inline constexpr bool is_final_v = __is_final(_Tp); 3242 3243 template <typename _Tp> 3244 inline constexpr bool is_signed_v = is_signed<_Tp>::value; 3245 template <typename _Tp> 3246 inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; 3247 3248 template <typename _Tp, typename... _Args> 3249 inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); 3250 template <typename _Tp> 3251 inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); 3252 template <typename _Tp> 3253 inline constexpr bool is_copy_constructible_v 3254 = __is_constructible(_Tp, __add_lval_ref_t<const _Tp>); 3255 template <typename _Tp> 3256 inline constexpr bool is_move_constructible_v 3257 = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); 3258 3259 template <typename _Tp, typename _Up> 3260 inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); 3261 template <typename _Tp> 3262 inline constexpr bool is_copy_assignable_v 3263 = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t<const _Tp>); 3264 template <typename _Tp> 3265 inline constexpr bool is_move_assignable_v 3266 = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); 3267 3268 template <typename _Tp> 3269 inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; 3270 3271 template <typename _Tp, typename... _Args> 3272 inline constexpr bool is_trivially_constructible_v 3273 = __is_trivially_constructible(_Tp, _Args...); 3274 template <typename _Tp> 3275 inline constexpr bool is_trivially_default_constructible_v 3276 = __is_trivially_constructible(_Tp); 3277 template <typename _Tp> 3278 inline constexpr bool is_trivially_copy_constructible_v 3279 = __is_trivially_constructible(_Tp, __add_lval_ref_t<const _Tp>); 3280 template <typename _Tp> 3281 inline constexpr bool is_trivially_move_constructible_v 3282 = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); 3283 3284 template <typename _Tp, typename _Up> 3285 inline constexpr bool is_trivially_assignable_v 3286 = __is_trivially_assignable(_Tp, _Up); 3287 template <typename _Tp> 3288 inline constexpr bool is_trivially_copy_assignable_v 3289 = __is_trivially_assignable(__add_lval_ref_t<_Tp>, 3290 __add_lval_ref_t<const _Tp>); 3291 template <typename _Tp> 3292 inline constexpr bool is_trivially_move_assignable_v 3293 = __is_trivially_assignable(__add_lval_ref_t<_Tp>, 3294 __add_rval_ref_t<_Tp>); 3295 template <typename _Tp> 3296 inline constexpr bool is_trivially_destructible_v = 3297 is_trivially_destructible<_Tp>::value; 3298 template <typename _Tp, typename... _Args> 3299 inline constexpr bool is_nothrow_constructible_v 3300 = __is_nothrow_constructible(_Tp, _Args...); 3301 template <typename _Tp> 3302 inline constexpr bool is_nothrow_default_constructible_v 3303 = __is_nothrow_constructible(_Tp); 3304 template <typename _Tp> 3305 inline constexpr bool is_nothrow_copy_constructible_v 3306 = __is_nothrow_constructible(_Tp, __add_lval_ref_t<const _Tp>); 3307 template <typename _Tp> 3308 inline constexpr bool is_nothrow_move_constructible_v 3309 = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); 3310 3311 template <typename _Tp, typename _Up> 3312 inline constexpr bool is_nothrow_assignable_v 3313 = __is_nothrow_assignable(_Tp, _Up); 3314 template <typename _Tp> 3315 inline constexpr bool is_nothrow_copy_assignable_v 3316 = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, 3317 __add_lval_ref_t<const _Tp>); 3318 template <typename _Tp> 3319 inline constexpr bool is_nothrow_move_assignable_v 3320 = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); 3321 3322 template <typename _Tp> 3323 inline constexpr bool is_nothrow_destructible_v = 3324 is_nothrow_destructible<_Tp>::value; 3325 3326 template <typename _Tp> 3327 inline constexpr bool has_virtual_destructor_v 3328 = __has_virtual_destructor(_Tp); 3329 3330 template <typename _Tp> 3331 inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; 3332 3333 template <typename _Tp> 3334 inline constexpr size_t rank_v = 0; 3335 template <typename _Tp, size_t _Size> 3336 inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; 3337 template <typename _Tp> 3338 inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; 3339 3340 template <typename _Tp, unsigned _Idx = 0> 3341 inline constexpr size_t extent_v = 0; 3342 template <typename _Tp, size_t _Size> 3343 inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; 3344 template <typename _Tp, unsigned _Idx, size_t _Size> 3345 inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; 3346 template <typename _Tp> 3347 inline constexpr size_t extent_v<_Tp[], 0> = 0; 3348 template <typename _Tp, unsigned _Idx> 3349 inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; 3350 3351 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_SAME 3352 template <typename _Tp, typename _Up> 3353 inline constexpr bool is_same_v = __is_same(_Tp, _Up); 3354 #else 3355 template <typename _Tp, typename _Up> 3356 inline constexpr bool is_same_v = false; 3357 template <typename _Tp> 3358 inline constexpr bool is_same_v<_Tp, _Tp> = true; 3359 #endif 3360 template <typename _Base, typename _Derived> 3361 inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); 3362 #if __has_builtin(__is_convertible) 3363 template <typename _From, typename _To> 3364 inline constexpr bool is_convertible_v = __is_convertible(_From, _To); 3365 #else 3366 template <typename _From, typename _To> 3367 inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value; 3368 #endif 3369 template<typename _Fn, typename... _Args> 3370 inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; 3371 template<typename _Fn, typename... _Args> 3372 inline constexpr bool is_nothrow_invocable_v 3373 = is_nothrow_invocable<_Fn, _Args...>::value; 3374 template<typename _Ret, typename _Fn, typename... _Args> 3375 inline constexpr bool is_invocable_r_v 3376 = is_invocable_r<_Ret, _Fn, _Args...>::value; 3377 template<typename _Ret, typename _Fn, typename... _Args> 3378 inline constexpr bool is_nothrow_invocable_r_v 3379 = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; 3380 /// @} 3381 3382 #ifdef _GLIBCXX_HAVE_BUILTIN_HAS_UNIQ_OBJ_REP 3383 # define __cpp_lib_has_unique_object_representations 201606L 3384 /// has_unique_object_representations 3385 /// @since C++17 3386 template<typename _Tp> 3387 struct has_unique_object_representations 3388 : bool_constant<__has_unique_object_representations( 3389 remove_cv_t<remove_all_extents_t<_Tp>> 3390 )> 3391 { 3392 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), 3393 "template argument must be a complete class or an unbounded array"); 3394 }; 3395 3396 /// @ingroup variable_templates 3397 template<typename _Tp> 3398 inline constexpr bool has_unique_object_representations_v 3399 = has_unique_object_representations<_Tp>::value; 3400 #endif 3401 3402 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_AGGREGATE 3403 # define __cpp_lib_is_aggregate 201703L 3404 /// is_aggregate - true if the type is an aggregate. 3405 /// @since C++17 3406 template<typename _Tp> 3407 struct is_aggregate 3408 : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> 3409 { }; 3410 3411 /** is_aggregate_v - true if the type is an aggregate. 3412 * @ingroup variable_templates 3413 * @since C++17 3414 */ 3415 template<typename _Tp> 3416 inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); 3417 #endif 3418 #endif // C++17 3419 3420 #if __cplusplus >= 202002L 3421 3422 /** * Remove references and cv-qualifiers. 3423 * @since C++20 3424 * @{ 3425 */ 3426 #define __cpp_lib_remove_cvref 201711L 3427 3428 #if __has_builtin(__remove_cvref) 3429 template<typename _Tp> 3430 struct remove_cvref 3431 { using type = __remove_cvref(_Tp); }; 3432 #else 3433 template<typename _Tp> 3434 struct remove_cvref 3435 { using type = typename remove_cv<_Tp>::type; }; 3436 3437 template<typename _Tp> 3438 struct remove_cvref<_Tp&> 3439 { using type = typename remove_cv<_Tp>::type; }; 3440 3441 template<typename _Tp> 3442 struct remove_cvref<_Tp&&> 3443 { using type = typename remove_cv<_Tp>::type; }; 3444 #endif 3445 3446 template<typename _Tp> 3447 using remove_cvref_t = typename remove_cvref<_Tp>::type; 3448 /// @} 3449 3450 /** * Identity metafunction. 3451 * @since C++20 3452 * @{ 3453 */ 3454 #define __cpp_lib_type_identity 201806L 3455 template<typename _Tp> 3456 struct type_identity { using type = _Tp; }; 3457 3458 template<typename _Tp> 3459 using type_identity_t = typename type_identity<_Tp>::type; 3460 /// @} 3461 3462 #define __cpp_lib_unwrap_ref 201811L 3463 3464 /** Unwrap a reference_wrapper 3465 * @since C++20 3466 * @{ 3467 */ 3468 template<typename _Tp> 3469 struct unwrap_reference { using type = _Tp; }; 3470 3471 template<typename _Tp> 3472 struct unwrap_reference<reference_wrapper<_Tp>> { using type = _Tp&; }; 3473 3474 template<typename _Tp> 3475 using unwrap_reference_t = typename unwrap_reference<_Tp>::type; 3476 /// @} 3477 3478 /** Decay type and if it's a reference_wrapper, unwrap it 3479 * @since C++20 3480 * @{ 3481 */ 3482 template<typename _Tp> 3483 struct unwrap_ref_decay { using type = unwrap_reference_t<decay_t<_Tp>>; }; 3484 3485 template<typename _Tp> 3486 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type; 3487 /// @} 3488 3489 #define __cpp_lib_bounded_array_traits 201902L 3490 3491 /// True for a type that is an array of known bound. 3492 /// @ingroup variable_templates 3493 /// @since C++20 3494 template<typename _Tp> 3495 inline constexpr bool is_bounded_array_v = false; 3496 3497 template<typename _Tp, size_t _Size> 3498 inline constexpr bool is_bounded_array_v<_Tp[_Size]> = true; 3499 3500 /// True for a type that is an array of unknown bound. 3501 /// @ingroup variable_templates 3502 /// @since C++20 3503 template<typename _Tp> 3504 inline constexpr bool is_unbounded_array_v = false; 3505 3506 template<typename _Tp> 3507 inline constexpr bool is_unbounded_array_v<_Tp[]> = true; 3508 3509 /// True for a type that is an array of known bound. 3510 /// @since C++20 3511 template<typename _Tp> 3512 struct is_bounded_array 3513 : public bool_constant<is_bounded_array_v<_Tp>> 3514 { }; 3515 3516 /// True for a type that is an array of unknown bound. 3517 /// @since C++20 3518 template<typename _Tp> 3519 struct is_unbounded_array 3520 : public bool_constant<is_unbounded_array_v<_Tp>> 3521 { }; 3522 3523 #if __has_builtin(__is_layout_compatible) 3524 3525 /// @since C++20 3526 template<typename _Tp, typename _Up> 3527 struct is_layout_compatible 3528 : bool_constant<__is_layout_compatible(_Tp, _Up)> 3529 { }; 3530 3531 /// @ingroup variable_templates 3532 /// @since C++20 3533 template<typename _Tp, typename _Up> 3534 constexpr bool is_layout_compatible_v 3535 = __is_layout_compatible(_Tp, _Up); 3536 3537 #if __has_builtin(__builtin_is_corresponding_member) 3538 #define __cpp_lib_is_layout_compatible 201907L 3539 3540 /// @since C++20 3541 template<typename _S1, typename _S2, typename _M1, typename _M2> 3542 constexpr bool 3543 is_corresponding_member(_M1 _S1::*__m1, _M2 _S2::*__m2) noexcept 3544 { return __builtin_is_corresponding_member(__m1, __m2); } 3545 #endif 3546 #endif 3547 3548 #if __has_builtin(__is_pointer_interconvertible_base_of) 3549 /// True if `_Derived` is standard-layout and has a base class of type `_Base` 3550 /// @since C++20 3551 template<typename _Base, typename _Derived> 3552 struct is_pointer_interconvertible_base_of 3553 : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)> 3554 { }; 3555 3556 /// @ingroup variable_templates 3557 /// @since C++20 3558 template<typename _Base, typename _Derived> 3559 constexpr bool is_pointer_interconvertible_base_of_v 3560 = __is_pointer_interconvertible_base_of(_Base, _Derived); 3561 3562 #if __has_builtin(__builtin_is_pointer_interconvertible_with_class) 3563 #define __cpp_lib_is_pointer_interconvertible 201907L 3564 3565 /// True if `__mp` points to the first member of a standard-layout type 3566 /// @returns true if `s.*__mp` is pointer-interconvertible with `s` 3567 /// @since C++20 3568 template<typename _Tp, typename _Mem> 3569 constexpr bool 3570 is_pointer_interconvertible_with_class(_Mem _Tp::*__mp) noexcept 3571 { return __builtin_is_pointer_interconvertible_with_class(__mp); } 3572 #endif 3573 #endif 3574 3575 #if __cplusplus > 202002L 3576 #define __cpp_lib_is_scoped_enum 202011L 3577 3578 /// True if the type is a scoped enumeration type. 3579 /// @since C++23 3580 3581 template<typename _Tp> 3582 struct is_scoped_enum 3583 : false_type 3584 { }; 3585 3586 template<typename _Tp> 3587 requires __is_enum(_Tp) 3588 && requires(remove_cv_t<_Tp> __t) { __t = __t; } // fails if incomplete 3589 struct is_scoped_enum<_Tp> 3590 : bool_constant<!requires(_Tp __t, void(*__f)(int)) { __f(__t); }> 3591 { }; 3592 3593 /// @ingroup variable_templates 3594 /// @since C++23 3595 template<typename _Tp> 3596 inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value; 3597 3598 #if __has_builtin(__reference_constructs_from_temporary) \ 3599 && __has_builtin(__reference_converts_from_temporary) 3600 3601 #define __cpp_lib_reference_from_temporary 202202L 3602 3603 /// True if _Tp is a reference type, a _Up value can be bound to _Tp in 3604 /// direct-initialization, and a temporary object would be bound to 3605 /// the reference, false otherwise. 3606 /// @since C++23 3607 template<typename _Tp, typename _Up> 3608 struct reference_constructs_from_temporary 3609 : public bool_constant<__reference_constructs_from_temporary(_Tp, _Up)> 3610 { 3611 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}) 3612 && std::__is_complete_or_unbounded(__type_identity<_Up>{}), 3613 "template argument must be a complete class or an unbounded array"); 3614 }; 3615 3616 /// True if _Tp is a reference type, a _Up value can be bound to _Tp in 3617 /// copy-initialization, and a temporary object would be bound to 3618 /// the reference, false otherwise. 3619 /// @since C++23 3620 template<typename _Tp, typename _Up> 3621 struct reference_converts_from_temporary 3622 : public bool_constant<__reference_converts_from_temporary(_Tp, _Up)> 3623 { 3624 static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}) 3625 && std::__is_complete_or_unbounded(__type_identity<_Up>{}), 3626 "template argument must be a complete class or an unbounded array"); 3627 }; 3628 3629 /// @ingroup variable_templates 3630 /// @since C++23 3631 template<typename _Tp, typename _Up> 3632 inline constexpr bool reference_constructs_from_temporary_v 3633 = reference_constructs_from_temporary<_Tp, _Up>::value; 3634 3635 /// @ingroup variable_templates 3636 /// @since C++23 3637 template<typename _Tp, typename _Up> 3638 inline constexpr bool reference_converts_from_temporary_v 3639 = reference_converts_from_temporary<_Tp, _Up>::value; 3640 #endif // __has_builtin for reference_from_temporary 3641 #endif // C++23 3642 3643 #if _GLIBCXX_HAVE_IS_CONSTANT_EVALUATED 3644 #define __cpp_lib_is_constant_evaluated 201811L 3645 3646 /// Returns true only when called during constant evaluation. 3647 /// @since C++20 3648 constexpr inline bool 3649 is_constant_evaluated() noexcept 3650 { 3651 #if __cpp_if_consteval >= 202106L 3652 if consteval { return true; } else { return false; } 3653 #else 3654 return __builtin_is_constant_evaluated(); 3655 #endif 3656 } 3657 #endif 3658 3659 /// @cond undocumented 3660 template<typename _From, typename _To> 3661 using __copy_cv = typename __match_cv_qualifiers<_From, _To>::__type; 3662 3663 template<typename _Xp, typename _Yp> 3664 using __cond_res 3665 = decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()()); 3666 3667 template<typename _Ap, typename _Bp, typename = void> 3668 struct __common_ref_impl 3669 { }; 3670 3671 // [meta.trans.other], COMMON-REF(A, B) 3672 template<typename _Ap, typename _Bp> 3673 using __common_ref = typename __common_ref_impl<_Ap, _Bp>::type; 3674 3675 // COND-RES(COPYCV(X, Y) &, COPYCV(Y, X) &) 3676 template<typename _Xp, typename _Yp> 3677 using __condres_cvref 3678 = __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>; 3679 3680 // If A and B are both lvalue reference types, ... 3681 template<typename _Xp, typename _Yp> 3682 struct __common_ref_impl<_Xp&, _Yp&, __void_t<__condres_cvref<_Xp, _Yp>>> 3683 : enable_if<is_reference_v<__condres_cvref<_Xp, _Yp>>, 3684 __condres_cvref<_Xp, _Yp>> 3685 { }; 3686 3687 // let C be remove_reference_t<COMMON-REF(X&, Y&)>&& 3688 template<typename _Xp, typename _Yp> 3689 using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&; 3690 3691 // If A and B are both rvalue reference types, ... 3692 template<typename _Xp, typename _Yp> 3693 struct __common_ref_impl<_Xp&&, _Yp&&, 3694 _Require<is_convertible<_Xp&&, __common_ref_C<_Xp, _Yp>>, 3695 is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>> 3696 { using type = __common_ref_C<_Xp, _Yp>; }; 3697 3698 // let D be COMMON-REF(const X&, Y&) 3699 template<typename _Xp, typename _Yp> 3700 using __common_ref_D = __common_ref<const _Xp&, _Yp&>; 3701 3702 // If A is an rvalue reference and B is an lvalue reference, ... 3703 template<typename _Xp, typename _Yp> 3704 struct __common_ref_impl<_Xp&&, _Yp&, 3705 _Require<is_convertible<_Xp&&, __common_ref_D<_Xp, _Yp>>>> 3706 { using type = __common_ref_D<_Xp, _Yp>; }; 3707 3708 // If A is an lvalue reference and B is an rvalue reference, ... 3709 template<typename _Xp, typename _Yp> 3710 struct __common_ref_impl<_Xp&, _Yp&&> 3711 : __common_ref_impl<_Yp&&, _Xp&> 3712 { }; 3713 /// @endcond 3714 3715 template<typename _Tp, typename _Up, 3716 template<typename> class _TQual, template<typename> class _UQual> 3717 struct basic_common_reference 3718 { }; 3719 3720 /// @cond undocumented 3721 template<typename _Tp> 3722 struct __xref 3723 { template<typename _Up> using __type = __copy_cv<_Tp, _Up>; }; 3724 3725 template<typename _Tp> 3726 struct __xref<_Tp&> 3727 { template<typename _Up> using __type = __copy_cv<_Tp, _Up>&; }; 3728 3729 template<typename _Tp> 3730 struct __xref<_Tp&&> 3731 { template<typename _Up> using __type = __copy_cv<_Tp, _Up>&&; }; 3732 3733 template<typename _Tp1, typename _Tp2> 3734 using __basic_common_ref 3735 = typename basic_common_reference<remove_cvref_t<_Tp1>, 3736 remove_cvref_t<_Tp2>, 3737 __xref<_Tp1>::template __type, 3738 __xref<_Tp2>::template __type>::type; 3739 /// @endcond 3740 3741 template<typename... _Tp> 3742 struct common_reference; 3743 3744 template<typename... _Tp> 3745 using common_reference_t = typename common_reference<_Tp...>::type; 3746 3747 // If sizeof...(T) is zero, there shall be no member type. 3748 template<> 3749 struct common_reference<> 3750 { }; 3751 3752 // If sizeof...(T) is one ... 3753 template<typename _Tp0> 3754 struct common_reference<_Tp0> 3755 { using type = _Tp0; }; 3756 3757 /// @cond undocumented 3758 template<typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void> 3759 struct __common_reference_impl 3760 : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1> 3761 { }; 3762 3763 // If sizeof...(T) is two ... 3764 template<typename _Tp1, typename _Tp2> 3765 struct common_reference<_Tp1, _Tp2> 3766 : __common_reference_impl<_Tp1, _Tp2> 3767 { }; 3768 3769 // If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, ... 3770 template<typename _Tp1, typename _Tp2> 3771 struct __common_reference_impl<_Tp1&, _Tp2&, 1, 3772 void_t<__common_ref<_Tp1&, _Tp2&>>> 3773 { using type = __common_ref<_Tp1&, _Tp2&>; }; 3774 3775 template<typename _Tp1, typename _Tp2> 3776 struct __common_reference_impl<_Tp1&&, _Tp2&&, 1, 3777 void_t<__common_ref<_Tp1&&, _Tp2&&>>> 3778 { using type = __common_ref<_Tp1&&, _Tp2&&>; }; 3779 3780 template<typename _Tp1, typename _Tp2> 3781 struct __common_reference_impl<_Tp1&, _Tp2&&, 1, 3782 void_t<__common_ref<_Tp1&, _Tp2&&>>> 3783 { using type = __common_ref<_Tp1&, _Tp2&&>; }; 3784 3785 template<typename _Tp1, typename _Tp2> 3786 struct __common_reference_impl<_Tp1&&, _Tp2&, 1, 3787 void_t<__common_ref<_Tp1&&, _Tp2&>>> 3788 { using type = __common_ref<_Tp1&&, _Tp2&>; }; 3789 3790 // Otherwise, if basic_common_reference<...>::type is well-formed, ... 3791 template<typename _Tp1, typename _Tp2> 3792 struct __common_reference_impl<_Tp1, _Tp2, 2, 3793 void_t<__basic_common_ref<_Tp1, _Tp2>>> 3794 { using type = __basic_common_ref<_Tp1, _Tp2>; }; 3795 3796 // Otherwise, if COND-RES(T1, T2) is well-formed, ... 3797 template<typename _Tp1, typename _Tp2> 3798 struct __common_reference_impl<_Tp1, _Tp2, 3, 3799 void_t<__cond_res<_Tp1, _Tp2>>> 3800 { using type = __cond_res<_Tp1, _Tp2>; }; 3801 3802 // Otherwise, if common_type_t<T1, T2> is well-formed, ... 3803 template<typename _Tp1, typename _Tp2> 3804 struct __common_reference_impl<_Tp1, _Tp2, 4, 3805 void_t<common_type_t<_Tp1, _Tp2>>> 3806 { using type = common_type_t<_Tp1, _Tp2>; }; 3807 3808 // Otherwise, there shall be no member type. 3809 template<typename _Tp1, typename _Tp2> 3810 struct __common_reference_impl<_Tp1, _Tp2, 5, void> 3811 { }; 3812 3813 // Otherwise, if sizeof...(T) is greater than two, ... 3814 template<typename _Tp1, typename _Tp2, typename... _Rest> 3815 struct common_reference<_Tp1, _Tp2, _Rest...> 3816 : __common_type_fold<common_reference<_Tp1, _Tp2>, 3817 __common_type_pack<_Rest...>> 3818 { }; 3819 3820 // Reuse __common_type_fold for common_reference<T1, T2, Rest...> 3821 template<typename _Tp1, typename _Tp2, typename... _Rest> 3822 struct __common_type_fold<common_reference<_Tp1, _Tp2>, 3823 __common_type_pack<_Rest...>, 3824 void_t<common_reference_t<_Tp1, _Tp2>>> 3825 : public common_reference<common_reference_t<_Tp1, _Tp2>, _Rest...> 3826 { }; 3827 /// @endcond 3828 3829 #endif // C++2a 3830 3831 /// @} group metaprogramming 3832 3833 _GLIBCXX_END_NAMESPACE_VERSION 3834 } // namespace std 3835 3836 #endif // C++11 3837 3838 #endif // _GLIBCXX_TYPE_TRAITS
Contact us
|
About us
|
Term of use
|
Copyright © 2000-2025 MyWebUniversity.com ™
