625 lines · plain
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10export namespace std {11 namespace ranges {12 // [algorithms.results], algorithm result types13 using std::ranges::in_found_result;14 using std::ranges::in_fun_result;15 using std::ranges::in_in_out_result;16 using std::ranges::in_in_result;17 using std::ranges::in_out_out_result;18 using std::ranges::in_out_result;19#if _LIBCPP_STD_VER >= 2320 using std::ranges::in_value_result;21#endif22 using std::ranges::min_max_result;23#if _LIBCPP_STD_VER >= 2324 using std::ranges::out_value_result;25#endif26 } // namespace ranges27 28 // [alg.nonmodifying], non-modifying sequence operations29 // [alg.all.of], all of30 using std::all_of;31 namespace ranges {32 using std::ranges::all_of;33 }34 35 // [alg.any.of], any of36 using std::any_of;37 namespace ranges {38 using std::ranges::any_of;39 }40 41 // [alg.none.of], none of42 using std::none_of;43 namespace ranges {44 using std::ranges::none_of;45 }46 47#if _LIBCPP_STD_VER >= 2348 // [alg.contains], contains49 namespace ranges {50 using std::ranges::contains;51 using std::ranges::contains_subrange;52 } // namespace ranges53#endif // _LIBCPP_STD_VER >= 2354 55 // [alg.foreach], for each56 using std::for_each;57 58 namespace ranges {59 using std::ranges::for_each;60 using std::ranges::for_each_result;61 } // namespace ranges62 63 using std::for_each_n;64 65 namespace ranges {66 using std::ranges::for_each_n_result;67 68 using std::ranges::for_each_n;69 } // namespace ranges70 71 // [alg.find], find72 using std::find;73 using std::find_if;74 using std::find_if_not;75 76 namespace ranges {77 using std::ranges::find;78 using std::ranges::find_if;79 using std::ranges::find_if_not;80 } // namespace ranges81 82#if _LIBCPP_STD_VER >= 2383 // [alg.find.last], find last84 namespace ranges {85 using std::ranges::find_last;86 using std::ranges::find_last_if;87 using std::ranges::find_last_if_not;88 } // namespace ranges89#endif90 91 // [alg.find.end], find end92 using std::find_end;93 94 namespace ranges {95 using std::ranges::find_end;96 }97 98 // [alg.find.first.of], find first99 using std::find_first_of;100 101 namespace ranges {102 using std::ranges::find_first_of;103 }104 105 // [alg.adjacent.find], adjacent find106 using std::adjacent_find;107 108 namespace ranges {109 using std::ranges::adjacent_find;110 }111 112 // [alg.count], count113 using std::count;114 using std::count_if;115 116 namespace ranges {117 using std::ranges::count;118 using std::ranges::count_if;119 } // namespace ranges120 121 // [mismatch], mismatch122 using std::mismatch;123 124 namespace ranges {125 using std::ranges::mismatch_result;126 127 using std::ranges::mismatch;128 } // namespace ranges129 130 // [alg.equal], equal131 using std::equal;132 133 namespace ranges {134 using std::ranges::equal;135 }136 137 // [alg.is.permutation], is permutation138 using std::is_permutation;139 140 namespace ranges {141 using std::ranges::is_permutation;142 }143 144 // [alg.search], search145 using std::search;146 147 namespace ranges {148 using std::ranges::search;149 }150 151 using std::search_n;152 153 namespace ranges {154 using std::ranges::search_n;155 }156 157 namespace ranges {158#if _LIBCPP_STD_VER >= 23159 // [alg.starts.with], starts with160 using std::ranges::starts_with;161 162 // [alg.ends.with], ends with163 using std::ranges::ends_with;164 165 // [alg.fold], fold166 using std::ranges::fold_left;167 using std::ranges::fold_left_with_iter;168 using std::ranges::fold_left_with_iter_result;169# if 0170 using std::ranges::fold_left_first;171 using std::ranges::fold_right;172 using std::ranges::fold_right_last;173 using std::ranges::fold_left_with_iter;174 using std::ranges::fold_left_first_with_iter;175 using std::ranges::fold_left_first_with_iter;176# endif177#endif // _LIBCPP_STD_VER >= 23178 } // namespace ranges179 180 // [alg.modifying.operations], mutating sequence operations181 // [alg.copy], copy182 using std::copy;183 184 namespace ranges {185 using std::ranges::copy;186 using std::ranges::copy_result;187 } // namespace ranges188 189 using std::copy_n;190 191 namespace ranges {192 using std::ranges::copy_n;193 using std::ranges::copy_n_result;194 } // namespace ranges195 196 using std::copy_if;197 198 namespace ranges {199 using std::ranges::copy_if;200 using std::ranges::copy_if_result;201 } // namespace ranges202 203 using std::copy_backward;204 205 namespace ranges {206 using std::ranges::copy_backward;207 using std::ranges::copy_backward_result;208 } // namespace ranges209 210 // [alg.move], move211 using std::move;212 213 namespace ranges {214 using std::ranges::move;215 using std::ranges::move_result;216 } // namespace ranges217 218 using std::move_backward;219 220 namespace ranges {221 using std::ranges::move_backward;222 using std::ranges::move_backward_result;223 } // namespace ranges224 225 // [alg.swap], swap226 using std::swap_ranges;227 228 namespace ranges {229 using std::ranges::swap_ranges;230 using std::ranges::swap_ranges_result;231 } // namespace ranges232 233 using std::iter_swap;234 235 // [alg.transform], transform236 using std::transform;237 238 namespace ranges {239 using std::ranges::binary_transform_result;240 using std::ranges::unary_transform_result;241 242 using std::ranges::transform;243 244 } // namespace ranges245 246 using std::replace;247 using std::replace_if;248 249 namespace ranges {250 using std::ranges::replace;251 using std::ranges::replace_if;252 } // namespace ranges253 254 using std::replace_copy;255 using std::replace_copy_if;256 257 namespace ranges {258 using std::ranges::replace_copy;259 using std::ranges::replace_copy_if;260 using std::ranges::replace_copy_if_result;261 using std::ranges::replace_copy_result;262 } // namespace ranges263 264 // [alg.fill], fill265 using std::fill;266 using std::fill_n;267 268 namespace ranges {269 using std::ranges::fill;270 using std::ranges::fill_n;271 } // namespace ranges272 273 // [alg.generate], generate274 using std::generate;275 using std::generate_n;276 277 namespace ranges {278 using std::ranges::generate;279 using std::ranges::generate_n;280 } // namespace ranges281 282 // [alg.remove], remove283 using std::remove;284 using std::remove_if;285 286 namespace ranges {287 using std::ranges::remove;288 using std::ranges::remove_if;289 } // namespace ranges290 291 using std::remove_copy;292 using std::remove_copy_if;293 namespace ranges {294 using std::ranges::remove_copy;295 using std::ranges::remove_copy_if;296 using std::ranges::remove_copy_if_result;297 using std::ranges::remove_copy_result;298 } // namespace ranges299 300 // [alg.unique], unique301 using std::unique;302 303 namespace ranges {304 using std::ranges::unique;305 }306 307 using std::unique_copy;308 309 namespace ranges {310 using std::ranges::unique_copy;311 using std::ranges::unique_copy_result;312 } // namespace ranges313 314 // [alg.reverse], reverse315 using std::reverse;316 317 namespace ranges {318 using std::ranges::reverse;319 }320 321 using std::reverse_copy;322 323 namespace ranges {324 using std::ranges::reverse_copy;325 using std::ranges::reverse_copy_result;326 } // namespace ranges327 328 // [alg.rotate], rotate329 using std::rotate;330 331 namespace ranges {332 using std::ranges::rotate;333 }334 335 using std::rotate_copy;336 337 namespace ranges {338 using std::ranges::rotate_copy;339 using std::ranges::rotate_copy_result;340 } // namespace ranges341 342 // [alg.random.sample], sample343 using std::sample;344 345 namespace ranges {346 using std::ranges::sample;347 }348 349 // [alg.random.shuffle], shuffle350 using std::shuffle;351 352 namespace ranges {353 using std::ranges::shuffle;354 }355 356 // [alg.shift], shift357 using std::shift_left;358 359 namespace ranges {360 // using std::ranges::shift_left;361 }362 363 using std::shift_right;364 365 namespace ranges {366 // using std::ranges::shift_right;367 }368 369 // [alg.sorting], sorting and related operations370 // [alg.sort], sorting371 using std::sort;372 373 namespace ranges {374 using std::ranges::sort;375 }376 377 using std::stable_sort;378 379 namespace ranges {380 using std::ranges::stable_sort;381 }382 383 using std::partial_sort;384 385 namespace ranges {386 using std::ranges::partial_sort;387 }388 using std::partial_sort_copy;389 390 namespace ranges {391 using std::ranges::partial_sort_copy;392 using std::ranges::partial_sort_copy_result;393 } // namespace ranges394 395 using std::is_sorted;396 using std::is_sorted_until;397 398 namespace ranges {399 using std::ranges::is_sorted;400 using std::ranges::is_sorted_until;401 } // namespace ranges402 403 // [alg.nth.element], Nth element404 using std::nth_element;405 406 namespace ranges {407 using std::ranges::nth_element;408 }409 410 // [alg.binary.search], binary search411 using std::lower_bound;412 413 namespace ranges {414 using std::ranges::lower_bound;415 }416 417 using std::upper_bound;418 419 namespace ranges {420 using std::ranges::upper_bound;421 }422 423 using std::equal_range;424 425 namespace ranges {426 using std::ranges::equal_range;427 }428 429 using std::binary_search;430 431 namespace ranges {432 using std::ranges::binary_search;433 }434 435 // [alg.partitions], partitions436 using std::is_partitioned;437 438 namespace ranges {439 using std::ranges::is_partitioned;440 }441 442 using std::partition;443 444 namespace ranges {445 using std::ranges::partition;446 }447 448 using std::stable_partition;449 450 namespace ranges {451 using std::ranges::stable_partition;452 }453 454 using std::partition_copy;455 456 namespace ranges {457 using std::ranges::partition_copy;458 using std::ranges::partition_copy_result;459 } // namespace ranges460 461 using std::partition_point;462 463 namespace ranges {464 using std::ranges::partition_point;465 }466 // [alg.merge], merge467 using std::merge;468 namespace ranges {469 using std::ranges::merge;470 using std::ranges::merge_result;471 } // namespace ranges472 473 using std::inplace_merge;474 475 namespace ranges {476 using std::ranges::inplace_merge;477 }478 479 // [alg.set.operations], set operations480 using std::includes;481 namespace ranges {482 using std::ranges::includes;483 }484 485 using std::set_union;486 487 namespace ranges {488 using std::ranges::set_union;489 using std::ranges::set_union_result;490 } // namespace ranges491 492 using std::set_intersection;493 namespace ranges {494 using std::ranges::set_intersection;495 using std::ranges::set_intersection_result;496 } // namespace ranges497 498 using std::set_difference;499 500 namespace ranges {501 using std::ranges::set_difference;502 using std::ranges::set_difference_result;503 } // namespace ranges504 505 using std::set_symmetric_difference;506 507 namespace ranges {508 using std::ranges::set_symmetric_difference_result;509 510 using std::ranges::set_symmetric_difference;511 } // namespace ranges512 513 // [alg.heap.operations], heap operations514 using std::push_heap;515 516 namespace ranges {517 using std::ranges::push_heap;518 }519 520 using std::pop_heap;521 522 namespace ranges {523 using std::ranges::pop_heap;524 }525 526 using std::make_heap;527 528 namespace ranges {529 using std::ranges::make_heap;530 }531 532 using std::sort_heap;533 534 namespace ranges {535 using std::ranges::sort_heap;536 }537 538 using std::is_heap;539 540 namespace ranges {541 using std::ranges::is_heap;542 }543 544 using std::is_heap_until;545 546 namespace ranges {547 using std::ranges::is_heap_until;548 }549 550 // [alg.min.max], minimum and maximum551 using std::min;552 553 namespace ranges {554 using std::ranges::min;555 }556 557 using std::max;558 559 namespace ranges {560 using std::ranges::max;561 }562 563 using std::minmax;564 565 namespace ranges {566 using std::ranges::minmax_result;567 568 using std::ranges::minmax;569 } // namespace ranges570 571 using std::min_element;572 573 namespace ranges {574 using std::ranges::min_element;575 }576 577 using std::max_element;578 579 namespace ranges {580 using std::ranges::max_element;581 }582 583 using std::minmax_element;584 585 namespace ranges {586 using std::ranges::minmax_element_result;587 588 using std::ranges::minmax_element;589 } // namespace ranges590 // [alg.clamp], bounded value591 using std::clamp;592 593 namespace ranges {594 using std::ranges::clamp;595 }596 597 // [alg.lex.comparison], lexicographical comparison598 using std::lexicographical_compare;599 600 namespace ranges {601 using std::ranges::lexicographical_compare;602 }603 604 // [alg.three.way], three-way comparison algorithms605 using std::lexicographical_compare_three_way;606 607 // [alg.permutation.generators], permutations608 using std::next_permutation;609 610 namespace ranges {611 using std::ranges::next_permutation_result;612 613 using std::ranges::next_permutation;614 } // namespace ranges615 616 using std::prev_permutation;617 618 namespace ranges {619 using std::ranges::prev_permutation_result;620 621 using std::ranges::prev_permutation;622 } // namespace ranges623 624} // namespace std625