Lines Matching full:ranges
21 namespace ranges {
49 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less> // since C++20
53 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less> // since C++20
57 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
58 constexpr I ranges::max_element(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
61 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
62 constexpr borrowed_iterator_t<R> ranges::max_element(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
68 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
74 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
79 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
83 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
106 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
111 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
131 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
135 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
139 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
145 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
149 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
153 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
167 constexpr ranges::unary_transform_result<I, O>
173 constexpr ranges::unary_transform_result<borrowed_iterator_t<R>, O>
181 constexpr ranges::binary_transform_result<I1, I2, O>
189 constexpr ranges::binary_transform_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>, O>
194 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
199 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
217 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
218 constexpr ranges::minmax_result<const T&>
222 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
223 constexpr ranges::minmax_result<T>
227 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
229 constexpr ranges::minmax_result<range_value_t<R>>
236 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
237 constexpr ranges::minmax_element_result<I>
241 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
242 constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
247 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
253 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
271 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
272 constexpr bool ranges::contains(I first, S last, const T& value, Proj proj = {}); // since C++23
275 requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
276 constexpr bool ranges::contains(R&& r, const T& value, Proj proj = {}); // since C++23
280 constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result); // since C++20
284 constexpr ranges::copy_result<borrowed_iterator_t<R>, O> ranges::copy(R&& r, O result); // since C++20
288 constexpr ranges::copy_n_result<I, O>
289 ranges::copy_n(I first, iter_difference_t<I> n, O result); // since C++20
294 constexpr ranges::copy_if_result<I, O>
295 ranges::copy_if(I first, S last, O result, Pred pred, Proj proj = {}); // since C++20
300 constexpr ranges::copy_if_result<borrowed_iterator_t<R>, O>
301 ranges::copy_if(R&& r, O result, Pred pred, Proj proj = {}); // since C++20
305 constexpr ranges::copy_backward_result<I1, I2>
306 ranges::copy_backward(I1 first, S1 last, I2 result); // since C++20
310 constexpr ranges::copy_backward_result<borrowed_iterator_t<R>, I>
311 ranges::copy_backward(R&& r, I result); // since C++20
318 constexpr ranges::for_each_result<I, Fun>
319 ranges::for_each(I first, S last, Fun f, Proj proj = {}); // since C++20
323 constexpr ranges::for_each_result<borrowed_iterator_t<R>, Fun>
324 ranges::for_each(R&& r, Fun f, Proj proj = {}); // since C++20
328 constexpr ranges::for_each_n_result<I, Fun>
329 ranges::for_each_n(I first, iter_difference_t<I> n, Fun f, Proj proj = {}); // since C++20
333 constexpr bool ranges::is_partitioned(I first, S last, Pred pred, Proj proj = {}); // since C++20
337 constexpr bool ranges::is_partitioned(R&& r, Pred pred, Proj proj = {}); // since C++20
339 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
343 ranges::push_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
345 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
348 ranges::push_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
350 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
354 ranges::pop_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
356 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
359 ranges::pop_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
361 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
365 ranges::make_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
367 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
370 ranges::make_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
372 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
376 ranges::sort_heap(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
378 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
381 ranges::sort_heap(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
384 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
388 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
392 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
396 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
402 constexpr I ranges::reverse(I first, S last); // since C++20
406 constexpr borrowed_iterator_t<R> ranges::reverse(R&& r); // since C++20
408 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
412 ranges::sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
414 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
417 ranges::sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
419 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
422 I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
424 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
427 ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
429 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
433 ranges::partial_sort(I first, I middle, S last, Comp comp = {}, Proj proj = {}); // since C++20
435 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
438 ranges::partial_sort(R&& r, iterator_t<R> middle, Comp comp = {}, Proj proj = {}); // since C++20
441 constexpr O ranges::fill(O first, S last, const T& value); // since C++20
444 constexpr borrowed_iterator_t<R> ranges::fill(R&& r, const T& value); // since C++20
447 constexpr O ranges::fill_n(O first, iter_difference_t<O> n, const T& value); // since C++20
471 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
473 constexpr bool ranges::equal(I1 first1, S1 last1, I2 first2, S2 last2,
477 template<input_range R1, input_range R2, class Pred = ranges::equal_to,
480 constexpr bool ranges::equal(R1&& r1, R2&& r2, Pred pred = {},
485 constexpr bool ranges::all_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
489 constexpr bool ranges::all_of(R&& r, Pred pred, Proj proj = {}); // since C++20
493 constexpr bool ranges::any_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
497 constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {}); // since C++20
500 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
504 constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
507 template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
512 constexpr bool ranges::ends_with(R1&& r1, R2&& r2, Pred pred = {},
517 constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {}); // since C++20
521 constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {}); // since C++20
524 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
526 constexpr bool ranges::starts_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
529 template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
532 constexpr bool ranges::starts_with(R1&& r1, R2&& r2, Pred pred = {},
537 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
544 template<input_range R1, random_access_range R2, class Comp = ranges::less,
555 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
556 constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
559 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
560 constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
563 indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
564 constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
567 indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
569 ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
571 template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
575 ranges::nth_element(I first, I nth, S last, Comp comp = {}, Proj proj = {}); // since C++20
577 template<random_access_range R, class Comp = ranges::less, class Proj = identity>
580 ranges::nth_element(R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {}); // since C++20
583 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less> // since C++20
588 ranges::less>
593 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
598 ranges::less>
603 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
609 ranges::less>
635 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
637 constexpr I1 ranges::find_first_of(I1 first1, S1 last1, I2 first2, S2 last2,
642 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
645 ranges::find_first_of(R1&& r1, R2&& r2,
651 projected<I, Proj>> Pred = ranges::equal_to>
652 constexpr I ranges::adjacent_find(I first, S last, Pred pred = {}, Proj proj = {}); // since C++20
656 projected<iterator_t<R>, Proj>> Pred = ranges::equal_to>
657 constexpr borrowed_iterator_t<R> ranges::adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // since C++20
661 indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
663 ranges::replace(I first, S last, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20
667 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T1*>
669 ranges::replace(R&& r, const T1& old_value, const T2& new_value, Proj proj = {}); // since C++20
674 constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {}); // since C++20
680 ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {}); // since C++20
683 indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
685 ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {}); // since C++20
690 projected<I2, Proj2>> Comp = ranges::less>
692 ranges::lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
698 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
700 ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
705 constexpr ranges::move_backward_result<I1, I2>
706 ranges::move_backward(I1 first, S1 last, I2 result); // since C++20
710 constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
711 ranges::move_backward(R&& r, I result); // since C++20
715 constexpr ranges::move_result<I, O>
716 ranges::move(I first, S last, O result); // since C++20
720 constexpr ranges::move_result<borrowed_iterator_t<R>, O>
721 ranges::move(R&& r, O result); // since C++20
755 weakly_incrementable O, class Comp = ranges::less, class Proj1 = identity,
762 template<input_range R1, input_range R2, weakly_incrementable O, class Comp = ranges::less,
770 requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
771 constexpr subrange<I> ranges::remove(I first, S last, const T& value, Proj proj = {}); // since C++20
775 indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
777 ranges::remove(R&& r, const T& value, Proj proj = {}); // since C++20
781 constexpr subrange<I> ranges::remove_if(I first, S last, Pred pred, Proj proj = {}); // since C++20
787 ranges::remove_if(R&& r, Pred pred, Proj proj = {}); // since C++20
793 weakly_incrementable O, class Comp = ranges::less,
801 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
811 weakly_incrementable O, class Comp = ranges::less,
819 weakly_incrementable O, class Comp = ranges::less,
831 constexpr ranges::reverse_copy_result<I, O>
832 ranges::reverse_copy(I first, S last, O result); // since C++20
836 constexpr ranges::reverse_copy_result<borrowed_iterator_t<R>, O>
837 ranges::reverse_copy(R&& r, O result); // since C++20
851 constexpr ranges::rotate_copy_result<I, O>
852 ranges::rotate_copy(I first, I middle, S last, O result); // since C++20
856 constexpr ranges::rotate_copy_result<borrowed_iterator_t<R>, O>
857 ranges::rotate_copy(R&& r, iterator_t<R> middle, O result); // since C++20
884 projected<I2, Proj2>> Pred = ranges::equal_to>
885 constexpr bool ranges::is_permutation(I1 first1, S1 last1, I2 first2, S2 last2,
892 projected<iterator_t<R2>, Proj2>> Pred = ranges::equal_to>
893 constexpr bool ranges::is_permutation(R1&& r1, R2&& r2, Pred pred = {},
897 sentinel_for<I2> S2, class Pred = ranges::equal_to,
901 ranges::search(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
904 template<forward_range R1, forward_range R2, class Pred = ranges::equal_to,
908 ranges::search(R1&& r1, R2&& r2, Pred pred = {},
912 class Pred = ranges::equal_to, class Proj = identity>
915 ranges::search_n(I first, S last, iter_difference_t<I> count,
918 template<forward_range R, class T, class Pred = ranges::equal_to,
922 ranges::search_n(R&& r, range_difference_t<R> count,
927 constexpr auto ranges::fold_left(I first, S last, T init, F f); // since C++23
943 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
946 ranges::find_end(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
950 class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
953 ranges::find_end(R1&& r1, R2&& r2, Pred pred = {},
960 weakly_incrementable O, class Comp = ranges::less,
969 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
977 indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
983 ranges::less>
991 weakly_incrementable O, class Comp = ranges::less,
999 class Comp = ranges::less, class Proj1 = identity, class Proj2 = identity>
1008 ranges::less>
1015 projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
1019 template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
1024 template<bidirectional_range R, class Comp = ranges::less, class Proj = identity>
1031 indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
1035 indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
1041 indirect_equivalence_relation<projected<I, Proj>> C = ranges::equal_to>
1050 indirect_equivalence_relation<projected<iterator_t<R>, Proj>> C = ranges::equal_to>
1063 indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
1069 indirect_binary_predicate<ranges::equal_to,
1095 indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T1*>
1103 indirect_binary_predicate<ranges::equal_to,
1129 template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
1132 constexpr ranges::prev_permutation_result<I>
1133 ranges::prev_permutation(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
1135 template<bidirectional_range R, class Comp = ranges::less,
1138 constexpr ranges::prev_permutation_result<borrowed_iterator_t<R>>
1139 ranges::prev_permutation(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
1144 template<bidirectional_iterator I, sentinel_for<I> S, class Comp = ranges::less,
1147 constexpr ranges::next_permutation_result<I>
1148 ranges::next_permutation(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
1150 template<bidirectional_range R, class Comp = ranges::less,
1153 constexpr ranges::next_permutation_result<borrowed_iterator_t<R>>
1154 ranges::next_permutation(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
1338 namespace ranges {
1344 constexpr ranges::swap_ranges_result<I1, I2>
1349 constexpr ranges::swap_ranges_result<borrowed_iterator_t<R1>, borrowed_iterator_t<R2>>