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