Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/c++/15/bits/std.cc
1 // -*- C++ -*- [std.modules] module std 2 3 // Copyright The GNU Toolchain Authors. 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. 9 10 // This library is distributed in the hope that it will be useful, 11 // but WITHOUT ANY WARRANTY; without even the implied warranty of 12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 // GNU General Public License for more details. 14 15 // Under Section 7 of GPL version 3, you are granted additional 16 // permissions described in the GCC Runtime Library Exception, version 17 // 3.1, as published by the Free Software Foundation. 18 19 // You should have received a copy of the GNU General Public License and 20 // a copy of the GCC Runtime Library Exception along with this program; 21 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 22 // <http://www.gnu.org/licenses/>. 23 24 module; 25 26 // stdc++.h doesn't include <execution> because of TBB issues; 27 // FIXME for now let's avoid the problem by suppressing TBB. 28 #define _GLIBCXX_USE_TBB_PAR_BACKEND 0 29 30 #include <bits/stdc++.h> 31 #include <execution> 32 33 // Module std does include deprecated library interfaces. 34 #undef __DEPRECATED 35 #include <strstream> 36 37 export module std; 38 39 // C library exports are appended from std-clib.cc.in. 40 41 // 27.4 <algorithm> 42 export namespace std 43 { 44 namespace ranges 45 { 46 using std::ranges::in_found_result; 47 using std::ranges::in_fun_result; 48 using std::ranges::in_in_out_result; 49 using std::ranges::in_in_result; 50 using std::ranges::in_out_out_result; 51 using std::ranges::in_out_result; 52 using std::ranges::min_max_result; 53 } 54 using std::all_of; 55 namespace ranges 56 { 57 using std::ranges::all_of; 58 } 59 using std::any_of; 60 namespace ranges 61 { 62 using std::ranges::any_of; 63 } 64 using std::none_of; 65 namespace ranges 66 { 67 using std::ranges::none_of; 68 } 69 using std::for_each; 70 namespace ranges 71 { 72 using std::ranges::for_each; 73 using std::ranges::for_each_result; 74 } 75 using std::for_each_n; 76 namespace ranges 77 { 78 using std::ranges::for_each_n; 79 using std::ranges::for_each_n_result; 80 } 81 using std::find; 82 using std::find_if; 83 using std::find_if_not; 84 namespace ranges 85 { 86 using std::ranges::find; 87 using std::ranges::find_if; 88 using std::ranges::find_if_not; 89 } 90 using std::find_end; 91 namespace ranges 92 { 93 using std::ranges::find_end; 94 } 95 using std::find_first_of; 96 namespace ranges 97 { 98 using std::ranges::find_first_of; 99 } 100 using std::adjacent_find; 101 namespace ranges 102 { 103 using std::ranges::adjacent_find; 104 } 105 using std::count; 106 using std::count_if; 107 namespace ranges 108 { 109 using std::ranges::count; 110 using std::ranges::count_if; 111 } 112 using std::mismatch; 113 namespace ranges 114 { 115 using std::ranges::mismatch; 116 using std::ranges::mismatch_result; 117 } 118 using std::equal; 119 namespace ranges 120 { 121 using std::ranges::equal; 122 } 123 using std::is_permutation; 124 namespace ranges 125 { 126 using std::ranges::is_permutation; 127 } 128 using std::search; 129 namespace ranges 130 { 131 using std::ranges::search; 132 } 133 using std::search_n; 134 namespace ranges 135 { 136 using std::ranges::search_n; 137 } 138 namespace ranges 139 {} 140 using std::copy; 141 namespace ranges 142 { 143 using std::ranges::copy; 144 using std::ranges::copy_result; 145 } 146 using std::copy_n; 147 namespace ranges 148 { 149 using std::ranges::copy_n; 150 using std::ranges::copy_n_result; 151 } 152 using std::copy_if; 153 namespace ranges 154 { 155 using std::ranges::copy_if; 156 using std::ranges::copy_if_result; 157 } 158 using std::copy_backward; 159 namespace ranges 160 { 161 using std::ranges::copy_backward; 162 using std::ranges::copy_backward_result; 163 } 164 using std::move; 165 namespace ranges 166 { 167 using std::ranges::move; 168 using std::ranges::move_result; 169 } 170 using std::move_backward; 171 namespace ranges 172 { 173 using std::ranges::move_backward; 174 using std::ranges::move_backward_result; 175 } 176 using std::swap_ranges; 177 namespace ranges 178 { 179 using std::ranges::swap_ranges; 180 using std::ranges::swap_ranges_result; 181 } 182 using std::iter_swap; 183 using std::transform; 184 namespace ranges 185 { 186 using std::ranges::binary_transform_result; 187 using std::ranges::transform; 188 using std::ranges::unary_transform_result; 189 } 190 using std::replace; 191 using std::replace_if; 192 namespace ranges 193 { 194 using std::ranges::replace; 195 using std::ranges::replace_if; 196 } 197 using std::replace_copy; 198 using std::replace_copy_if; 199 namespace ranges 200 { 201 using std::ranges::replace_copy; 202 using std::ranges::replace_copy_if; 203 using std::ranges::replace_copy_if_result; 204 using std::ranges::replace_copy_result; 205 } 206 using std::fill; 207 using std::fill_n; 208 namespace ranges 209 { 210 using std::ranges::fill; 211 using std::ranges::fill_n; 212 } 213 using std::generate; 214 using std::generate_n; 215 namespace ranges 216 { 217 using std::ranges::generate; 218 using std::ranges::generate_n; 219 } 220 using std::remove; 221 using std::remove_if; 222 namespace ranges 223 { 224 using std::ranges::remove; 225 using std::ranges::remove_if; 226 } 227 using std::remove_copy; 228 using std::remove_copy_if; 229 namespace ranges 230 { 231 using std::ranges::remove_copy; 232 using std::ranges::remove_copy_if; 233 using std::ranges::remove_copy_if_result; 234 using std::ranges::remove_copy_result; 235 } 236 using std::unique; 237 namespace ranges 238 { 239 using std::ranges::unique; 240 } 241 using std::unique_copy; 242 namespace ranges 243 { 244 using std::ranges::unique_copy; 245 using std::ranges::unique_copy_result; 246 } 247 using std::reverse; 248 namespace ranges 249 { 250 using std::ranges::reverse; 251 } 252 using std::reverse_copy; 253 namespace ranges 254 { 255 using std::ranges::reverse_copy; 256 using std::ranges::reverse_copy_result; 257 } 258 using std::rotate; 259 namespace ranges 260 { 261 using std::ranges::rotate; 262 } 263 using std::rotate_copy; 264 namespace ranges 265 { 266 using std::ranges::rotate_copy; 267 using std::ranges::rotate_copy_result; 268 } 269 using std::sample; 270 namespace ranges 271 { 272 using std::ranges::sample; 273 } 274 using std::shuffle; 275 namespace ranges 276 { 277 using std::ranges::shuffle; 278 } 279 using std::shift_left; 280 namespace ranges 281 {} 282 using std::shift_right; 283 namespace ranges 284 {} 285 using std::sort; 286 namespace ranges 287 { 288 using std::ranges::sort; 289 } 290 using std::stable_sort; 291 namespace ranges 292 { 293 using std::ranges::stable_sort; 294 } 295 using std::partial_sort; 296 namespace ranges 297 { 298 using std::ranges::partial_sort; 299 } 300 using std::partial_sort_copy; 301 namespace ranges 302 { 303 using std::ranges::partial_sort_copy; 304 using std::ranges::partial_sort_copy_result; 305 } 306 using std::is_sorted; 307 using std::is_sorted_until; 308 namespace ranges 309 { 310 using std::ranges::is_sorted; 311 using std::ranges::is_sorted_until; 312 } 313 using std::nth_element; 314 namespace ranges 315 { 316 using std::ranges::nth_element; 317 } 318 using std::lower_bound; 319 namespace ranges 320 { 321 using std::ranges::lower_bound; 322 } 323 using std::upper_bound; 324 namespace ranges 325 { 326 using std::ranges::upper_bound; 327 } 328 using std::equal_range; 329 namespace ranges 330 { 331 using std::ranges::equal_range; 332 } 333 using std::binary_search; 334 namespace ranges 335 { 336 using std::ranges::binary_search; 337 } 338 using std::is_partitioned; 339 namespace ranges 340 { 341 using std::ranges::is_partitioned; 342 } 343 using std::partition; 344 namespace ranges 345 { 346 using std::ranges::partition; 347 } 348 using std::stable_partition; 349 namespace ranges 350 { 351 using std::ranges::stable_partition; 352 } 353 using std::partition_copy; 354 namespace ranges 355 { 356 using std::ranges::partition_copy; 357 using std::ranges::partition_copy_result; 358 } 359 using std::partition_point; 360 namespace ranges 361 { 362 using std::ranges::partition_point; 363 } 364 using std::merge; 365 namespace ranges 366 { 367 using std::ranges::merge; 368 using std::ranges::merge_result; 369 } 370 using std::inplace_merge; 371 namespace ranges 372 { 373 using std::ranges::inplace_merge; 374 } 375 using std::includes; 376 namespace ranges 377 { 378 using std::ranges::includes; 379 } 380 using std::set_union; 381 namespace ranges 382 { 383 using std::ranges::set_union; 384 using std::ranges::set_union_result; 385 } 386 using std::set_intersection; 387 namespace ranges 388 { 389 using std::ranges::set_intersection; 390 using std::ranges::set_intersection_result; 391 } 392 using std::set_difference; 393 namespace ranges 394 { 395 using std::ranges::set_difference; 396 using std::ranges::set_difference_result; 397 } 398 using std::set_symmetric_difference; 399 namespace ranges 400 { 401 using std::ranges::set_symmetric_difference; 402 using std::ranges::set_symmetric_difference_result; 403 } 404 using std::push_heap; 405 namespace ranges 406 { 407 using std::ranges::push_heap; 408 } 409 using std::pop_heap; 410 namespace ranges 411 { 412 using std::ranges::pop_heap; 413 } 414 using std::make_heap; 415 namespace ranges 416 { 417 using std::ranges::make_heap; 418 } 419 using std::sort_heap; 420 namespace ranges 421 { 422 using std::ranges::sort_heap; 423 } 424 using std::is_heap; 425 namespace ranges 426 { 427 using std::ranges::is_heap; 428 } 429 using std::is_heap_until; 430 namespace ranges 431 { 432 using std::ranges::is_heap_until; 433 } 434 using std::min; 435 namespace ranges 436 { 437 using std::ranges::min; 438 } 439 using std::max; 440 namespace ranges 441 { 442 using std::ranges::max; 443 } 444 using std::minmax; 445 namespace ranges 446 { 447 using std::ranges::minmax; 448 using std::ranges::minmax_result; 449 } 450 using std::min_element; 451 namespace ranges 452 { 453 using std::ranges::min_element; 454 } 455 using std::max_element; 456 namespace ranges 457 { 458 using std::ranges::max_element; 459 } 460 using std::minmax_element; 461 namespace ranges 462 { 463 using std::ranges::minmax_element; 464 using std::ranges::minmax_element_result; 465 } 466 using std::clamp; 467 namespace ranges 468 { 469 using std::ranges::clamp; 470 } 471 using std::lexicographical_compare; 472 namespace ranges 473 { 474 using std::ranges::lexicographical_compare; 475 } 476 using std::lexicographical_compare_three_way; 477 using std::next_permutation; 478 namespace ranges 479 { 480 using std::ranges::next_permutation; 481 using std::ranges::next_permutation_result; 482 } 483 using std::prev_permutation; 484 namespace ranges 485 { 486 using std::ranges::prev_permutation; 487 using std::ranges::prev_permutation_result; 488 } 489 namespace ranges 490 { 491 #if __cpp_lib_ranges_contains 492 using ranges::contains; 493 using ranges::contains_subrange; 494 #endif 495 #if __cpp_lib_ranges_fold 496 using ranges::fold_left; 497 using ranges::fold_left_first; 498 using ranges::fold_left_first_with_iter; 499 using ranges::fold_left_first_with_iter_result; 500 using ranges::fold_left_with_iter; 501 using ranges::fold_left_with_iter_result; 502 using ranges::fold_right; 503 using ranges::fold_right_last; 504 using ranges::in_value_result; 505 using ranges::out_value_result; 506 #endif 507 #if __cpp_lib_ranges_find_last 508 using ranges::find_last; 509 using ranges::find_last_if; 510 using ranges::find_last_if_not; 511 #endif 512 } 513 } 514 515 // 22.7.2 <any> 516 #if __cpp_lib_any 517 export namespace std 518 { 519 using std::any; 520 using std::any_cast; 521 using std::bad_any_cast; 522 using std::make_any; 523 using std::swap; 524 } 525 #endif 526 527 // 24.3.2 <array> 528 export namespace std 529 { 530 using std::array; 531 using std::operator==; 532 using std::operator<=>; 533 using std::get; 534 using std::swap; 535 using std::to_array; 536 using std::tuple_element; 537 using std::tuple_size; 538 } 539 540 // 33.5.2 <atomic> 541 export namespace std 542 { 543 using std::atomic; 544 using std::atomic_bool; 545 using std::atomic_char; 546 using std::atomic_char16_t; 547 using std::atomic_char32_t; 548 using std::atomic_char8_t; 549 using std::atomic_compare_exchange_strong; 550 using std::atomic_compare_exchange_strong_explicit; 551 using std::atomic_compare_exchange_weak; 552 using std::atomic_compare_exchange_weak_explicit; 553 using std::atomic_exchange; 554 using std::atomic_exchange_explicit; 555 using std::atomic_fetch_add; 556 using std::atomic_fetch_add_explicit; 557 using std::atomic_fetch_and; 558 using std::atomic_fetch_and_explicit; 559 using std::atomic_fetch_or; 560 using std::atomic_fetch_or_explicit; 561 using std::atomic_fetch_sub; 562 using std::atomic_fetch_sub_explicit; 563 using std::atomic_fetch_xor; 564 using std::atomic_fetch_xor_explicit; 565 using std::atomic_flag; 566 using std::atomic_flag_clear; 567 using std::atomic_flag_clear_explicit; 568 using std::atomic_flag_notify_all; 569 using std::atomic_flag_notify_one; 570 using std::atomic_flag_test; 571 using std::atomic_flag_test_and_set; 572 using std::atomic_flag_test_and_set_explicit; 573 using std::atomic_flag_test_explicit; 574 using std::atomic_flag_wait; 575 using std::atomic_flag_wait_explicit; 576 using std::atomic_init; 577 using std::atomic_int; 578 using std::atomic_int16_t; 579 using std::atomic_int32_t; 580 using std::atomic_int64_t; 581 using std::atomic_int8_t; 582 using std::atomic_int_fast16_t; 583 using std::atomic_int_fast32_t; 584 using std::atomic_int_fast64_t; 585 using std::atomic_int_fast8_t; 586 using std::atomic_int_least16_t; 587 using std::atomic_int_least32_t; 588 using std::atomic_int_least64_t; 589 using std::atomic_int_least8_t; 590 using std::atomic_intmax_t; 591 using std::atomic_intptr_t; 592 using std::atomic_is_lock_free; 593 using std::atomic_llong; 594 using std::atomic_load; 595 using std::atomic_load_explicit; 596 using std::atomic_long; 597 using std::atomic_notify_all; 598 using std::atomic_notify_one; 599 using std::atomic_ptrdiff_t; 600 using std::atomic_ref; 601 using std::atomic_schar; 602 using std::atomic_short; 603 using std::atomic_signal_fence; 604 #ifdef __cpp_lib_atomic_lock_free_type_aliases 605 using std::atomic_signed_lock_free; 606 #endif 607 using std::atomic_size_t; 608 using std::atomic_store; 609 using std::atomic_store_explicit; 610 using std::atomic_thread_fence; 611 using std::atomic_uchar; 612 using std::atomic_uint; 613 using std::atomic_uint16_t; 614 using std::atomic_uint32_t; 615 using std::atomic_uint64_t; 616 using std::atomic_uint8_t; 617 using std::atomic_uint_fast16_t; 618 using std::atomic_uint_fast32_t; 619 using std::atomic_uint_fast64_t; 620 using std::atomic_uint_fast8_t; 621 using std::atomic_uint_least16_t; 622 using std::atomic_uint_least32_t; 623 using std::atomic_uint_least64_t; 624 using std::atomic_uint_least8_t; 625 using std::atomic_uintmax_t; 626 using std::atomic_uintptr_t; 627 using std::atomic_ullong; 628 using std::atomic_ulong; 629 #ifdef __cpp_lib_atomic_lock_free_type_aliases 630 using std::atomic_unsigned_lock_free; 631 #endif 632 using std::atomic_ushort; 633 using std::atomic_wait; 634 using std::atomic_wait_explicit; 635 using std::atomic_wchar_t; 636 using std::kill_dependency; 637 using std::memory_order; 638 using std::memory_order_acq_rel; 639 using std::memory_order_acquire; 640 using std::memory_order_consume; 641 using std::memory_order_relaxed; 642 using std::memory_order_release; 643 using std::memory_order_seq_cst; 644 // ATOMIC_*_LOCK_FREE not exported 645 } 646 647 // 33.9.3 <barrier> 648 #if __cpp_lib_barrier 649 export namespace std 650 { 651 using std::barrier; 652 } 653 #endif 654 655 // 22.15 <bit> 656 export namespace std 657 { 658 using std::bit_cast; 659 using std::bit_ceil; 660 using std::bit_floor; 661 using std::bit_width; 662 using std::countl_one; 663 using std::countl_zero; 664 using std::countr_one; 665 using std::countr_zero; 666 using std::endian; 667 using std::has_single_bit; 668 using std::popcount; 669 using std::rotl; 670 using std::rotr; 671 #if __cpp_lib_byteswap // >= C++23 672 using std::byteswap; 673 #endif 674 } 675 676 // 22.9 <bitset> 677 export namespace std 678 { 679 using std::bitset; 680 using std::operator&; 681 using std::operator|; 682 using std::operator^; 683 using std::operator>>; 684 using std::operator<<; 685 using std::hash; 686 } 687 688 // 22.13 <charconv> 689 export namespace std 690 { 691 using std::chars_format; 692 using std::operator&; 693 using std::operator&=; 694 using std::operator^; 695 using std::operator^=; 696 using std::operator|; 697 using std::operator|=; 698 using std::operator~; 699 using std::from_chars; 700 using std::from_chars_result; 701 using std::to_chars; 702 using std::to_chars_result; 703 } 704 705 // 29.2 <chrono> 706 #if __cpp_lib_chrono 707 export namespace std 708 { 709 namespace chrono 710 { 711 using std::chrono::duration; 712 using std::chrono::time_point; 713 } 714 using std::common_type; 715 namespace chrono 716 { 717 using std::chrono::duration_values; 718 using std::chrono::treat_as_floating_point; 719 using std::chrono::treat_as_floating_point_v; 720 using std::chrono::operator+; 721 using std::chrono::operator-; 722 using std::chrono::operator*; 723 using std::chrono::operator/; 724 using std::chrono::operator%; 725 using std::chrono::operator==; 726 using std::chrono::operator<; 727 using std::chrono::operator>; 728 using std::chrono::operator<=; 729 using std::chrono::operator>=; 730 using std::chrono::operator<=>; 731 using std::chrono::ceil; 732 using std::chrono::duration_cast; 733 using std::chrono::floor; 734 using std::chrono::round; 735 using std::chrono::operator<<; 736 using std::chrono::abs; 737 using std::chrono::day; 738 using std::chrono::days; 739 using std::chrono::file_clock; 740 using std::chrono::file_time; 741 using std::chrono::hh_mm_ss; 742 using std::chrono::high_resolution_clock; 743 using std::chrono::hours; 744 using std::chrono::is_am; 745 using std::chrono::is_pm; 746 using std::chrono::last_spec; 747 using std::chrono::local_days; 748 using std::chrono::local_seconds; 749 using std::chrono::local_t; 750 using std::chrono::local_time; 751 using std::chrono::make12; 752 using std::chrono::make24; 753 using std::chrono::microseconds; 754 using std::chrono::milliseconds; 755 using std::chrono::minutes; 756 using std::chrono::month; 757 using std::chrono::month_day; 758 using std::chrono::month_day_last; 759 using std::chrono::month_weekday; 760 using std::chrono::month_weekday_last; 761 using std::chrono::months; 762 using std::chrono::nanoseconds; 763 using std::chrono::seconds; 764 using std::chrono::steady_clock; 765 using std::chrono::sys_days; 766 using std::chrono::sys_seconds; 767 using std::chrono::sys_time; 768 using std::chrono::system_clock; 769 using std::chrono::time_point_cast; 770 using std::chrono::weekday; 771 using std::chrono::weekday_indexed; 772 using std::chrono::weekday_last; 773 using std::chrono::weeks; 774 using std::chrono::year; 775 using std::chrono::year_month; 776 using std::chrono::year_month_day; 777 using std::chrono::year_month_day_last; 778 using std::chrono::year_month_weekday; 779 using std::chrono::year_month_weekday_last; 780 using std::chrono::years; 781 } 782 using std::formatter; 783 namespace chrono 784 { 785 using std::chrono::April; 786 using std::chrono::August; 787 using std::chrono::December; 788 using std::chrono::February; 789 using std::chrono::Friday; 790 using std::chrono::January; 791 using std::chrono::July; 792 using std::chrono::June; 793 using std::chrono::last; 794 using std::chrono::March; 795 using std::chrono::May; 796 using std::chrono::Monday; 797 using std::chrono::November; 798 using std::chrono::October; 799 using std::chrono::Saturday; 800 using std::chrono::September; 801 using std::chrono::Sunday; 802 using std::chrono::Thursday; 803 using std::chrono::Tuesday; 804 using std::chrono::Wednesday; 805 using chrono::utc_clock; 806 using chrono::utc_time; 807 using chrono::utc_seconds; 808 using chrono::tai_clock; 809 using chrono::tai_time; 810 using chrono::tai_seconds; 811 using chrono::gps_clock; 812 using chrono::gps_time; 813 using chrono::gps_seconds; 814 using chrono::clock_cast; 815 using chrono::parse; 816 using chrono::from_stream; 817 using chrono::clock_time_conversion; 818 #if __cpp_lib_chrono >= 201907L 819 using chrono::tzdb; 820 using chrono::tzdb_list; 821 using chrono::get_tzdb; 822 using chrono::get_tzdb_list; 823 using chrono::locate_zone; 824 using chrono::current_zone; 825 using chrono::reload_tzdb; 826 using chrono::remote_version; 827 using chrono::nonexistent_local_time; 828 using chrono::ambiguous_local_time; 829 using chrono::sys_info; 830 using chrono::local_info; 831 using chrono::choose; 832 using chrono::time_zone; 833 using chrono::zoned_traits; 834 using chrono::zoned_time; 835 using chrono::zoned_seconds; 836 using chrono::leap_second; 837 using chrono::leap_second_info; 838 using chrono::get_leap_second_info; 839 using chrono::time_zone_link; 840 using chrono::local_time_format; 841 #endif 842 using chrono::is_clock; 843 using chrono::is_clock_v; 844 } 845 } 846 export namespace std::inline literals::inline chrono_literals 847 { 848 using std::literals::chrono_literals::operator""h; 849 using std::literals::chrono_literals::operator""min; 850 using std::literals::chrono_literals::operator""s; 851 using std::literals::chrono_literals::operator""ms; 852 using std::literals::chrono_literals::operator""us; 853 using std::literals::chrono_literals::operator""ns; 854 using std::literals::chrono_literals::operator""d; 855 using std::literals::chrono_literals::operator""y; 856 } 857 export namespace std::chrono { 858 using namespace literals::chrono_literals; 859 } 860 #endif // __cpp_lib_chrono 861 862 // <codecvt>: deprecated C++17, removed C++26 863 export namespace std 864 { 865 using std::codecvt_mode; 866 using std::codecvt_utf16; 867 using std::codecvt_utf8; 868 using std::codecvt_utf8_utf16; 869 } 870 871 // 17.11.1 <compare> 872 #if __cpp_lib_three_way_comparison 873 export namespace std 874 { 875 using std::common_comparison_category; 876 using std::common_comparison_category_t; 877 using std::compare_three_way; 878 using std::compare_three_way_result; 879 using std::compare_three_way_result_t; 880 using std::is_eq; 881 using std::is_gt; 882 using std::is_gteq; 883 using std::is_lt; 884 using std::is_lteq; 885 using std::is_neq; 886 using std::partial_ordering; 887 using std::strong_ordering; 888 using std::three_way_comparable; 889 using std::three_way_comparable_with; 890 using std::weak_ordering; 891 using std::compare_partial_order_fallback; 892 using std::compare_strong_order_fallback; 893 using std::compare_weak_order_fallback; 894 using std::partial_order; 895 using std::strong_order; 896 using std::weak_order; 897 } 898 #endif // __cpp_lib_three_way_comparison 899 900 // 28.4 <complex> 901 export namespace std 902 { 903 using std::complex; 904 using std::operator+; 905 using std::operator-; 906 using std::operator*; 907 using std::operator/; 908 using std::operator==; 909 using std::operator>>; 910 using std::operator<<; 911 using std::abs; 912 using std::acos; 913 using std::acosh; 914 using std::arg; 915 using std::asin; 916 using std::asinh; 917 using std::atan; 918 using std::atanh; 919 using std::conj; 920 using std::cos; 921 using std::cosh; 922 using std::exp; 923 using std::imag; 924 using std::log; 925 using std::log10; 926 using std::norm; 927 using std::polar; 928 using std::pow; 929 using std::proj; 930 using std::real; 931 using std::sin; 932 using std::sinh; 933 using std::sqrt; 934 using std::tan; 935 using std::tanh; 936 #if __cpp_lib_tuple_like >= 202311L 937 using std::tuple_element; 938 using std::tuple_element_t; 939 using std::tuple_size; 940 using std::tuple_size_v; 941 using std::get; 942 #endif 943 } 944 export namespace std::inline literals::inline complex_literals 945 { 946 using std::operator""il; 947 using std::operator""i; 948 using std::operator""if; 949 } 950 951 // 18 <concepts> 952 #if __cpp_lib_concepts 953 export namespace std 954 { 955 using std::assignable_from; 956 using std::common_reference_with; 957 using std::common_with; 958 using std::convertible_to; 959 using std::derived_from; 960 using std::floating_point; 961 using std::integral; 962 using std::same_as; 963 using std::signed_integral; 964 using std::unsigned_integral; 965 namespace ranges 966 { 967 using std::ranges::swap; 968 } 969 using std::constructible_from; 970 using std::copy_constructible; 971 using std::copyable; 972 using std::default_initializable; 973 using std::destructible; 974 using std::equality_comparable; 975 using std::equality_comparable_with; 976 using std::equivalence_relation; 977 using std::invocable; 978 using std::movable; 979 using std::move_constructible; 980 using std::predicate; 981 using std::regular; 982 using std::regular_invocable; 983 using std::relation; 984 using std::semiregular; 985 using std::strict_weak_order; 986 using std::swappable; 987 using std::swappable_with; 988 using std::totally_ordered; 989 using std::totally_ordered_with; 990 } 991 #endif 992 993 // 33.7 <condition_variable> 994 export namespace std 995 { 996 using std::condition_variable; 997 using std::condition_variable_any; 998 using std::cv_status; 999 using std::notify_all_at_thread_exit; 1000 } 1001 1002 // 17.12.2 <coroutine> 1003 #if __cpp_lib_coroutine 1004 export namespace std 1005 { 1006 using std::coroutine_handle; 1007 using std::coroutine_traits; 1008 using std::operator==; 1009 using std::operator<=>; 1010 using std::hash; 1011 using std::noop_coroutine; 1012 using std::noop_coroutine_handle; 1013 using std::noop_coroutine_promise; 1014 using std::suspend_always; 1015 using std::suspend_never; 1016 } 1017 #endif // __cpp_lib_coroutine 1018 1019 // 22.16 <debugging> 1020 #if __cpp_lib_debugging 1021 export namespace std 1022 { 1023 using std::breakpoint; 1024 using std::breakpoint_if_debugging; 1025 using std::is_debugger_present; 1026 } 1027 #endif 1028 1029 // 24.3 <deque> 1030 export namespace std 1031 { 1032 using std::deque; 1033 using std::operator==; 1034 using std::operator<=>; 1035 using std::erase; 1036 using std::erase_if; 1037 using std::swap; 1038 namespace pmr 1039 { 1040 using std::pmr::deque; 1041 } 1042 } 1043 1044 // 17.9.2 <exception> 1045 export namespace std 1046 { 1047 using std::bad_exception; 1048 using std::current_exception; 1049 using std::exception; 1050 using std::exception_ptr; 1051 using std::get_terminate; 1052 using std::make_exception_ptr; 1053 using std::nested_exception; 1054 using std::rethrow_exception; 1055 using std::rethrow_if_nested; 1056 using std::set_terminate; 1057 using std::terminate; 1058 using std::terminate_handler; 1059 using std::throw_with_nested; 1060 using std::uncaught_exception; 1061 using std::uncaught_exceptions; 1062 } 1063 1064 // 34.4 <execution> 1065 #if __cpp_lib_execution 1066 export namespace std 1067 { 1068 using std::is_execution_policy; 1069 using std::is_execution_policy_v; 1070 namespace execution 1071 { 1072 using std::execution::sequenced_policy; 1073 using std::execution::parallel_policy; 1074 using std::execution::parallel_unsequenced_policy; 1075 using std::execution::unsequenced_policy; 1076 using std::execution::seq; 1077 using std::execution::par; 1078 using std::execution::par_unseq; 1079 using std::execution::unseq; 1080 } 1081 #if __cpp_lib_senders 1082 using std::forwarding_query_t; 1083 using std::get_allocator_t; 1084 using std::get_stop_token_t; 1085 using std::forwarding_query; 1086 using std::get_allocator; 1087 using std::get_stop_token; 1088 using std::stop_token_of_t; 1089 namespace execution 1090 { 1091 using std::execution::get_domain_t; 1092 using std::execution::get_scheduler_t; 1093 using std::execution::get_delegation_scheduler_t; 1094 using std::execution::get_forward_progress_guarantee_t; 1095 using std::execution::get_completion_scheduler_t; 1096 using std::execution::get_domain; 1097 using std::execution::get_scheduler; 1098 using std::execution::get_delegation_scheduler; 1099 using std::execution::forward_progress_guarantee; 1100 using std::execution::get_forward_progress_guarantee; 1101 using std::execution::get_completion_scheduler; 1102 using std::execution::empty_env; 1103 using std::execution::get_env_t; 1104 using std::execution::get_env; 1105 using std::execution::env_of_t; 1106 using std::execution::default_domain; 1107 using std::execution::scheduler_t; 1108 using std::execution::scheduler; 1109 using std::execution::receiver_t; 1110 using std::execution::receiver; 1111 using std::execution::receiver_of; 1112 using std::execution::set_value_t; 1113 using std::execution::set_error_t; 1114 using std::execution::set_stopped_t; 1115 using std::execution::set_value; 1116 using std::execution::set_error; 1117 using std::execution::set_stopped; 1118 using std::execution::operation_state_t; 1119 using std::execution::operation_state; 1120 using std::execution::start_t; 1121 using std::execution::start; 1122 using std::execution::sender_t; 1123 using std::execution::sender; 1124 using std::execution::sender_in; 1125 using std::execution::sender_to; 1126 using std::execution::get_completion_signatures_t; 1127 using std::execution::get_completion_signatures; 1128 using std::execution::completion_signatures_of_t; 1129 using std::execution::value_types_of_t; 1130 using std::execution::error_types_of_t; 1131 using std::execution::sends_stopped; 1132 using std::execution::tag_of_t; 1133 using std::execution::transform_sender; 1134 using std::execution::transform_env; 1135 using std::execution::apply_sender; 1136 using std::execution::connect_t; 1137 using std::execution::connect; 1138 using std::execution::connect_result_t; 1139 using std::execution::just_t; 1140 using std::execution::just_error_t; 1141 using std::execution::just_stopped_t; 1142 using std::execution::schedule_t; 1143 using std::execution::just; 1144 using std::execution::just_error; 1145 using std::execution::just_stopped; 1146 using std::execution::schedule; 1147 using std::execution::read_env; 1148 using std::execution::schedule_result_t; 1149 using std::execution::sender_adaptor_closure; 1150 using std::execution::starts_on_t; 1151 using std::execution::continues_on_t; 1152 using std::execution::on_t; 1153 using std::execution::schedule_from_t; 1154 using std::execution::then_t; 1155 using std::execution::upon_error_t; 1156 using std::execution::upon_stopped_t; 1157 using std::execution::let_value_t; 1158 using std::execution::let_error_t; 1159 using std::execution::let_stopped_t; 1160 using std::execution::bulk_t; 1161 using std::execution::split_t; 1162 using std::execution::when_all_t; 1163 using std::execution::when_all_with_variant_t; 1164 using std::execution::into_variant_t; 1165 using std::execution::stopped_as_optional_t; 1166 using std::execution::stopped_as_error_t; 1167 using std::execution::starts_on; 1168 using std::execution::continues_on; 1169 using std::execution::on; 1170 using std::execution::schedule_from; 1171 using std::execution::then; 1172 using std::execution::upon_error; 1173 using std::execution::upon_stopped; 1174 using std::execution::let_value; 1175 using std::execution::let_error; 1176 using std::execution::let_stopped; 1177 using std::execution::bulk; 1178 using std::execution::split; 1179 using std::execution::when_all; 1180 using std::execution::when_all_with_variant; 1181 using std::execution::into_variant; 1182 using std::execution::stopped_as_optional; 1183 using std::execution::stopped_as_error; 1184 using std::execution::completion_signatures; 1185 using std::execution::transform_completion_signatures; 1186 using std::execution::transform_completion_signatures_of; 1187 using std::execution::run_loop; 1188 } 1189 namespace this_thread 1190 { 1191 using std::this_thread::sync_wait_t; 1192 using std::this_thread::sync_wait_with_variant_t; 1193 using std::this_thread::sync_wait; 1194 using std::this_thread::sync_wait_with_variant; 1195 } 1196 #endif // __cpp_lib_senders 1197 } 1198 #endif // __cpp_lib_execution 1199 1200 // 22.8 <expected> 1201 #if __cpp_lib_expected 1202 export namespace std 1203 { 1204 using std::unexpected; 1205 using std::bad_expected_access; 1206 using std::unexpect_t; 1207 using std::unexpect; 1208 using std::expected; 1209 } 1210 #endif 1211 1212 // <filesystem> 1213 #if __cpp_lib_filesystem 1214 export namespace std::filesystem 1215 { 1216 using std::filesystem::begin; 1217 using std::filesystem::copy_options; 1218 using std::filesystem::directory_entry; 1219 using std::filesystem::directory_iterator; 1220 using std::filesystem::directory_options; 1221 using std::filesystem::end; 1222 using std::filesystem::file_status; 1223 using std::filesystem::file_time_type; 1224 using std::filesystem::file_type; 1225 using std::filesystem::filesystem_error; 1226 using std::filesystem::hash_value; 1227 using std::filesystem::path; 1228 using std::filesystem::perm_options; 1229 using std::filesystem::perms; 1230 using std::filesystem::recursive_directory_iterator; 1231 using std::filesystem::space_info; 1232 using std::filesystem::swap; 1233 using std::filesystem::operator&; 1234 using std::filesystem::operator&=; 1235 using std::filesystem::operator^; 1236 using std::filesystem::operator^=; 1237 using std::filesystem::operator|; 1238 using std::filesystem::operator|=; 1239 using std::filesystem::operator~; 1240 using std::filesystem::absolute; 1241 using std::filesystem::canonical; 1242 using std::filesystem::copy; 1243 using std::filesystem::copy_file; 1244 using std::filesystem::copy_symlink; 1245 using std::filesystem::create_directories; 1246 using std::filesystem::create_directory; 1247 using std::filesystem::create_directory_symlink; 1248 using std::filesystem::create_hard_link; 1249 using std::filesystem::create_symlink; 1250 using std::filesystem::current_path; 1251 using std::filesystem::equivalent; 1252 using std::filesystem::exists; 1253 using std::filesystem::file_size; 1254 using std::filesystem::hard_link_count; 1255 using std::filesystem::is_block_file; 1256 using std::filesystem::is_character_file; 1257 using std::filesystem::is_directory; 1258 using std::filesystem::is_empty; 1259 using std::filesystem::is_fifo; 1260 using std::filesystem::is_other; 1261 using std::filesystem::is_regular_file; 1262 using std::filesystem::is_socket; 1263 using std::filesystem::is_symlink; 1264 using std::filesystem::last_write_time; 1265 using std::filesystem::permissions; 1266 using std::filesystem::proximate; 1267 using std::filesystem::read_symlink; 1268 using std::filesystem::relative; 1269 using std::filesystem::remove; 1270 using std::filesystem::remove_all; 1271 using std::filesystem::rename; 1272 using std::filesystem::resize_file; 1273 using std::filesystem::space; 1274 using std::filesystem::status; 1275 using std::filesystem::status_known; 1276 using std::filesystem::symlink_status; 1277 using std::filesystem::temp_directory_path; 1278 using std::filesystem::u8path; 1279 using std::filesystem::weakly_canonical; 1280 } 1281 #endif // __cpp_lib_filesystem 1282 1283 // <flat_map> 1284 #if __cpp_lib_flat_map 1285 export namespace std 1286 { 1287 using std::flat_map; 1288 using std::flat_multimap; 1289 using std::sorted_equivalent; 1290 using std::sorted_equivalent_t; 1291 using std::sorted_unique; 1292 using std::sorted_unique_t; 1293 } 1294 #endif 1295 1296 // <flat_set> 1297 #if __cpp_lib_flat_set 1298 export namespace std 1299 { 1300 using std::flat_set; 1301 using std::flat_multiset; 1302 using std::sorted_equivalent; 1303 using std::sorted_equivalent_t; 1304 using std::sorted_unique; 1305 using std::sorted_unique_t; 1306 } 1307 #endif 1308 1309 // <format> 1310 export namespace std 1311 { 1312 using std::basic_format_arg; 1313 using std::basic_format_args; 1314 using std::basic_format_context; 1315 using std::basic_format_parse_context; 1316 using std::basic_format_string; 1317 using std::format; 1318 using std::format_args; 1319 using std::format_context; 1320 using std::format_error; 1321 using std::format_parse_context; 1322 using std::format_string; 1323 using std::format_to; 1324 using std::format_to_n; 1325 using std::format_to_n_result; 1326 using std::formatted_size; 1327 #if __cpp_lib_format_ranges 1328 using std::formattable; 1329 #endif 1330 using std::formatter; 1331 using std::make_format_args; 1332 using std::make_wformat_args; 1333 #if __cpp_lib_format >= 202311L // >= C++26 1334 using std::runtime_format; 1335 #endif 1336 using std::vformat; 1337 using std::vformat_to; 1338 using std::visit_format_arg; 1339 using std::wformat_args; 1340 using std::wformat_context; 1341 using std::wformat_parse_context; 1342 using std::wformat_string; 1343 #ifdef __cpp_lib_format_ranges 1344 using std::format_kind; 1345 using std::range_format; 1346 using std::range_formatter; 1347 #endif 1348 } 1349 1350 // <forward_list> 1351 export namespace std 1352 { 1353 using std::forward_list; 1354 using std::operator==; 1355 using std::operator<=>; 1356 using std::erase; 1357 using std::erase_if; 1358 using std::swap; 1359 namespace pmr 1360 { 1361 using std::pmr::forward_list; 1362 } 1363 } 1364 1365 // <fstream> 1366 export namespace std 1367 { 1368 using std::basic_filebuf; 1369 using std::basic_fstream; 1370 using std::basic_ifstream; 1371 using std::basic_ofstream; 1372 using std::filebuf; 1373 using std::fstream; 1374 using std::ifstream; 1375 using std::ofstream; 1376 using std::swap; 1377 using std::wfilebuf; 1378 using std::wfstream; 1379 using std::wifstream; 1380 using std::wofstream; 1381 } 1382 1383 // <functional> 1384 export namespace std 1385 { 1386 using std::bind; 1387 using std::bind_front; 1388 #if __cpp_lib_bind_back 1389 using std::bind_back; 1390 #endif 1391 using std::bit_and; 1392 using std::bit_not; 1393 using std::bit_or; 1394 using std::bit_xor; 1395 using std::compare_three_way; 1396 using std::cref; 1397 using std::divides; 1398 using std::equal_to; 1399 using std::greater; 1400 using std::greater_equal; 1401 using std::identity; 1402 using std::invoke; 1403 #if __cpp_lib_invoke_r 1404 using std::invoke_r; 1405 #endif 1406 using std::is_bind_expression; 1407 using std::is_bind_expression_v; 1408 using std::is_placeholder; 1409 using std::is_placeholder_v; 1410 using std::less; 1411 using std::less_equal; 1412 using std::logical_and; 1413 using std::logical_not; 1414 using std::logical_or; 1415 using std::minus; 1416 using std::modulus; 1417 #if __cpp_lib_move_only_function 1418 using std::move_only_function; 1419 #endif 1420 using std::multiplies; 1421 using std::negate; 1422 using std::not_equal_to; 1423 using std::not_fn; 1424 using std::plus; 1425 using std::ref; 1426 using std::reference_wrapper; 1427 namespace placeholders 1428 { 1429 using std::placeholders::_1; 1430 using std::placeholders::_10; 1431 using std::placeholders::_2; 1432 using std::placeholders::_3; 1433 using std::placeholders::_4; 1434 using std::placeholders::_5; 1435 using std::placeholders::_6; 1436 using std::placeholders::_7; 1437 using std::placeholders::_8; 1438 using std::placeholders::_9; 1439 } 1440 using std::bad_function_call; 1441 using std::function; 1442 using std::mem_fn; 1443 using std::swap; 1444 using std::operator==; 1445 using std::boyer_moore_horspool_searcher; 1446 using std::boyer_moore_searcher; 1447 using std::default_searcher; 1448 using std::hash; 1449 namespace ranges 1450 { 1451 using std::ranges::equal_to; 1452 using std::ranges::greater; 1453 using std::ranges::greater_equal; 1454 using std::ranges::less; 1455 using std::ranges::less_equal; 1456 using std::ranges::not_equal_to; 1457 } 1458 } 1459 1460 // <future> 1461 export namespace std 1462 { 1463 using std::future_errc; 1464 using std::future_status; 1465 using std::launch; 1466 using std::operator&; 1467 using std::operator&=; 1468 using std::operator^; 1469 using std::operator^=; 1470 using std::operator|; 1471 using std::operator|=; 1472 using std::operator~; 1473 using std::async; 1474 using std::future; 1475 using std::future_category; 1476 using std::future_error; 1477 using std::is_error_code_enum; 1478 using std::make_error_code; 1479 using std::make_error_condition; 1480 using std::packaged_task; 1481 using std::promise; 1482 using std::shared_future; 1483 using std::swap; 1484 using std::uses_allocator; 1485 } 1486 1487 #if __cpp_lib_generator 1488 export namespace std 1489 { 1490 using std::generator; 1491 namespace pmr 1492 { 1493 using pmr::generator; 1494 } 1495 } 1496 #endif 1497 1498 // <hazard_pointer> FIXME 1499 1500 // 17.10.2 <initializer_list> 1501 export namespace std 1502 { 1503 using std::begin; 1504 using std::end; 1505 using std::initializer_list; 1506 } 1507 1508 // <inplace_vector> FIXME 1509 1510 // <iomanip> 1511 export namespace std 1512 { 1513 using std::get_money; 1514 using std::get_time; 1515 using std::put_money; 1516 using std::put_time; 1517 using std::quoted; 1518 using std::resetiosflags; 1519 using std::setbase; 1520 using std::setfill; 1521 using std::setiosflags; 1522 using std::setprecision; 1523 using std::setw; 1524 } 1525 1526 // <ios> 1527 export namespace std 1528 { 1529 using std::fpos; 1530 using std::operator!=; 1531 using std::operator-; 1532 using std::operator==; 1533 using std::basic_ios; 1534 using std::boolalpha; 1535 using std::dec; 1536 using std::defaultfloat; 1537 using std::fixed; 1538 using std::hex; 1539 using std::hexfloat; 1540 using std::internal; 1541 using std::io_errc; 1542 using std::ios; 1543 using std::ios_base; 1544 using std::iostream_category; 1545 using std::is_error_code_enum; 1546 using std::left; 1547 using std::make_error_code; 1548 using std::make_error_condition; 1549 using std::noboolalpha; 1550 using std::noshowbase; 1551 using std::noshowpoint; 1552 using std::noshowpos; 1553 using std::noskipws; 1554 using std::nounitbuf; 1555 using std::nouppercase; 1556 using std::oct; 1557 using std::right; 1558 using std::scientific; 1559 using std::showbase; 1560 using std::showpoint; 1561 using std::showpos; 1562 using std::skipws; 1563 using std::streamoff; 1564 using std::streamsize; 1565 using std::unitbuf; 1566 using std::uppercase; 1567 using std::wios; 1568 } 1569 1570 // <iosfwd> 1571 export namespace std 1572 { 1573 using std::streampos; 1574 using std::u16streampos; 1575 using std::u32streampos; 1576 using std::u8streampos; 1577 using std::wstreampos; 1578 using std::istreambuf_iterator; 1579 using std::ostreambuf_iterator; 1580 using std::fpos; 1581 #ifdef __cpp_lib_syncbuf 1582 using std::basic_osyncstream; 1583 using std::basic_syncbuf; 1584 using std::osyncstream; 1585 using std::syncbuf; 1586 using std::wosyncstream; 1587 using std::wsyncbuf; 1588 #endif 1589 } 1590 1591 // <iostream> 1592 export namespace std 1593 { 1594 using std::cerr; 1595 using std::cin; 1596 using std::clog; 1597 using std::cout; 1598 using std::wcerr; 1599 using std::wcin; 1600 using std::wclog; 1601 using std::wcout; 1602 } 1603 1604 // <istream> 1605 export namespace std 1606 { 1607 using std::basic_iostream; 1608 using std::basic_istream; 1609 using std::iostream; 1610 using std::istream; 1611 using std::wiostream; 1612 using std::wistream; 1613 using std::ws; 1614 using std::operator>>; 1615 } 1616 1617 // <iterator> 1618 export namespace std 1619 { 1620 using std::incrementable_traits; 1621 using std::indirectly_readable_traits; 1622 using std::iter_difference_t; 1623 using std::iter_reference_t; 1624 using std::iter_value_t; 1625 using std::iterator_traits; 1626 // _Cpo is an implementation detail we can't avoid exposing; if we do the 1627 // using in ranges directly, it conflicts with any friend functions of the 1628 // same name, which is why the customization points are in an inline 1629 // namespace in the first place. 1630 namespace ranges::inline _Cpo 1631 { 1632 using _Cpo::iter_move; 1633 using _Cpo::iter_swap; 1634 } 1635 using std::advance; 1636 using std::bidirectional_iterator; 1637 using std::bidirectional_iterator_tag; 1638 using std::contiguous_iterator; 1639 using std::contiguous_iterator_tag; 1640 using std::disable_sized_sentinel_for; 1641 using std::distance; 1642 using std::forward_iterator; 1643 using std::forward_iterator_tag; 1644 using std::incrementable; 1645 using std::indirect_binary_predicate; 1646 using std::indirect_equivalence_relation; 1647 using std::indirect_result_t; 1648 using std::indirect_strict_weak_order; 1649 using std::indirect_unary_predicate; 1650 using std::indirectly_comparable; 1651 using std::indirectly_copyable; 1652 using std::indirectly_copyable_storable; 1653 using std::indirectly_movable; 1654 using std::indirectly_movable_storable; 1655 using std::indirectly_readable; 1656 using std::indirectly_regular_unary_invocable; 1657 using std::indirectly_swappable; 1658 using std::indirectly_unary_invocable; 1659 using std::indirectly_writable; 1660 using std::input_iterator; 1661 using std::input_iterator_tag; 1662 using std::input_or_output_iterator; 1663 using std::iter_common_reference_t; 1664 using std::iter_rvalue_reference_t; 1665 using std::mergeable; 1666 using std::next; 1667 using std::output_iterator; 1668 using std::output_iterator_tag; 1669 using std::permutable; 1670 using std::prev; 1671 using std::projected; 1672 using std::random_access_iterator; 1673 using std::random_access_iterator_tag; 1674 using std::sentinel_for; 1675 using std::sized_sentinel_for; 1676 using std::sortable; 1677 using std::weakly_incrementable; 1678 namespace ranges 1679 { 1680 using std::ranges::advance; 1681 using std::ranges::distance; 1682 using std::ranges::next; 1683 using std::ranges::prev; 1684 } 1685 using std::reverse_iterator; 1686 using std::operator==; 1687 using std::operator!=; 1688 using std::operator<; 1689 using std::operator>; 1690 using std::operator<=; 1691 using std::operator>=; 1692 using std::operator<=>; 1693 using std::operator-; 1694 using std::operator+; 1695 using std::back_insert_iterator; 1696 using std::back_inserter; 1697 using std::begin; 1698 using std::cbegin; 1699 using std::cend; 1700 using std::common_iterator; 1701 using std::counted_iterator; 1702 using std::crbegin; 1703 using std::crend; 1704 using std::data; 1705 using std::default_sentinel; 1706 using std::default_sentinel_t; 1707 using std::empty; 1708 using std::end; 1709 using std::front_insert_iterator; 1710 using std::front_inserter; 1711 using std::insert_iterator; 1712 using std::inserter; 1713 using std::istream_iterator; 1714 using std::istreambuf_iterator; 1715 using std::iterator; 1716 using std::make_move_iterator; 1717 using std::make_reverse_iterator; 1718 using std::move_iterator; 1719 using std::move_sentinel; 1720 using std::ostream_iterator; 1721 using std::ostreambuf_iterator; 1722 using std::rbegin; 1723 using std::rend; 1724 using std::size; 1725 using std::ssize; 1726 using std::unreachable_sentinel; 1727 using std::unreachable_sentinel_t; 1728 #if __glibcxx_ranges_as_const // >= C++23 1729 using std::iter_const_reference_t; 1730 using std::basic_const_iterator; 1731 using std::const_iterator; 1732 using std::const_sentinel; 1733 using std::make_const_iterator; 1734 using std::make_const_sentinel; 1735 #endif 1736 #if __glibcxx_algorithm_default_value_type // >= C++26 1737 using std::projected_value_t; 1738 #endif 1739 } 1740 // FIXME these should be friends of __normal_iterator to avoid exporting 1741 // __gnu_cxx. 1742 export namespace __gnu_cxx 1743 { 1744 using __gnu_cxx::operator==; 1745 using __gnu_cxx::operator<=>; 1746 using __gnu_cxx::operator+; 1747 using __gnu_cxx::operator-; 1748 } 1749 1750 // <latch> 1751 export namespace std 1752 { 1753 using std::latch; 1754 } 1755 1756 // 17.3.3 <limits> [limits.syn] 1757 export namespace std 1758 { 1759 using std::float_denorm_style; // deprecated in C++23 1760 using std::float_round_style; 1761 using std::numeric_limits; 1762 } 1763 1764 // FIXME <linalg> 1765 1766 // <list> 1767 export namespace std 1768 { 1769 using std::list; 1770 using std::operator==; 1771 using std::operator<=>; 1772 using std::erase; 1773 using std::erase_if; 1774 using std::swap; 1775 namespace pmr 1776 { 1777 using std::pmr::list; 1778 } 1779 } 1780 1781 // <locale> 1782 export namespace std 1783 { 1784 using std::codecvt; 1785 using std::codecvt_base; 1786 using std::codecvt_byname; 1787 using std::collate; 1788 using std::collate_byname; 1789 using std::ctype; 1790 using std::ctype_base; 1791 using std::ctype_byname; 1792 using std::has_facet; 1793 using std::isalnum; 1794 using std::isalpha; 1795 using std::isblank; 1796 using std::iscntrl; 1797 using std::isdigit; 1798 using std::isgraph; 1799 using std::islower; 1800 using std::isprint; 1801 using std::ispunct; 1802 using std::isspace; 1803 using std::isupper; 1804 using std::isxdigit; 1805 using std::locale; 1806 using std::messages; 1807 using std::messages_base; 1808 using std::messages_byname; 1809 using std::money_base; 1810 using std::money_get; 1811 using std::money_put; 1812 using std::moneypunct; 1813 using std::moneypunct_byname; 1814 using std::num_get; 1815 using std::num_put; 1816 using std::numpunct; 1817 using std::numpunct_byname; 1818 using std::time_base; 1819 using std::time_get; 1820 using std::time_get_byname; 1821 using std::time_put; 1822 using std::time_put_byname; 1823 using std::tolower; 1824 using std::toupper; 1825 using std::use_facet; 1826 using std::wbuffer_convert; 1827 using std::wstring_convert; 1828 } 1829 1830 // <map> 1831 export namespace std 1832 { 1833 using std::map; 1834 using std::operator==; 1835 using std::operator<=>; 1836 using std::erase_if; 1837 using std::multimap; 1838 using std::swap; 1839 namespace pmr 1840 { 1841 using std::pmr::map; 1842 using std::pmr::multimap; 1843 } 1844 } 1845 1846 // FIXME <mdspan> 1847 1848 // 20.2 <memory> 1849 export namespace std 1850 { 1851 using std::align; 1852 using std::allocator; 1853 using std::allocator_arg; 1854 using std::allocator_arg_t; 1855 using std::allocator_traits; 1856 using std::assume_aligned; 1857 using std::make_obj_using_allocator; 1858 using std::pointer_traits; 1859 using std::to_address; 1860 using std::uninitialized_construct_using_allocator; 1861 using std::uses_allocator; 1862 using std::uses_allocator_construction_args; 1863 using std::uses_allocator_v; 1864 using std::operator==; 1865 using std::addressof; 1866 using std::uninitialized_default_construct; 1867 using std::uninitialized_default_construct_n; 1868 namespace ranges 1869 { 1870 using std::ranges::uninitialized_default_construct; 1871 using std::ranges::uninitialized_default_construct_n; 1872 } 1873 using std::uninitialized_value_construct; 1874 using std::uninitialized_value_construct_n; 1875 namespace ranges 1876 { 1877 using std::ranges::uninitialized_value_construct; 1878 using std::ranges::uninitialized_value_construct_n; 1879 } 1880 using std::uninitialized_copy; 1881 using std::uninitialized_copy_n; 1882 namespace ranges 1883 { 1884 using std::ranges::uninitialized_copy; 1885 using std::ranges::uninitialized_copy_n; 1886 using std::ranges::uninitialized_copy_n_result; 1887 using std::ranges::uninitialized_copy_result; 1888 } 1889 using std::uninitialized_move; 1890 using std::uninitialized_move_n; 1891 namespace ranges 1892 { 1893 using std::ranges::uninitialized_move; 1894 using std::ranges::uninitialized_move_n; 1895 using std::ranges::uninitialized_move_n_result; 1896 using std::ranges::uninitialized_move_result; 1897 } 1898 using std::uninitialized_fill; 1899 using std::uninitialized_fill_n; 1900 namespace ranges 1901 { 1902 using std::ranges::uninitialized_fill; 1903 using std::ranges::uninitialized_fill_n; 1904 } 1905 using std::construct_at; 1906 namespace ranges 1907 { 1908 using std::ranges::construct_at; 1909 } 1910 using std::destroy; 1911 using std::destroy_at; 1912 using std::destroy_n; 1913 namespace ranges 1914 { 1915 using std::ranges::destroy; 1916 using std::ranges::destroy_at; 1917 using std::ranges::destroy_n; 1918 } 1919 using std::default_delete; 1920 using std::make_unique; 1921 using std::make_unique_for_overwrite; 1922 using std::unique_ptr; 1923 using std::operator<; 1924 using std::operator>; 1925 using std::operator<=; 1926 using std::operator>=; 1927 using std::operator<=>; 1928 using std::operator<<; 1929 using std::allocate_shared; 1930 using std::allocate_shared_for_overwrite; 1931 using std::bad_weak_ptr; 1932 using std::const_pointer_cast; 1933 using std::dynamic_pointer_cast; 1934 using std::make_shared; 1935 using std::make_shared_for_overwrite; 1936 using std::reinterpret_pointer_cast; 1937 using std::shared_ptr; 1938 using std::static_pointer_cast; 1939 using std::swap; 1940 using std::get_deleter; 1941 using std::atomic_compare_exchange_strong; 1942 using std::atomic_compare_exchange_strong_explicit; 1943 using std::atomic_compare_exchange_weak; 1944 using std::atomic_compare_exchange_weak_explicit; 1945 using std::atomic_exchange; 1946 using std::atomic_exchange_explicit; 1947 using std::atomic_is_lock_free; 1948 using std::atomic_load; 1949 using std::atomic_load_explicit; 1950 using std::atomic_store; 1951 using std::atomic_store_explicit; 1952 using std::enable_shared_from_this; 1953 using std::hash; 1954 using std::owner_less; 1955 using std::weak_ptr; 1956 #if __cpp_lib_out_ptr 1957 using std::out_ptr; 1958 using std::inout_ptr; 1959 using std::out_ptr_t; 1960 using std::inout_ptr_t; 1961 #endif 1962 } 1963 1964 // 20.4 <memory_resource> 1965 export namespace std::pmr 1966 { 1967 using std::pmr::memory_resource; 1968 using std::pmr::operator==; 1969 using std::pmr::get_default_resource; 1970 using std::pmr::monotonic_buffer_resource; 1971 using std::pmr::new_delete_resource; 1972 using std::pmr::null_memory_resource; 1973 using std::pmr::polymorphic_allocator; 1974 using std::pmr::pool_options; 1975 using std::pmr::set_default_resource; 1976 using std::pmr::synchronized_pool_resource; 1977 using std::pmr::unsynchronized_pool_resource; 1978 } 1979 1980 // <mutex> 1981 export namespace std 1982 { 1983 using std::adopt_lock; 1984 using std::adopt_lock_t; 1985 using std::call_once; 1986 using std::defer_lock; 1987 using std::defer_lock_t; 1988 using std::lock; 1989 using std::lock_guard; 1990 using std::mutex; 1991 using std::once_flag; 1992 using std::recursive_mutex; 1993 using std::recursive_timed_mutex; 1994 using std::scoped_lock; 1995 using std::swap; 1996 using std::timed_mutex; 1997 using std::try_lock; 1998 using std::try_to_lock; 1999 using std::try_to_lock_t; 2000 using std::unique_lock; 2001 } 2002 2003 // 17.6.2 <new> [new.syn] 2004 export namespace std 2005 { 2006 using std::align_val_t; 2007 using std::bad_alloc; 2008 using std::bad_array_new_length; 2009 using std::destroying_delete; 2010 using std::destroying_delete_t; 2011 using std::get_new_handler; 2012 using std::hardware_destructive_interference_size; 2013 using std::hardware_constructive_interference_size; 2014 using std::launder; 2015 using std::new_handler; 2016 using std::nothrow; 2017 using std::nothrow_t; 2018 using std::set_new_handler; 2019 } 2020 export 2021 { 2022 using ::operator new; 2023 using ::operator delete; 2024 using ::operator new[]; 2025 using ::operator delete[]; 2026 } 2027 2028 // <numbers> 2029 export namespace std::numbers 2030 { 2031 using std::numbers::e; 2032 using std::numbers::e_v; 2033 using std::numbers::egamma; 2034 using std::numbers::egamma_v; 2035 using std::numbers::inv_pi; 2036 using std::numbers::inv_pi_v; 2037 using std::numbers::inv_sqrt3; 2038 using std::numbers::inv_sqrt3_v; 2039 using std::numbers::inv_sqrtpi; 2040 using std::numbers::inv_sqrtpi_v; 2041 using std::numbers::ln10; 2042 using std::numbers::ln10_v; 2043 using std::numbers::ln2; 2044 using std::numbers::ln2_v; 2045 using std::numbers::log10e; 2046 using std::numbers::log10e_v; 2047 using std::numbers::log2e; 2048 using std::numbers::log2e_v; 2049 using std::numbers::phi; 2050 using std::numbers::phi_v; 2051 using std::numbers::pi; 2052 using std::numbers::pi_v; 2053 using std::numbers::sqrt2; 2054 using std::numbers::sqrt2_v; 2055 using std::numbers::sqrt3; 2056 using std::numbers::sqrt3_v; 2057 } 2058 2059 // <numeric> 2060 export namespace std 2061 { 2062 using std::accumulate; 2063 using std::adjacent_difference; 2064 using std::exclusive_scan; 2065 using std::inclusive_scan; 2066 using std::inner_product; 2067 using std::iota; 2068 using std::partial_sum; 2069 using std::reduce; 2070 using std::transform_exclusive_scan; 2071 using std::transform_inclusive_scan; 2072 using std::transform_reduce; 2073 using std::gcd; 2074 using std::lcm; 2075 using std::midpoint; 2076 #if __cpp_lib_ranges_iota 2077 namespace ranges 2078 { 2079 using ranges::iota; 2080 using ranges::iota_result; 2081 } 2082 #endif 2083 #if __cpp_lib_saturation_arithmetic 2084 using std::add_sat; 2085 using std::sub_sat; 2086 using std::mul_sat; 2087 using std::div_sat; 2088 using std::saturate_cast; 2089 #endif 2090 } 2091 2092 // <optional> 2093 export namespace std 2094 { 2095 using std::bad_optional_access; 2096 using std::nullopt; 2097 using std::nullopt_t; 2098 using std::optional; 2099 using std::operator==; 2100 using std::operator!=; 2101 using std::operator<; 2102 using std::operator>; 2103 using std::operator<=; 2104 using std::operator>=; 2105 using std::operator<=>; 2106 using std::hash; 2107 using std::make_optional; 2108 using std::swap; 2109 } 2110 2111 // <ostream> 2112 export namespace std 2113 { 2114 using std::basic_ostream; 2115 using std::endl; 2116 using std::ends; 2117 using std::flush; 2118 using std::ostream; 2119 using std::wostream; 2120 using std::operator<<; 2121 #ifdef __cpp_lib_syncbuf 2122 using std::emit_on_flush; 2123 using std::noemit_on_flush; 2124 using std::flush_emit; 2125 #endif 2126 } 2127 2128 // <print> 2129 #if __cpp_lib_print 2130 export namespace std 2131 { 2132 using std::print; 2133 using std::println; 2134 using std::vprint_unicode; 2135 //FIXME using std::vprint_unicode_buffered; 2136 using std::vprint_nonunicode; 2137 //FIXME using std::vprint_nonunicode_buffered; 2138 } 2139 #endif 2140 2141 // <queue> 2142 export namespace std 2143 { 2144 using std::queue; 2145 using std::operator==; 2146 using std::operator!=; 2147 using std::operator<; 2148 using std::operator>; 2149 using std::operator<=; 2150 using std::operator>=; 2151 using std::operator<=>; 2152 using std::priority_queue; 2153 using std::swap; 2154 using std::uses_allocator; 2155 } 2156 2157 // <random> 2158 export namespace std 2159 { 2160 using std::bernoulli_distribution; 2161 using std::binomial_distribution; 2162 using std::cauchy_distribution; 2163 using std::chi_squared_distribution; 2164 using std::default_random_engine; 2165 using std::discard_block_engine; 2166 using std::discrete_distribution; 2167 using std::exponential_distribution; 2168 using std::extreme_value_distribution; 2169 using std::fisher_f_distribution; 2170 using std::gamma_distribution; 2171 using std::generate_canonical; 2172 using std::geometric_distribution; 2173 using std::independent_bits_engine; 2174 using std::knuth_b; 2175 using std::linear_congruential_engine; 2176 using std::lognormal_distribution; 2177 using std::mersenne_twister_engine; 2178 using std::minstd_rand; 2179 using std::minstd_rand0; 2180 using std::mt19937; 2181 using std::mt19937_64; 2182 using std::negative_binomial_distribution; 2183 using std::normal_distribution; 2184 using std::piecewise_constant_distribution; 2185 using std::piecewise_linear_distribution; 2186 using std::poisson_distribution; 2187 using std::random_device; 2188 using std::ranlux24; 2189 using std::ranlux24_base; 2190 using std::ranlux48; 2191 using std::ranlux48_base; 2192 using std::seed_seq; 2193 using std::shuffle_order_engine; 2194 using std::student_t_distribution; 2195 using std::subtract_with_carry_engine; 2196 using std::uniform_int_distribution; 2197 using std::uniform_random_bit_generator; 2198 using std::uniform_real_distribution; 2199 using std::weibull_distribution; 2200 } 2201 2202 // <ranges> 2203 export namespace std 2204 { 2205 namespace ranges 2206 { 2207 using std::ranges::begin; 2208 using std::ranges::cbegin; 2209 using std::ranges::cdata; 2210 using std::ranges::cend; 2211 using std::ranges::crbegin; 2212 using std::ranges::crend; 2213 using std::ranges::data; 2214 using std::ranges::empty; 2215 using std::ranges::end; 2216 using std::ranges::rbegin; 2217 using std::ranges::rend; 2218 using std::ranges::size; 2219 using std::ranges::ssize; 2220 using std::ranges::bidirectional_range; 2221 using std::ranges::borrowed_range; 2222 using std::ranges::common_range; 2223 using std::ranges::contiguous_range; 2224 using std::ranges::disable_sized_range; 2225 using std::ranges::enable_borrowed_range; 2226 using std::ranges::enable_view; 2227 using std::ranges::forward_range; 2228 using std::ranges::get; 2229 using std::ranges::input_range; 2230 using std::ranges::iterator_t; 2231 using std::ranges::output_range; 2232 using std::ranges::random_access_range; 2233 using std::ranges::range; 2234 using std::ranges::range_common_reference_t; 2235 using std::ranges::range_difference_t; 2236 using std::ranges::range_reference_t; 2237 using std::ranges::range_rvalue_reference_t; 2238 using std::ranges::range_size_t; 2239 using std::ranges::range_value_t; 2240 using std::ranges::sentinel_t; 2241 using std::ranges::sized_range; 2242 using std::ranges::subrange; 2243 using std::ranges::subrange_kind; 2244 using std::ranges::view; 2245 using std::ranges::view_base; 2246 using std::ranges::view_interface; 2247 using std::ranges::viewable_range; 2248 } 2249 using std::ranges::get; 2250 namespace ranges 2251 { 2252 using std::ranges::borrowed_iterator_t; 2253 using std::ranges::borrowed_subrange_t; 2254 using std::ranges::dangling; 2255 using std::ranges::empty_view; 2256 namespace views 2257 { 2258 using std::ranges::views::empty; 2259 } 2260 using std::ranges::single_view; 2261 namespace views 2262 { 2263 using std::ranges::views::single; 2264 } 2265 using std::ranges::iota_view; 2266 namespace views 2267 { 2268 using std::ranges::views::iota; 2269 } 2270 using std::ranges::basic_istream_view; 2271 using std::ranges::istream_view; 2272 using std::ranges::wistream_view; 2273 namespace views 2274 { 2275 using std::ranges::views::istream; 2276 } 2277 namespace views 2278 { 2279 using std::ranges::views::all; 2280 using std::ranges::views::all_t; 2281 } 2282 using std::ranges::filter_view; 2283 using std::ranges::owning_view; 2284 using std::ranges::ref_view; 2285 namespace views 2286 { 2287 using std::ranges::views::filter; 2288 } 2289 using std::ranges::transform_view; 2290 namespace views 2291 { 2292 using std::ranges::views::transform; 2293 } 2294 using std::ranges::take_view; 2295 namespace views 2296 { 2297 using std::ranges::views::take; 2298 } 2299 using std::ranges::take_while_view; 2300 namespace views 2301 { 2302 using std::ranges::views::take_while; 2303 } 2304 using std::ranges::drop_view; 2305 namespace views 2306 { 2307 using std::ranges::views::drop; 2308 } 2309 using std::ranges::drop_while_view; 2310 namespace views 2311 { 2312 using std::ranges::views::drop_while; 2313 } 2314 using std::ranges::join_view; 2315 namespace views 2316 { 2317 using std::ranges::views::join; 2318 } 2319 using std::ranges::lazy_split_view; 2320 using std::ranges::split_view; 2321 namespace views 2322 { 2323 using std::ranges::views::lazy_split; 2324 using std::ranges::views::split; 2325 } 2326 namespace views 2327 { 2328 using std::ranges::views::counted; 2329 } 2330 using std::ranges::common_view; 2331 namespace views 2332 { 2333 using std::ranges::views::common; 2334 } 2335 using std::ranges::reverse_view; 2336 namespace views 2337 { 2338 using std::ranges::views::reverse; 2339 } 2340 using std::ranges::elements_view; 2341 using std::ranges::keys_view; 2342 using std::ranges::values_view; 2343 namespace views 2344 { 2345 using std::ranges::views::elements; 2346 using std::ranges::views::keys; 2347 using std::ranges::views::values; 2348 } 2349 #if __cpp_lib_ranges >= 202202L 2350 using ranges::range_adaptor_closure; 2351 #endif 2352 } 2353 namespace views = ranges::views; 2354 using std::tuple_element; 2355 using std::tuple_size; 2356 namespace ranges 2357 { 2358 #if __glibcxx_ranges_as_const // >= C++23 2359 using ranges::constant_range; 2360 using ranges::const_iterator_t; 2361 using ranges::const_sentinel_t; 2362 using ranges::range_const_reference_t; 2363 using ranges::as_const_view; 2364 namespace views { using views::as_const; } 2365 #endif 2366 #ifdef __glibcxx_generator // C++ >= 23 && __glibcxx_coroutine 2367 using ranges::elements_of; 2368 #endif 2369 #ifdef __cpp_lib_ranges_as_rvalue // C++ >= 23 2370 using ranges::as_rvalue_view; 2371 namespace views { using views::as_rvalue; } 2372 #endif 2373 #ifdef __cpp_lib_ranges_chunk // C++ >= 23 2374 using ranges::chunk_view; 2375 namespace views { using views::chunk; } 2376 #endif 2377 #ifdef __cpp_lib_ranges_slide // C++ >= 23 2378 using ranges::slide_view; 2379 namespace views { using views::slide; } 2380 #endif 2381 #ifdef __cpp_lib_ranges_zip // C++ >= 23 2382 using ranges::zip_view; 2383 using ranges::zip_transform_view; 2384 using ranges::adjacent_view; 2385 using ranges::adjacent_transform_view; 2386 namespace views { 2387 using views::zip; 2388 using views::zip_transform; 2389 using views::adjacent; 2390 using views::adjacent_transform; 2391 using views::pairwise; 2392 using views::pairwise_transform; 2393 } 2394 #endif 2395 #ifdef __cpp_lib_ranges_chunk_by // C++ >= 23 2396 using ranges::chunk_by_view; 2397 namespace views { using views::chunk_by; } 2398 #endif 2399 #ifdef __cpp_lib_ranges_join_with // C++ >= 23 2400 using ranges::join_with_view; 2401 namespace views { using views::join_with; } 2402 #endif 2403 #ifdef __cpp_lib_ranges_repeat // C++ >= 23 2404 using ranges::repeat_view; 2405 namespace views { using views::repeat; } 2406 #endif 2407 #ifdef __cpp_lib_ranges_stride // C++ >= 23 2408 using ranges::stride_view; 2409 namespace views { using views::stride; } 2410 #endif 2411 #ifdef __cpp_lib_ranges_cartesian_product // C++ >= 23 2412 using ranges::cartesian_product_view; 2413 namespace views { using views::cartesian_product; } 2414 #endif 2415 #ifdef __cpp_lib_ranges_enumerate // C++ >= 23 2416 using ranges::enumerate_view; 2417 namespace views { using views::enumerate; } 2418 #endif 2419 #if __cpp_lib_ranges_concat // C++ >= C++26 2420 using ranges::concat_view; 2421 namespace views { using views::concat; } 2422 #endif 2423 #if __cpp_lib_ranges_cache_latest // C++ >= C++26 2424 using ranges::cache_latest_view; 2425 namespace views { using views::cache_latest; } 2426 #endif 2427 #if __glibcxx_ranges_to_input // C++ >= 26 2428 using ranges::to_input_view; 2429 namespace views { using views::to_input; } 2430 #endif 2431 } 2432 #if __glibcxx_ranges_to_container // C++ >= 23 2433 namespace ranges { using ranges::to; } 2434 using std::from_range_t; 2435 using std::from_range; 2436 #endif 2437 } 2438 2439 // <ratio> 2440 export namespace std 2441 { 2442 using std::atto; 2443 using std::centi; 2444 using std::deca; 2445 using std::deci; 2446 using std::exa; 2447 using std::femto; 2448 using std::giga; 2449 using std::hecto; 2450 using std::kilo; 2451 using std::mega; 2452 using std::micro; 2453 using std::milli; 2454 using std::nano; 2455 using std::peta; 2456 using std::pico; 2457 using std::ratio; 2458 using std::ratio_add; 2459 using std::ratio_divide; 2460 using std::ratio_equal; 2461 using std::ratio_equal_v; 2462 using std::ratio_greater; 2463 using std::ratio_greater_equal; 2464 using std::ratio_greater_equal_v; 2465 using std::ratio_greater_v; 2466 using std::ratio_less; 2467 using std::ratio_less_equal; 2468 using std::ratio_less_equal_v; 2469 using std::ratio_less_v; 2470 using std::ratio_multiply; 2471 using std::ratio_not_equal; 2472 using std::ratio_not_equal_v; 2473 using std::ratio_subtract; 2474 using std::tera; 2475 } 2476 2477 // FIXME <rcu> 2478 2479 // <regex> 2480 export namespace std 2481 { 2482 namespace regex_constants 2483 { 2484 using std::regex_constants::error_type; 2485 using std::regex_constants::match_flag_type; 2486 using std::regex_constants::syntax_option_type; 2487 using std::regex_constants::operator&; 2488 using std::regex_constants::operator&=; 2489 using std::regex_constants::operator^; 2490 using std::regex_constants::operator^=; 2491 using std::regex_constants::operator|; 2492 using std::regex_constants::operator|=; 2493 using std::regex_constants::operator~; 2494 using std::regex_constants::awk; 2495 using std::regex_constants::basic; 2496 using std::regex_constants::collate; 2497 using std::regex_constants::ECMAScript; 2498 using std::regex_constants::egrep; 2499 using std::regex_constants::extended; 2500 using std::regex_constants::grep; 2501 using std::regex_constants::icase; 2502 using std::regex_constants::multiline; 2503 using std::regex_constants::nosubs; 2504 using std::regex_constants::optimize; 2505 using std::regex_constants::format_default; 2506 using std::regex_constants::format_first_only; 2507 using std::regex_constants::format_no_copy; 2508 using std::regex_constants::format_sed; 2509 using std::regex_constants::match_any; 2510 using std::regex_constants::match_continuous; 2511 using std::regex_constants::match_default; 2512 using std::regex_constants::match_not_bol; 2513 using std::regex_constants::match_not_bow; 2514 using std::regex_constants::match_not_eol; 2515 using std::regex_constants::match_not_eow; 2516 using std::regex_constants::match_not_null; 2517 using std::regex_constants::match_prev_avail; 2518 using std::regex_constants::error_backref; 2519 using std::regex_constants::error_badbrace; 2520 using std::regex_constants::error_badrepeat; 2521 using std::regex_constants::error_brace; 2522 using std::regex_constants::error_brack; 2523 using std::regex_constants::error_collate; 2524 using std::regex_constants::error_complexity; 2525 using std::regex_constants::error_ctype; 2526 using std::regex_constants::error_escape; 2527 using std::regex_constants::error_paren; 2528 using std::regex_constants::error_range; 2529 using std::regex_constants::error_space; 2530 using std::regex_constants::error_stack; 2531 } 2532 using std::basic_regex; 2533 using std::csub_match; 2534 using std::regex; 2535 using std::regex_error; 2536 using std::regex_traits; 2537 using std::ssub_match; 2538 using std::sub_match; 2539 using std::swap; 2540 using std::wcsub_match; 2541 using std::wregex; 2542 using std::wssub_match; 2543 using std::operator==; 2544 using std::operator<=>; 2545 using std::operator<<; 2546 using std::cmatch; 2547 using std::cregex_iterator; 2548 using std::cregex_token_iterator; 2549 using std::match_results; 2550 using std::regex_iterator; 2551 using std::regex_match; 2552 using std::regex_replace; 2553 using std::regex_search; 2554 using std::regex_token_iterator; 2555 using std::smatch; 2556 using std::sregex_iterator; 2557 using std::sregex_token_iterator; 2558 using std::wcmatch; 2559 using std::wcregex_iterator; 2560 using std::wcregex_token_iterator; 2561 using std::wsmatch; 2562 using std::wsregex_iterator; 2563 using std::wsregex_token_iterator; 2564 namespace pmr 2565 { 2566 #if _GLIBCXX_USE_CXX11_ABI 2567 using std::pmr::cmatch; 2568 using std::pmr::match_results; 2569 using std::pmr::smatch; 2570 using std::pmr::wcmatch; 2571 using std::pmr::wsmatch; 2572 #endif 2573 } 2574 } 2575 2576 // 20.5 <scoped_allocator> 2577 export namespace std 2578 { 2579 using std::scoped_allocator_adaptor; 2580 using std::operator==; 2581 } 2582 2583 // <semaphore> 2584 export namespace std 2585 { 2586 using std::binary_semaphore; 2587 using std::counting_semaphore; 2588 } 2589 2590 // <set> 2591 export namespace std 2592 { 2593 using std::set; 2594 using std::operator==; 2595 using std::operator<=>; 2596 using std::erase_if; 2597 using std::multiset; 2598 using std::swap; 2599 namespace pmr 2600 { 2601 using std::pmr::multiset; 2602 using std::pmr::set; 2603 } 2604 } 2605 2606 // <shared_mutex> 2607 export namespace std 2608 { 2609 using std::shared_lock; 2610 using std::shared_mutex; 2611 using std::shared_timed_mutex; 2612 using std::swap; 2613 } 2614 2615 // 17.8.1 <source_location> 2616 export namespace std 2617 { 2618 using std::source_location; 2619 } 2620 2621 // <span> 2622 export namespace std 2623 { 2624 using std::dynamic_extent; 2625 using std::span; 2626 namespace ranges 2627 { 2628 using std::ranges::enable_borrowed_range; 2629 using std::ranges::enable_view; 2630 } 2631 using std::as_bytes; 2632 using std::as_writable_bytes; 2633 } 2634 2635 #if __cpp_lib_spanstream 2636 // <spanstream> 2637 export namespace std 2638 { 2639 using std::basic_spanbuf; 2640 using std::spanbuf; 2641 using std::wspanbuf; 2642 using std::basic_ispanstream; 2643 using std::ispanstream; 2644 using std::wispanstream; 2645 using std::basic_ospanstream; 2646 using std::ospanstream; 2647 using std::wospanstream; 2648 using std::basic_spanstream; 2649 using std::spanstream; 2650 using std::wspanstream; 2651 } 2652 #endif 2653 2654 // <sstream> 2655 export namespace std 2656 { 2657 using std::basic_istringstream; 2658 using std::basic_ostringstream; 2659 using std::basic_stringbuf; 2660 using std::basic_stringstream; 2661 using std::istringstream; 2662 using std::ostringstream; 2663 using std::stringbuf; 2664 using std::stringstream; 2665 using std::swap; 2666 using std::wistringstream; 2667 using std::wostringstream; 2668 using std::wstringbuf; 2669 using std::wstringstream; 2670 } 2671 2672 // <stack> 2673 export namespace std 2674 { 2675 using std::stack; 2676 using std::operator==; 2677 using std::operator!=; 2678 using std::operator<; 2679 using std::operator>; 2680 using std::operator<=; 2681 using std::operator>=; 2682 using std::operator<=>; 2683 using std::swap; 2684 using std::uses_allocator; 2685 } 2686 2687 // 19.6 <stacktrace> 2688 #if __cpp_lib_stacktrace 2689 export namespace std 2690 { 2691 using std::stacktrace_entry; 2692 using std::basic_stacktrace; 2693 using std::stacktrace; 2694 using std::swap; 2695 using std::to_string; 2696 using std::operator<<; 2697 using std::formatter; 2698 namespace pmr 2699 { 2700 using std::pmr::stacktrace; 2701 } 2702 using std::hash; 2703 } 2704 #endif 2705 2706 // 19.2 <stdexcept> 2707 export namespace std 2708 { 2709 using std::domain_error; 2710 using std::invalid_argument; 2711 using std::length_error; 2712 using std::logic_error; 2713 using std::out_of_range; 2714 using std::overflow_error; 2715 using std::range_error; 2716 using std::runtime_error; 2717 using std::underflow_error; 2718 } 2719 2720 // 17.4.2 <stdfloat> 2721 export namespace std 2722 { 2723 #ifdef __STDCPP_FLOAT16_T__ 2724 using std::float16_t; 2725 #endif 2726 #ifdef __STDCPP_FLOAT32_T__ 2727 using std::float32_t; 2728 #endif 2729 #ifdef __STDCPP_FLOAT64_T__ 2730 using std::float64_t; 2731 #endif 2732 #ifdef __STDCPP_FLOAT128_T__ 2733 using std::float128_t; 2734 #endif 2735 #ifdef __STDCPP_BFLOAT16_T__ 2736 using std::bfloat16_t; 2737 #endif 2738 } 2739 2740 // <stop_token> 2741 #if __cpp_lib_jthread 2742 export namespace std 2743 { 2744 using std::stop_token; 2745 using std::stop_source; 2746 using std::nostopstate_t; 2747 using std::nostopstate; 2748 using std::stop_callback; 2749 #if __cpp_lib_senders 2750 using std::never_stop_token; 2751 using std::inplace_stop_token; 2752 using std::inplace_stop_source; 2753 using std::inplace_stop_callback; 2754 using std::stop_callback_for; 2755 #endif 2756 } 2757 #endif 2758 2759 // <streambuf> 2760 export namespace std 2761 { 2762 using std::basic_streambuf; 2763 using std::streambuf; 2764 using std::wstreambuf; 2765 } 2766 2767 // <string> 2768 export namespace std 2769 { 2770 using std::basic_string; 2771 using std::char_traits; 2772 using std::operator+; 2773 using std::operator==; 2774 using std::operator<=>; 2775 using std::swap; 2776 using std::operator>>; 2777 using std::operator<<; 2778 using std::erase; 2779 using std::erase_if; 2780 using std::getline; 2781 using std::stod; 2782 using std::stof; 2783 using std::stoi; 2784 using std::stol; 2785 using std::stold; 2786 using std::stoll; 2787 using std::stoul; 2788 using std::stoull; 2789 using std::string; 2790 using std::to_string; 2791 using std::to_wstring; 2792 using std::u16string; 2793 using std::u32string; 2794 using std::u8string; 2795 using std::wstring; 2796 namespace pmr 2797 { 2798 #if _GLIBCXX_USE_CXX11_ABI 2799 using std::pmr::basic_string; 2800 using std::pmr::string; 2801 using std::pmr::u16string; 2802 using std::pmr::u32string; 2803 using std::pmr::u8string; 2804 using std::pmr::wstring; 2805 #endif 2806 } 2807 using std::hash; 2808 } 2809 export namespace std::inline literals::inline string_literals 2810 { 2811 using std::operator""s; 2812 } 2813 2814 // <string_view> 2815 export namespace std 2816 { 2817 using std::basic_string_view; 2818 namespace ranges 2819 { 2820 using std::ranges::enable_borrowed_range; 2821 using std::ranges::enable_view; 2822 } 2823 using std::operator==; 2824 using std::operator<=>; 2825 using std::operator<<; 2826 using std::hash; 2827 using std::string_view; 2828 using std::u16string_view; 2829 using std::u32string_view; 2830 using std::u8string_view; 2831 using std::wstring_view; 2832 } 2833 export namespace std::inline literals::inline string_view_literals 2834 { 2835 using string_view_literals::operator""sv; 2836 } 2837 2838 // <strstream>: deprecated C++98, removed C++26 2839 export namespace std 2840 { 2841 using std::istrstream; 2842 using std::ostrstream; 2843 using std::strstream; 2844 using std::strstreambuf; 2845 } 2846 2847 // <syncstream> 2848 export namespace std 2849 { 2850 #ifdef __cpp_lib_syncbuf 2851 using std::basic_syncbuf; 2852 using std::swap; 2853 using std::basic_osyncstream; 2854 using std::osyncstream; 2855 using std::syncbuf; 2856 using std::wosyncstream; 2857 using std::wsyncbuf; 2858 #endif 2859 } 2860 2861 // 19.5 <system_error> 2862 export namespace std 2863 { 2864 using std::errc; 2865 using std::error_category; 2866 using std::error_code; 2867 using std::error_condition; 2868 using std::generic_category; 2869 using std::is_error_code_enum; 2870 using std::is_error_condition_enum; 2871 using std::make_error_code; 2872 using std::system_category; 2873 using std::system_error; 2874 using std::operator<<; 2875 using std::make_error_condition; 2876 using std::operator==; 2877 using std::operator<=>; 2878 using std::hash; 2879 using std::is_error_code_enum_v; 2880 using std::is_error_condition_enum_v; 2881 } 2882 2883 // <text_encoding> 2884 #if __cpp_lib_text_encoding 2885 export namespace std 2886 { 2887 using std::text_encoding; 2888 } 2889 #endif 2890 2891 // <thread> 2892 export namespace std 2893 { 2894 using std::swap; 2895 using std::thread; 2896 using std::jthread; 2897 namespace this_thread 2898 { 2899 using std::this_thread::get_id; 2900 using std::this_thread::sleep_for; 2901 using std::this_thread::sleep_until; 2902 using std::this_thread::yield; 2903 } 2904 using std::operator==; 2905 using std::operator<=>; 2906 using std::operator<<; 2907 using std::hash; 2908 } 2909 2910 // <tuple> 2911 export namespace std 2912 { 2913 using std::apply; 2914 using std::forward_as_tuple; 2915 using std::get; 2916 using std::ignore; 2917 using std::make_from_tuple; 2918 using std::make_tuple; 2919 using std::tie; 2920 using std::tuple; 2921 using std::tuple_cat; 2922 using std::tuple_element; 2923 using std::tuple_element_t; 2924 using std::tuple_size; 2925 using std::operator==; 2926 using std::operator<=>; 2927 using std::swap; 2928 using std::tuple_size_v; 2929 using std::uses_allocator; 2930 } 2931 2932 // <type_traits> 2933 export namespace std 2934 { 2935 using std::add_const; 2936 using std::add_const_t; 2937 using std::add_cv; 2938 using std::add_cv_t; 2939 using std::add_lvalue_reference; 2940 using std::add_lvalue_reference_t; 2941 using std::add_pointer; 2942 using std::add_pointer_t; 2943 using std::add_rvalue_reference; 2944 using std::add_rvalue_reference_t; 2945 using std::add_volatile; 2946 using std::add_volatile_t; 2947 using std::aligned_storage; 2948 using std::aligned_storage_t; 2949 using std::aligned_union; 2950 using std::aligned_union_t; 2951 using std::alignment_of; 2952 using std::alignment_of_v; 2953 using std::basic_common_reference; 2954 using std::bool_constant; 2955 using std::common_reference; 2956 using std::common_reference_t; 2957 using std::common_type; 2958 using std::common_type_t; 2959 using std::conditional; 2960 using std::conditional_t; 2961 using std::conjunction; 2962 using std::conjunction_v; 2963 using std::decay; 2964 using std::decay_t; 2965 using std::disjunction; 2966 using std::disjunction_v; 2967 using std::enable_if; 2968 using std::enable_if_t; 2969 using std::extent; 2970 using std::extent_v; 2971 using std::false_type; 2972 using std::has_unique_object_representations; 2973 using std::has_unique_object_representations_v; 2974 using std::has_virtual_destructor; 2975 using std::has_virtual_destructor_v; 2976 using std::integral_constant; 2977 using std::invoke_result; 2978 using std::invoke_result_t; 2979 using std::is_abstract; 2980 using std::is_abstract_v; 2981 using std::is_aggregate; 2982 using std::is_aggregate_v; 2983 using std::is_arithmetic; 2984 using std::is_arithmetic_v; 2985 using std::is_array; 2986 using std::is_array_v; 2987 using std::is_assignable; 2988 using std::is_assignable_v; 2989 using std::is_base_of; 2990 using std::is_base_of_v; 2991 using std::is_bounded_array; 2992 using std::is_bounded_array_v; 2993 using std::is_class; 2994 using std::is_class_v; 2995 using std::is_compound; 2996 using std::is_compound_v; 2997 using std::is_const; 2998 using std::is_const_v; 2999 using std::is_constant_evaluated; 3000 using std::is_constructible; 3001 using std::is_constructible_v; 3002 using std::is_convertible; 3003 using std::is_convertible_v; 3004 using std::is_copy_assignable; 3005 using std::is_copy_assignable_v; 3006 using std::is_copy_constructible; 3007 using std::is_copy_constructible_v; 3008 using std::is_default_constructible; 3009 using std::is_default_constructible_v; 3010 using std::is_destructible; 3011 using std::is_destructible_v; 3012 using std::is_empty; 3013 using std::is_empty_v; 3014 using std::is_enum; 3015 using std::is_enum_v; 3016 using std::is_final; 3017 using std::is_final_v; 3018 using std::is_floating_point; 3019 using std::is_floating_point_v; 3020 using std::is_function; 3021 using std::is_function_v; 3022 using std::is_fundamental; 3023 using std::is_fundamental_v; 3024 using std::is_integral; 3025 using std::is_integral_v; 3026 using std::is_invocable; 3027 using std::is_invocable_r; 3028 using std::is_invocable_r_v; 3029 using std::is_invocable_v; 3030 using std::is_lvalue_reference; 3031 using std::is_lvalue_reference_v; 3032 using std::is_member_function_pointer; 3033 using std::is_member_function_pointer_v; 3034 using std::is_member_object_pointer; 3035 using std::is_member_object_pointer_v; 3036 using std::is_member_pointer; 3037 using std::is_member_pointer_v; 3038 using std::is_move_assignable; 3039 using std::is_move_assignable_v; 3040 using std::is_move_constructible; 3041 using std::is_move_constructible_v; 3042 using std::is_nothrow_assignable; 3043 using std::is_nothrow_assignable_v; 3044 using std::is_nothrow_constructible; 3045 using std::is_nothrow_constructible_v; 3046 using std::is_nothrow_convertible; 3047 using std::is_nothrow_convertible_v; 3048 using std::is_nothrow_copy_assignable; 3049 using std::is_nothrow_copy_assignable_v; 3050 using std::is_nothrow_copy_constructible; 3051 using std::is_nothrow_copy_constructible_v; 3052 using std::is_nothrow_default_constructible; 3053 using std::is_nothrow_default_constructible_v; 3054 using std::is_nothrow_destructible; 3055 using std::is_nothrow_destructible_v; 3056 using std::is_nothrow_invocable; 3057 using std::is_nothrow_invocable_r; 3058 using std::is_nothrow_invocable_r_v; 3059 using std::is_nothrow_invocable_v; 3060 using std::is_nothrow_move_assignable; 3061 using std::is_nothrow_move_assignable_v; 3062 using std::is_nothrow_move_constructible; 3063 using std::is_nothrow_move_constructible_v; 3064 using std::is_nothrow_swappable; 3065 using std::is_nothrow_swappable_v; 3066 using std::is_nothrow_swappable_with; 3067 using std::is_nothrow_swappable_with_v; 3068 using std::is_null_pointer; 3069 using std::is_null_pointer_v; 3070 using std::is_object; 3071 using std::is_object_v; 3072 using std::is_pod; 3073 using std::is_pod_v; 3074 using std::is_pointer; 3075 using std::is_pointer_v; 3076 using std::is_polymorphic; 3077 using std::is_polymorphic_v; 3078 using std::is_reference; 3079 using std::is_reference_v; 3080 using std::is_rvalue_reference; 3081 using std::is_rvalue_reference_v; 3082 using std::is_same; 3083 using std::is_same_v; 3084 using std::is_scalar; 3085 using std::is_scalar_v; 3086 using std::is_signed; 3087 using std::is_signed_v; 3088 using std::is_standard_layout; 3089 using std::is_standard_layout_v; 3090 using std::is_swappable; 3091 using std::is_swappable_v; 3092 using std::is_swappable_with; 3093 using std::is_swappable_with_v; 3094 using std::is_trivial; 3095 using std::is_trivial_v; 3096 using std::is_trivially_assignable; 3097 using std::is_trivially_assignable_v; 3098 using std::is_trivially_constructible; 3099 using std::is_trivially_constructible_v; 3100 using std::is_trivially_copy_assignable; 3101 using std::is_trivially_copy_assignable_v; 3102 using std::is_trivially_copy_constructible; 3103 using std::is_trivially_copy_constructible_v; 3104 using std::is_trivially_copyable; 3105 using std::is_trivially_copyable_v; 3106 using std::is_trivially_default_constructible; 3107 using std::is_trivially_default_constructible_v; 3108 using std::is_trivially_destructible; 3109 using std::is_trivially_destructible_v; 3110 using std::is_trivially_move_assignable; 3111 using std::is_trivially_move_assignable_v; 3112 using std::is_trivially_move_constructible; 3113 using std::is_trivially_move_constructible_v; 3114 using std::is_unbounded_array; 3115 using std::is_unbounded_array_v; 3116 using std::is_union; 3117 using std::is_union_v; 3118 using std::is_unsigned; 3119 using std::is_unsigned_v; 3120 #if __cpp_lib_is_virtual_base_of 3121 using std::is_virtual_base_of; 3122 using std::is_virtual_base_of_v; 3123 #endif 3124 using std::is_void; 3125 using std::is_void_v; 3126 using std::is_volatile; 3127 using std::is_volatile_v; 3128 using std::make_signed; 3129 using std::make_signed_t; 3130 using std::make_unsigned; 3131 using std::make_unsigned_t; 3132 using std::negation; 3133 using std::negation_v; 3134 using std::rank; 3135 using std::rank_v; 3136 using std::remove_all_extents; 3137 using std::remove_all_extents_t; 3138 using std::remove_const; 3139 using std::remove_const_t; 3140 using std::remove_cv; 3141 using std::remove_cv_t; 3142 using std::remove_cvref; 3143 using std::remove_cvref_t; 3144 using std::remove_extent; 3145 using std::remove_extent_t; 3146 using std::remove_pointer; 3147 using std::remove_pointer_t; 3148 using std::remove_reference; 3149 using std::remove_reference_t; 3150 using std::remove_volatile; 3151 using std::remove_volatile_t; 3152 using std::true_type; 3153 using std::type_identity; 3154 using std::type_identity_t; 3155 using std::underlying_type; 3156 using std::underlying_type_t; 3157 using std::unwrap_ref_decay; 3158 using std::unwrap_ref_decay_t; 3159 using std::unwrap_reference; 3160 using std::unwrap_reference_t; 3161 using std::void_t; 3162 #if __cpp_lib_reference_from_temporary 3163 using std::reference_converts_from_temporary; 3164 using std::reference_converts_from_temporary_v; 3165 using std::reference_constructs_from_temporary; 3166 using std::reference_constructs_from_temporary_v; 3167 #endif 3168 #if __cpp_lib_is_layout_compatible 3169 using std::is_corresponding_member; 3170 using std::is_layout_compatible; 3171 using std::is_layout_compatible_v; 3172 #endif 3173 #if __cpp_lib_is_pointer_interconvertible 3174 using std::is_pointer_interconvertible_base_of; 3175 using std::is_pointer_interconvertible_base_of_v; 3176 using std::is_pointer_interconvertible_with_class; 3177 #endif 3178 #if __cpp_lib_is_scoped_enum 3179 using std::is_scoped_enum; 3180 using std::is_scoped_enum_v; 3181 #endif 3182 } 3183 3184 // <typeindex> 3185 export namespace std 3186 { 3187 using std::hash; 3188 using std::type_index; 3189 } 3190 3191 // 17.7.2 <typeinfo> [typeinfo.syn] 3192 export namespace std 3193 { 3194 using std::bad_cast; 3195 using std::bad_typeid; 3196 using std::type_info; 3197 } 3198 3199 // <unordered_map> 3200 export namespace std 3201 { 3202 using std::unordered_map; 3203 using std::unordered_multimap; 3204 using std::operator==; 3205 using std::erase_if; 3206 using std::swap; 3207 namespace pmr 3208 { 3209 using std::pmr::unordered_map; 3210 using std::pmr::unordered_multimap; 3211 } 3212 } 3213 3214 // <unordered_set> 3215 export namespace std 3216 { 3217 using std::unordered_multiset; 3218 using std::unordered_set; 3219 using std::operator==; 3220 using std::erase_if; 3221 using std::swap; 3222 namespace pmr 3223 { 3224 using std::pmr::unordered_multiset; 3225 using std::pmr::unordered_set; 3226 } 3227 } 3228 3229 // <utility> 3230 export namespace std 3231 { 3232 using std::as_const; 3233 using std::cmp_equal; 3234 using std::cmp_greater; 3235 using std::cmp_greater_equal; 3236 using std::cmp_less; 3237 using std::cmp_less_equal; 3238 using std::cmp_not_equal; 3239 using std::declval; 3240 using std::exchange; 3241 using std::forward; 3242 #if __cpp_lib_forward_like 3243 using std::forward_like; 3244 #endif 3245 using std::in_range; 3246 using std::index_sequence; 3247 using std::index_sequence_for; 3248 using std::integer_sequence; 3249 using std::make_index_sequence; 3250 using std::make_integer_sequence; 3251 using std::move; 3252 using std::move_if_noexcept; 3253 using std::pair; 3254 using std::swap; 3255 using std::operator==; 3256 using std::operator<=>; 3257 using std::get; 3258 using std::in_place; 3259 using std::in_place_index; 3260 using std::in_place_index_t; 3261 using std::in_place_t; 3262 using std::in_place_type; 3263 using std::in_place_type_t; 3264 using std::make_pair; 3265 using std::piecewise_construct; 3266 using std::piecewise_construct_t; 3267 #if __cpp_lib_to_underlying 3268 using std::to_underlying; 3269 #endif 3270 using std::tuple_element; 3271 using std::tuple_size; 3272 #pragma GCC diagnostic push 3273 #pragma GCC diagnostic ignored "-Wdeprecated-declarations" 3274 namespace rel_ops 3275 { 3276 using std::rel_ops::operator!=; 3277 using std::rel_ops::operator>; 3278 using std::rel_ops::operator<=; 3279 using std::rel_ops::operator>=; 3280 } 3281 #pragma GCC diagnostic pop 3282 #if __cpp_lib_unreachable 3283 using std::unreachable; 3284 #endif 3285 } 3286 3287 // <valarray> 3288 export namespace std 3289 { 3290 using std::gslice; 3291 using std::gslice_array; 3292 using std::indirect_array; 3293 using std::mask_array; 3294 using std::slice; 3295 using std::slice_array; 3296 using std::swap; 3297 using std::valarray; 3298 using std::operator*; 3299 using std::operator/; 3300 using std::operator%; 3301 using std::operator+; 3302 using std::operator-; 3303 using std::operator^; 3304 using std::operator&; 3305 using std::operator|; 3306 using std::operator<<; 3307 using std::operator>>; 3308 using std::operator&&; 3309 using std::operator||; 3310 using std::operator==; 3311 using std::operator!=; 3312 using std::operator<; 3313 using std::operator>; 3314 using std::operator<=; 3315 using std::operator>=; 3316 using std::abs; 3317 using std::acos; 3318 using std::asin; 3319 using std::atan; 3320 using std::atan2; 3321 using std::begin; 3322 using std::cos; 3323 using std::cosh; 3324 using std::end; 3325 using std::exp; 3326 using std::log; 3327 using std::log10; 3328 using std::pow; 3329 using std::sin; 3330 using std::sinh; 3331 using std::sqrt; 3332 using std::tan; 3333 using std::tanh; 3334 } 3335 3336 // <variant> 3337 export namespace std 3338 { 3339 using std::get; 3340 using std::get_if; 3341 using std::holds_alternative; 3342 using std::variant; 3343 using std::variant_alternative; 3344 using std::variant_alternative_t; 3345 using std::variant_npos; 3346 using std::variant_size; 3347 using std::variant_size_v; 3348 using std::operator==; 3349 using std::operator!=; 3350 using std::operator<; 3351 using std::operator>; 3352 using std::operator<=; 3353 using std::operator>=; 3354 using std::operator<=>; 3355 using std::bad_variant_access; 3356 using std::hash; 3357 using std::monostate; 3358 using std::swap; 3359 using std::visit; 3360 } 3361 3362 // <vector> 3363 export namespace std 3364 { 3365 using std::vector; 3366 using std::operator==; 3367 using std::operator<=>; 3368 using std::erase; 3369 using std::erase_if; 3370 using std::swap; 3371 namespace pmr 3372 { 3373 using std::pmr::vector; 3374 } 3375 using std::hash; 3376 } 3377 // C standard library exports for -*- C++ -*- std and std.compat modules 3378 // This file is appended to std.cc.in or std-compat.cc.in. 3379 3380 #ifdef STD_COMPAT 3381 #define C_LIB_NAMESPACE 3382 #else 3383 #define C_LIB_NAMESPACE namespace std 3384 #endif 3385 3386 // C standard library headers [tab:headers.cpp.c] 3387 3388 // 19.3 <cassert> 3389 // No exports 3390 3391 // 23.5.1 <cctype> 3392 export C_LIB_NAMESPACE 3393 { 3394 using std::isalnum; 3395 using std::isalpha; 3396 #ifdef _GLIBCXX_USE_C99_CTYPE 3397 using std::isblank; 3398 #endif 3399 using std::iscntrl; 3400 using std::isdigit; 3401 using std::isgraph; 3402 using std::islower; 3403 using std::isprint; 3404 using std::ispunct; 3405 using std::isspace; 3406 using std::isupper; 3407 using std::isxdigit; 3408 using std::tolower; 3409 using std::toupper; 3410 } 3411 3412 // 19.4 <cerrno> 3413 // No exports 3414 3415 // 28.3 <cfenv> 3416 export C_LIB_NAMESPACE 3417 { 3418 #ifdef _GLIBCXX_USE_C99_FENV 3419 using std::feclearexcept; 3420 using std::fegetenv; 3421 using std::fegetexceptflag; 3422 using std::fegetround; 3423 using std::feholdexcept; 3424 using std::fenv_t; 3425 using std::feraiseexcept; 3426 using std::fesetenv; 3427 using std::fesetexceptflag; 3428 using std::fesetround; 3429 using std::fetestexcept; 3430 using std::feupdateenv; 3431 using std::fexcept_t; 3432 #endif 3433 } 3434 3435 // 17.3.7 <cfloat> [cfloat.syn] 3436 // No exports, only provides macros 3437 3438 // 31.13.2 <cinttypes> 3439 export C_LIB_NAMESPACE 3440 { 3441 #ifdef _GLIBCXX_USE_C99_INTTYPES 3442 using std::imaxabs; 3443 using std::imaxdiv; 3444 using std::imaxdiv_t; 3445 using std::strtoimax; 3446 using std::strtoumax; 3447 #if defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_C99_INTTYPES_WCHAR_T 3448 using std::wcstoimax; 3449 using std::wcstoumax; 3450 #endif 3451 #endif 3452 } 3453 3454 // 17.3.6 <climits> [climits.syn] 3455 // No exports, only provides macros 3456 3457 // 30.5 <clocale> 3458 export C_LIB_NAMESPACE 3459 { 3460 using std::lconv; 3461 using std::localeconv; 3462 using std::setlocale; 3463 // LC_* macros not exported 3464 } 3465 3466 // 28.7.1 <cmath> 3467 export C_LIB_NAMESPACE 3468 { 3469 using std::abs; 3470 using std::acos; 3471 using std::acosf; 3472 using std::acosh; 3473 using std::acoshf; 3474 using std::acoshl; 3475 using std::acosl; 3476 using std::asin; 3477 using std::asinf; 3478 using std::asinh; 3479 using std::asinhf; 3480 using std::asinhl; 3481 using std::asinl; 3482 using std::atan; 3483 using std::atan2; 3484 using std::atan2f; 3485 using std::atan2l; 3486 using std::atanf; 3487 using std::atanh; 3488 using std::atanhf; 3489 using std::atanhl; 3490 using std::atanl; 3491 using std::cbrt; 3492 using std::cbrtf; 3493 using std::cbrtl; 3494 using std::ceil; 3495 using std::ceilf; 3496 using std::ceill; 3497 using std::copysign; 3498 using std::copysignf; 3499 using std::copysignl; 3500 using std::cos; 3501 using std::cosf; 3502 using std::cosh; 3503 using std::coshf; 3504 using std::coshl; 3505 using std::cosl; 3506 using std::double_t; 3507 using std::erf; 3508 using std::erfc; 3509 using std::erfcf; 3510 using std::erfcl; 3511 using std::erff; 3512 using std::erfl; 3513 using std::exp; 3514 using std::exp2; 3515 using std::exp2f; 3516 using std::exp2l; 3517 using std::expf; 3518 using std::expl; 3519 using std::expm1; 3520 using std::expm1f; 3521 using std::expm1l; 3522 using std::fabs; 3523 using std::fabsf; 3524 using std::fabsl; 3525 using std::fdim; 3526 using std::fdimf; 3527 using std::fdiml; 3528 using std::float_t; 3529 using std::floor; 3530 using std::floorf; 3531 using std::floorl; 3532 using std::fma; 3533 using std::fmaf; 3534 using std::fmal; 3535 using std::fmax; 3536 using std::fmaxf; 3537 using std::fmaxl; 3538 using std::fmin; 3539 using std::fminf; 3540 using std::fminl; 3541 using std::fmod; 3542 using std::fmodf; 3543 using std::fmodl; 3544 using std::fpclassify; 3545 using std::frexp; 3546 using std::frexpf; 3547 using std::frexpl; 3548 using std::hypot; 3549 using std::hypotf; 3550 using std::hypotl; 3551 using std::ilogb; 3552 using std::ilogbf; 3553 using std::ilogbl; 3554 using std::isfinite; 3555 using std::isgreater; 3556 using std::isgreaterequal; 3557 using std::isinf; 3558 using std::isless; 3559 using std::islessequal; 3560 using std::islessgreater; 3561 using std::isnan; 3562 using std::isnormal; 3563 using std::isunordered; 3564 using std::ldexp; 3565 using std::ldexpf; 3566 using std::ldexpl; 3567 #ifndef STD_COMPAT 3568 using std::lerp; 3569 #endif 3570 using std::lgamma; 3571 using std::lgammaf; 3572 using std::lgammal; 3573 using std::llrint; 3574 using std::llrintf; 3575 using std::llrintl; 3576 using std::llround; 3577 using std::llroundf; 3578 using std::llroundl; 3579 using std::log; 3580 using std::log10; 3581 using std::log10f; 3582 using std::log10l; 3583 using std::log1p; 3584 using std::log1pf; 3585 using std::log1pl; 3586 using std::log2; 3587 using std::log2f; 3588 using std::log2l; 3589 using std::logb; 3590 using std::logbf; 3591 using std::logbl; 3592 using std::logf; 3593 using std::logl; 3594 using std::lrint; 3595 using std::lrintf; 3596 using std::lrintl; 3597 using std::lround; 3598 using std::lroundf; 3599 using std::lroundl; 3600 using std::modf; 3601 using std::modff; 3602 using std::modfl; 3603 using std::nan; 3604 using std::nanf; 3605 using std::nanl; 3606 using std::nearbyint; 3607 using std::nearbyintf; 3608 using std::nearbyintl; 3609 using std::nextafter; 3610 using std::nextafterf; 3611 using std::nextafterl; 3612 using std::nexttoward; 3613 using std::nexttowardf; 3614 using std::nexttowardl; 3615 using std::pow; 3616 using std::powf; 3617 using std::powl; 3618 using std::remainder; 3619 using std::remainderf; 3620 using std::remainderl; 3621 using std::remquo; 3622 using std::remquof; 3623 using std::remquol; 3624 using std::rint; 3625 using std::rintf; 3626 using std::rintl; 3627 using std::round; 3628 using std::roundf; 3629 using std::roundl; 3630 using std::scalbln; 3631 using std::scalblnf; 3632 using std::scalblnl; 3633 using std::scalbn; 3634 using std::scalbnf; 3635 using std::scalbnl; 3636 using std::signbit; 3637 using std::sin; 3638 using std::sinf; 3639 using std::sinh; 3640 using std::sinhf; 3641 using std::sinhl; 3642 using std::sinl; 3643 using std::sqrt; 3644 using std::sqrtf; 3645 using std::sqrtl; 3646 using std::tan; 3647 using std::tanf; 3648 using std::tanh; 3649 using std::tanhf; 3650 using std::tanhl; 3651 using std::tanl; 3652 using std::tgamma; 3653 using std::tgammaf; 3654 using std::tgammal; 3655 using std::trunc; 3656 using std::truncf; 3657 using std::truncl; 3658 3659 #if __cpp_lib_math_special_functions && !defined(STD_COMPAT) 3660 using std::assoc_laguerre; 3661 using std::assoc_laguerref; 3662 using std::assoc_laguerrel; 3663 using std::assoc_legendre; 3664 using std::assoc_legendref; 3665 using std::assoc_legendrel; 3666 using std::beta; 3667 using std::betaf; 3668 using std::betal; 3669 using std::comp_ellint_1; 3670 using std::comp_ellint_1f; 3671 using std::comp_ellint_1l; 3672 using std::comp_ellint_2; 3673 using std::comp_ellint_2f; 3674 using std::comp_ellint_2l; 3675 using std::comp_ellint_3; 3676 using std::comp_ellint_3f; 3677 using std::comp_ellint_3l; 3678 using std::cyl_bessel_i; 3679 using std::cyl_bessel_if; 3680 using std::cyl_bessel_il; 3681 using std::cyl_bessel_j; 3682 using std::cyl_bessel_jf; 3683 using std::cyl_bessel_jl; 3684 using std::cyl_bessel_k; 3685 using std::cyl_bessel_kf; 3686 using std::cyl_bessel_kl; 3687 using std::cyl_neumann; 3688 using std::cyl_neumannf; 3689 using std::cyl_neumannl; 3690 using std::ellint_1; 3691 using std::ellint_1f; 3692 using std::ellint_1l; 3693 using std::ellint_2; 3694 using std::ellint_2f; 3695 using std::ellint_2l; 3696 using std::ellint_3; 3697 using std::ellint_3f; 3698 using std::ellint_3l; 3699 using std::expint; 3700 using std::expintf; 3701 using std::expintl; 3702 using std::hermite; 3703 using std::hermitef; 3704 using std::hermitel; 3705 using std::legendre; 3706 using std::legendref; 3707 using std::legendrel; 3708 using std::laguerre; 3709 using std::laguerref; 3710 using std::laguerrel; 3711 using std::riemann_zeta; 3712 using std::riemann_zetaf; 3713 using std::riemann_zetal; 3714 using std::sph_bessel; 3715 using std::sph_besself; 3716 using std::sph_bessell; 3717 using std::sph_legendre; 3718 using std::sph_legendref; 3719 using std::sph_legendrel; 3720 using std::sph_neumann; 3721 using std::sph_neumannf; 3722 using std::sph_neumannl; 3723 #endif 3724 } 3725 3726 // 17.13.3 <csetjmp> 3727 export C_LIB_NAMESPACE 3728 { 3729 using std::jmp_buf; 3730 using std::longjmp; 3731 // setjmp macro not exported 3732 } 3733 3734 // 17.13.4 <csignal> 3735 export C_LIB_NAMESPACE 3736 { 3737 using std::raise; 3738 using std::sig_atomic_t; 3739 using std::signal; 3740 // SIG_* macros not exported 3741 } 3742 3743 // 17.13.2 <cstdarg> 3744 export C_LIB_NAMESPACE 3745 { 3746 using std::va_list; 3747 // va_arg and friend macros not exported 3748 } 3749 3750 // 17.2.1 <cstddef> [cstddef.syn] 3751 export C_LIB_NAMESPACE 3752 { 3753 using std::max_align_t; 3754 using std::nullptr_t; 3755 using std::ptrdiff_t; 3756 using std::size_t; 3757 #ifndef STD_COMPAT 3758 using std::byte; 3759 using std::operator<<=; 3760 using std::operator<<; 3761 using std::operator>>=; 3762 using std::operator>>; 3763 using std::operator|=; 3764 using std::operator|; 3765 using std::operator&=; 3766 using std::operator&; 3767 using std::operator^=; 3768 using std::operator^; 3769 using std::operator~; 3770 using std::to_integer; 3771 #endif 3772 // NULL and offsetof macros not exported 3773 } 3774 3775 // 17.4 <cstdint> 3776 export C_LIB_NAMESPACE 3777 { 3778 using std::int8_t; 3779 using std::int16_t; 3780 using std::int32_t; 3781 using std::int64_t; 3782 using std::int_fast16_t; 3783 using std::int_fast32_t; 3784 using std::int_fast64_t; 3785 using std::int_fast8_t; 3786 using std::int_least16_t; 3787 using std::int_least32_t; 3788 using std::int_least64_t; 3789 using std::int_least8_t; 3790 using std::intmax_t; 3791 using std::intptr_t; 3792 using std::uint8_t; 3793 using std::uint16_t; 3794 using std::uint32_t; 3795 using std::uint64_t; 3796 using std::uint_fast16_t; 3797 using std::uint_fast32_t; 3798 using std::uint_fast64_t; 3799 using std::uint_fast8_t; 3800 using std::uint_least16_t; 3801 using std::uint_least32_t; 3802 using std::uint_least64_t; 3803 using std::uint_least8_t; 3804 using std::uintmax_t; 3805 using std::uintptr_t; 3806 } 3807 3808 // 31.13.1 <cstdio> 3809 export C_LIB_NAMESPACE 3810 { 3811 using std::clearerr; 3812 using std::fclose; 3813 using std::feof; 3814 using std::ferror; 3815 using std::fflush; 3816 using std::fgetc; 3817 using std::fgetpos; 3818 using std::fgets; 3819 using std::FILE; 3820 using std::fopen; 3821 using std::fpos_t; 3822 using std::fprintf; 3823 using std::fputc; 3824 using std::fputs; 3825 using std::fread; 3826 using std::freopen; 3827 using std::fscanf; 3828 using std::fseek; 3829 using std::fsetpos; 3830 using std::ftell; 3831 using std::fwrite; 3832 using std::getc; 3833 using std::getchar; 3834 using std::perror; 3835 using std::printf; 3836 using std::putc; 3837 using std::putchar; 3838 using std::puts; 3839 using std::remove; 3840 using std::rename; 3841 using std::rewind; 3842 using std::scanf; 3843 using std::setbuf; 3844 using std::setvbuf; 3845 using std::size_t; 3846 using std::snprintf; 3847 using std::sprintf; 3848 using std::sscanf; 3849 using std::tmpfile; 3850 #if _GLIBCXX_USE_TMPNAM 3851 using std::tmpnam; 3852 #endif 3853 using std::ungetc; 3854 using std::vfprintf; 3855 using std::vfscanf; 3856 using std::vprintf; 3857 using std::vscanf; 3858 using std::vsnprintf; 3859 using std::vsprintf; 3860 using std::vsscanf; 3861 } 3862 3863 // 17.2.2 <cstdlib> [cstdlib.syn] 3864 export C_LIB_NAMESPACE 3865 { 3866 using std::_Exit; 3867 using std::abort; 3868 using std::abs; 3869 #ifdef _GLIBCXX_HAVE_ALIGNED_ALLOC 3870 using std::aligned_alloc; 3871 #endif 3872 #ifdef _GLIBCXX_HAVE_AT_QUICK_EXIT 3873 using std::at_quick_exit; 3874 #endif 3875 using std::atexit; 3876 using std::atof; 3877 using std::atoi; 3878 using std::atol; 3879 using std::atoll; 3880 using std::bsearch; 3881 using std::calloc; 3882 using std::div; 3883 using std::div_t; 3884 using std::exit; 3885 using std::free; 3886 using std::getenv; 3887 using std::labs; 3888 using std::ldiv; 3889 using std::ldiv_t; 3890 using std::llabs; 3891 using std::lldiv; 3892 using std::lldiv_t; 3893 using std::malloc; 3894 #ifdef _GLIBCXX_HAVE_MBSTATE_T 3895 using std::mblen; 3896 using std::mbstowcs; 3897 using std::mbtowc; 3898 #endif 3899 using std::qsort; 3900 #ifdef _GLIBCXX_HAVE_QUICK_EXIT 3901 using std::quick_exit; 3902 #endif 3903 using std::rand; 3904 using std::realloc; 3905 using std::size_t; 3906 using std::srand; 3907 using std::strtod; 3908 using std::strtof; 3909 using std::strtol; 3910 using std::strtold; 3911 using std::strtoll; 3912 using std::strtoul; 3913 using std::strtoull; 3914 using std::system; 3915 #ifdef _GLIBCXX_USE_WCHAR_T 3916 using std::wcstombs; 3917 using std::wctomb; 3918 #endif 3919 } 3920 3921 // 23.5.3 <cstring> 3922 export C_LIB_NAMESPACE 3923 { 3924 using std::memchr; 3925 using std::memcmp; 3926 using std::memcpy; 3927 using std::memmove; 3928 using std::memset; 3929 using std::size_t; 3930 using std::strcat; 3931 using std::strchr; 3932 using std::strcmp; 3933 using std::strcoll; 3934 using std::strcpy; 3935 using std::strcspn; 3936 using std::strerror; 3937 using std::strlen; 3938 using std::strncat; 3939 using std::strncmp; 3940 using std::strncpy; 3941 using std::strpbrk; 3942 using std::strrchr; 3943 using std::strspn; 3944 using std::strstr; 3945 using std::strtok; 3946 using std::strxfrm; 3947 } 3948 3949 // 29.15 <ctime> 3950 export C_LIB_NAMESPACE 3951 { 3952 using std::asctime; 3953 using std::clock; 3954 using std::clock_t; 3955 using std::ctime; 3956 using std::difftime; 3957 using std::gmtime; 3958 using std::localtime; 3959 using std::mktime; 3960 using std::size_t; 3961 using std::strftime; 3962 using std::time; 3963 using std::time_t; 3964 using std::tm; 3965 #ifdef _GLIBCXX_HAVE_TIMESPEC_GET 3966 using std::timespec; 3967 using std::timespec_get; 3968 #endif 3969 } 3970 3971 // 23.5.5 <cuchar> 3972 export C_LIB_NAMESPACE 3973 { 3974 #if _GLIBCXX_USE_UCHAR_C8RTOMB_MBRTOC8_CXX20 3975 using std::mbrtoc8; 3976 using std::c8rtomb; 3977 #endif 3978 #if _GLIBCXX_USE_C11_UCHAR_CXX11 3979 using std::mbrtoc16; 3980 using std::c16rtomb; 3981 using std::mbrtoc32; 3982 using std::c32rtomb; 3983 #endif 3984 } 3985 3986 #if _GLIBCXX_USE_WCHAR_T 3987 // 23.5.4 <cwchar> 3988 export C_LIB_NAMESPACE 3989 { 3990 using std::btowc; 3991 using std::fgetwc; 3992 using std::fgetws; 3993 using std::fputwc; 3994 using std::fputws; 3995 using std::fwide; 3996 using std::fwprintf; 3997 using std::fwscanf; 3998 using std::getwc; 3999 using std::getwchar; 4000 using std::mbrlen; 4001 using std::mbrtowc; 4002 using std::mbsinit; 4003 using std::mbsrtowcs; 4004 using std::mbstate_t; 4005 using std::putwc; 4006 using std::putwchar; 4007 using std::size_t; 4008 using std::swprintf; 4009 using std::swscanf; 4010 using std::tm; 4011 using std::ungetwc; 4012 using std::vfwprintf; 4013 # if _GLIBCXX_HAVE_VFWSCANF 4014 using std::vfwscanf; 4015 #endif 4016 #ifndef _GLIBCXX_HAVE_BROKEN_VSWPRINTF 4017 using std::vswprintf; 4018 #endif 4019 # if _GLIBCXX_HAVE_VSWSCANF 4020 using std::vswscanf; 4021 #endif 4022 using std::vwprintf; 4023 # if _GLIBCXX_HAVE_VWSCANF 4024 using std::vwscanf; 4025 #endif 4026 using std::wcrtomb; 4027 using std::wcscat; 4028 using std::wcschr; 4029 using std::wcscmp; 4030 using std::wcscoll; 4031 using std::wcscpy; 4032 using std::wcscspn; 4033 using std::wcsftime; 4034 using std::wcslen; 4035 using std::wcsncat; 4036 using std::wcsncmp; 4037 using std::wcsncpy; 4038 using std::wcspbrk; 4039 using std::wcsrchr; 4040 using std::wcsrtombs; 4041 using std::wcsspn; 4042 using std::wcsstr; 4043 using std::wcstod; 4044 #if _GLIBCXX_HAVE_WCSTOF 4045 using std::wcstof; 4046 #endif 4047 using std::wcstok; 4048 using std::wcstol; 4049 #if _GLIBCXX_USE_C99_WCHAR 4050 using std::wcstold; 4051 using std::wcstoll; 4052 #endif 4053 using std::wcstoul; 4054 #if _GLIBCXX_USE_C99_WCHAR 4055 using std::wcstoull; 4056 #endif 4057 using std::wcsxfrm; 4058 using std::wctob; 4059 using std::wint_t; 4060 using std::wmemchr; 4061 using std::wmemcmp; 4062 using std::wmemcpy; 4063 using std::wmemmove; 4064 using std::wmemset; 4065 using std::wprintf; 4066 using std::wscanf; 4067 } 4068 #endif 4069 4070 #if _GLIBCXX_USE_WCHAR_T 4071 // 23.5.2 <cwctype> 4072 export C_LIB_NAMESPACE 4073 { 4074 using std::iswalnum; 4075 using std::iswalpha; 4076 #if _GLIBCXX_HAVE_ISWBLANK 4077 using std::iswblank; 4078 #endif 4079 using std::iswcntrl; 4080 using std::iswctype; 4081 using std::iswdigit; 4082 using std::iswgraph; 4083 using std::iswlower; 4084 using std::iswprint; 4085 using std::iswpunct; 4086 using std::iswspace; 4087 using std::iswupper; 4088 using std::iswxdigit; 4089 using std::towctrans; 4090 using std::towlower; 4091 using std::towupper; 4092 using std::wctrans; 4093 using std::wctrans_t; 4094 using std::wctype; 4095 using std::wctype_t; 4096 using std::wint_t; 4097 } 4098 #endif
