mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-17 08:06:40 +00:00
Code Issues Projects Releases Wiki Activity

[libc++] Implement part of P2562R1: constexpr ranges::stable_sort (#128860)

Browse Source 
Drive-by: Enables test coverage for `ranges::stable_sort` with proxy
iterators, and changes "constexpr in" to "constexpr since" in comments
in `<algorithm>`.
This commit is contained in:
A. Jiang 2025-03-07 01:27:48 +08:00 committed by GitHub
parent 6e2fd4b269
commit ba9aeedf8e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 176 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libcxx/include/__algorithm/ranges_stable_sort.h
View File

@ -41,7 +41,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
namespace ranges {
struct __stable_sort {
template <class _Iter, class _Sent, class _Comp, class _Proj>
_LIBCPP_HIDE_FROM_ABI static _Iter __stable_sort_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX26 _Iter
__stable_sort_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
auto __last_iter = ranges::next(__first, __last);
auto&& __projected_comp = std::__make_projected(__comp, __proj);
@ -52,13 +53,14 @@ struct __stable_sort {
template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
requires sortable<_Iter, _Comp, _Proj>
_LIBCPP_HIDE_FROM_ABI _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 _Iter
operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
return __stable_sort_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
}
template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
requires sortable<iterator_t<_Range>, _Comp, _Proj>
_LIBCPP_HIDE_FROM_ABI borrowed_iterator_t<_Range>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 borrowed_iterator_t<_Range>
operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
return __stable_sort_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
}

275
libcxx/include/algorithm
View File

@ -422,11 +422,12 @@ namespace ranges {
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
class Proj = identity>
requires sortable<I, Comp, Proj>
I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
constexpr I // constexpr since C++26
ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
template<random_access_range R, class Comp = ranges::less, class Proj = identity>
requires sortable<iterator_t<R>, Comp, Proj>
borrowed_iterator_t<R>
constexpr borrowed_iterator_t<R> // constexpr since C++26
ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
@ -1167,84 +1168,84 @@ namespace ranges {
}
template <class InputIterator, class Predicate>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
all_of(InputIterator first, InputIterator last, Predicate pred);
template <class InputIterator, class Predicate>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
any_of(InputIterator first, InputIterator last, Predicate pred);
template <class InputIterator, class Predicate>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
none_of(InputIterator first, InputIterator last, Predicate pred);
template <class InputIterator, class Function>
constexpr Function // constexpr in C++20
constexpr Function // constexpr since C++20
for_each(InputIterator first, InputIterator last, Function f);
template<class InputIterator, class Size, class Function>
constexpr InputIterator // constexpr in C++20
constexpr InputIterator // constexpr since C++20
for_each_n(InputIterator first, Size n, Function f); // C++17
template <class InputIterator, class T>
constexpr InputIterator // constexpr in C++20
constexpr InputIterator // constexpr since C++20
find(InputIterator first, InputIterator last, const T& value);
template <class InputIterator, class Predicate>
constexpr InputIterator // constexpr in C++20
constexpr InputIterator // constexpr since C++20
find_if(InputIterator first, InputIterator last, Predicate pred);
template<class InputIterator, class Predicate>
constexpr InputIterator // constexpr in C++20
constexpr InputIterator // constexpr since C++20
find_if_not(InputIterator first, InputIterator last, Predicate pred);
template <class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator1 // constexpr in C++20
constexpr ForwardIterator1 // constexpr since C++20
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr ForwardIterator1 // constexpr in C++20
constexpr ForwardIterator1 // constexpr since C++20
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
template <class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator1 // constexpr in C++20
constexpr ForwardIterator1 // constexpr since C++20
find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr ForwardIterator1 // constexpr in C++20
constexpr ForwardIterator1 // constexpr since C++20
find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
template <class ForwardIterator>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
adjacent_find(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class BinaryPredicate>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
template <class InputIterator, class T>
constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
constexpr typename iterator_traits<InputIterator>::difference_type // constexpr since C++20
count(InputIterator first, InputIterator last, const T& value);
template <class InputIterator, class Predicate>
constexpr typename iterator_traits<InputIterator>::difference_type // constexpr in C++20
constexpr typename iterator_traits<InputIterator>::difference_type // constexpr since C++20
count_if(InputIterator first, InputIterator last, Predicate pred);
template <class InputIterator1, class InputIterator2>
constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
constexpr pair<InputIterator1, InputIterator2> // constexpr since C++20
mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
template <class InputIterator1, class InputIterator2>
constexpr pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2); // since C++14, constexpr in C++20
InputIterator2 first2, InputIterator2 last2); // since C++14, constexpr since C++20
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr pair<InputIterator1, InputIterator2> // constexpr in C++20
constexpr pair<InputIterator1, InputIterator2> // constexpr since C++20
mismatch(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred);
@ -1252,19 +1253,19 @@ template <class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
BinaryPredicate pred); // since C++14, constexpr in C++20
BinaryPredicate pred); // since C++14, constexpr since C++20
template <class InputIterator1, class InputIterator2>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
template <class InputIterator1, class InputIterator2>
constexpr bool
equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2); // since C++14, constexpr in C++20
InputIterator2 first2, InputIterator2 last2); // since C++14, constexpr since C++20
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred);
@ -1272,20 +1273,20 @@ template <class InputIterator1, class InputIterator2, class BinaryPredicate>
constexpr bool
equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2,
BinaryPredicate pred); // since C++14, constexpr in C++20
BinaryPredicate pred); // since C++14, constexpr since C++20
template<class ForwardIterator1, class ForwardIterator2>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2);
template<class ForwardIterator1, class ForwardIterator2>
constexpr bool
is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2); // since C++14, constexpr in C++20
ForwardIterator2 first2, ForwardIterator2 last2); // since C++14, constexpr since C++20
template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, BinaryPredicate pred);
@ -1293,42 +1294,42 @@ template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr bool
is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred); // since C++14, constexpr in C++20
BinaryPredicate pred); // since C++14, constexpr since C++20
template <class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator1 // constexpr in C++20
constexpr ForwardIterator1 // constexpr since C++20
search(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
constexpr ForwardIterator1 // constexpr in C++20
constexpr ForwardIterator1 // constexpr since C++20
search(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
template <class ForwardIterator, class Size, class T>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
template <class ForwardIterator, class Size, class T, class BinaryPredicate>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
search_n(ForwardIterator first, ForwardIterator last,
Size count, const T& value, BinaryPredicate pred);
template <class InputIterator, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
copy(InputIterator first, InputIterator last, OutputIterator result);
template<class InputIterator, class OutputIterator, class Predicate>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
copy_if(InputIterator first, InputIterator last,
OutputIterator result, Predicate pred);
template<class InputIterator, class Size, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
copy_n(InputIterator first, Size n, OutputIterator result);
template <class BidirectionalIterator1, class BidirectionalIterator2>
constexpr BidirectionalIterator2 // constexpr in C++20
constexpr BidirectionalIterator2 // constexpr since C++20
copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
BidirectionalIterator2 result);
@ -1343,7 +1344,7 @@ template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 result);
template <class ForwardIterator1, class ForwardIterator2>
constexpr ForwardIterator2 // constexpr in C++20
constexpr ForwardIterator2 // constexpr since C++20
swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);
namespace ranges {
@ -1362,97 +1363,97 @@ template<input_range R1, input_range R2>
}
template <class ForwardIterator1, class ForwardIterator2>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
iter_swap(ForwardIterator1 a, ForwardIterator2 b);
template <class InputIterator, class OutputIterator, class UnaryOperation>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op);
template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,
OutputIterator result, BinaryOperation binary_op);
template <class ForwardIterator, class T>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
template <class ForwardIterator, class Predicate, class T>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
template <class InputIterator, class OutputIterator, class T>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
replace_copy(InputIterator first, InputIterator last, OutputIterator result,
const T& old_value, const T& new_value);
template <class InputIterator, class OutputIterator, class Predicate, class T>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);
template <class ForwardIterator, class T>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
fill(ForwardIterator first, ForwardIterator last, const T& value);
template <class OutputIterator, class Size, class T>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
fill_n(OutputIterator first, Size n, const T& value);
template <class ForwardIterator, class Generator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
generate(ForwardIterator first, ForwardIterator last, Generator gen);
template <class OutputIterator, class Size, class Generator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
generate_n(OutputIterator first, Size n, Generator gen);
template <class ForwardIterator, class T>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
remove(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class Predicate>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
template <class InputIterator, class OutputIterator, class T>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
template <class InputIterator, class OutputIterator, class Predicate>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);
template <class ForwardIterator>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
unique(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class BinaryPredicate>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred);
template <class InputIterator, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
unique_copy(InputIterator first, InputIterator last, OutputIterator result);
template <class InputIterator, class OutputIterator, class BinaryPredicate>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred);
template <class BidirectionalIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
reverse(BidirectionalIterator first, BidirectionalIterator last);
template <class BidirectionalIterator, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result);
template <class ForwardIterator>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
template <class ForwardIterator, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
template <class RandomAccessIterator>
@ -1485,125 +1486,125 @@ template<class ForwardIterator>
typename iterator_traits<ForwardIterator>::difference_type n); // C++20
template <class InputIterator, class Predicate>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_partitioned(InputIterator first, InputIterator last, Predicate pred);
template <class ForwardIterator, class Predicate>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
partition(ForwardIterator first, ForwardIterator last, Predicate pred);
template <class InputIterator, class OutputIterator1,
class OutputIterator2, class Predicate>
constexpr pair<OutputIterator1, OutputIterator2> // constexpr in C++20
constexpr pair<OutputIterator1, OutputIterator2> // constexpr since C++20
partition_copy(InputIterator first, InputIterator last,
OutputIterator1 out_true, OutputIterator2 out_false,
Predicate pred);
template <class ForwardIterator, class Predicate>
constexpr ForwardIterator // constexpr in C++26
constexpr ForwardIterator // constexpr since C++26
stable_partition(ForwardIterator first, ForwardIterator last, Predicate pred);
template<class ForwardIterator, class Predicate>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
partition_point(ForwardIterator first, ForwardIterator last, Predicate pred);
template <class ForwardIterator>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_sorted(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_sorted(ForwardIterator first, ForwardIterator last, Compare comp);
template<class ForwardIterator>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
is_sorted_until(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
is_sorted_until(ForwardIterator first, ForwardIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
sort(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++26
constexpr void // constexpr since C++26
stable_sort(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++26
constexpr void // constexpr since C++26
stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp);
template <class InputIterator, class RandomAccessIterator>
constexpr RandomAccessIterator // constexpr in C++20
constexpr RandomAccessIterator // constexpr since C++20
partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first, RandomAccessIterator result_last);
template <class InputIterator, class RandomAccessIterator, class Compare>
constexpr RandomAccessIterator // constexpr in C++20
constexpr RandomAccessIterator // constexpr since C++20
partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp);
template <class ForwardIterator, class T>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class T, class Compare>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
template <class ForwardIterator, class T>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class T, class Compare>
constexpr ForwardIterator // constexpr in C++20
constexpr ForwardIterator // constexpr since C++20
upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
template <class ForwardIterator, class T>
constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
constexpr pair<ForwardIterator, ForwardIterator> // constexpr since C++20
equal_range(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class T, class Compare>
constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++20
constexpr pair<ForwardIterator, ForwardIterator> // constexpr since C++20
equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
template <class ForwardIterator, class T>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
binary_search(ForwardIterator first, ForwardIterator last, const T& value);
template <class ForwardIterator, class T, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp);
template <class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
merge(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result);
template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
merge(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
@ -1616,123 +1617,123 @@ template <class BidirectionalIterator, class Compare>
inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp);
template <class InputIterator1, class InputIterator2>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
template <class InputIterator1, class InputIterator2, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp);
template <class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_union(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result);
template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_union(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
template <class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_intersection(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result);
template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_intersection(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
template <class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_difference(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result);
template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_difference(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
template <class InputIterator1, class InputIterator2, class OutputIterator>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result);
template <class InputIterator1, class InputIterator2, class OutputIterator, class Compare>
constexpr OutputIterator // constexpr in C++20
constexpr OutputIterator // constexpr since C++20
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
push_heap(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
pop_heap(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
make_heap(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
sort_heap(RandomAccessIterator first, RandomAccessIterator last);
template <class RandomAccessIterator, class Compare>
constexpr void // constexpr in C++20
constexpr void // constexpr since C++20
sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
template <class RandomAccessIterator>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_heap(RandomAccessIterator first, RandomAccessiterator last);
template <class RandomAccessIterator, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
is_heap(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
template <class RandomAccessIterator>
constexpr RandomAccessIterator // constexpr in C++20
constexpr RandomAccessIterator // constexpr since C++20
is_heap_until(RandomAccessIterator first, RandomAccessiterator last);
template <class RandomAccessIterator, class Compare>
constexpr RandomAccessIterator // constexpr in C++20
constexpr RandomAccessIterator // constexpr since C++20
is_heap_until(RandomAccessIterator first, RandomAccessiterator last, Compare comp);
template <class ForwardIterator>
constexpr ForwardIterator // constexpr in C++14
constexpr ForwardIterator // constexpr since C++14
min_element(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
constexpr ForwardIterator // constexpr in C++14
constexpr ForwardIterator // constexpr since C++14
min_element(ForwardIterator first, ForwardIterator last, Compare comp);
template <class T>
constexpr const T& // constexpr in C++14
constexpr const T& // constexpr since C++14
min(const T& a, const T& b);
template <class T, class Compare>
constexpr const T& // constexpr in C++14
constexpr const T& // constexpr since C++14
min(const T& a, const T& b, Compare comp);
template<class T>
constexpr T // constexpr in C++14
constexpr T // constexpr since C++14
min(initializer_list<T> t);
template<class T, class Compare>
constexpr T // constexpr in C++14
constexpr T // constexpr since C++14
min(initializer_list<T> t, Compare comp);
template<class T>
@ -1742,59 +1743,59 @@ template<class T, class Compare>
constexpr const T& clamp(const T& v, const T& lo, const T& hi, Compare comp); // C++17
template <class ForwardIterator>
constexpr ForwardIterator // constexpr in C++14
constexpr ForwardIterator // constexpr since C++14
max_element(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class Compare>
constexpr ForwardIterator // constexpr in C++14
constexpr ForwardIterator // constexpr since C++14
max_element(ForwardIterator first, ForwardIterator last, Compare comp);
template <class T>
constexpr const T& // constexpr in C++14
constexpr const T& // constexpr since C++14
max(const T& a, const T& b);
template <class T, class Compare>
constexpr const T& // constexpr in C++14
constexpr const T& // constexpr since C++14
max(const T& a, const T& b, Compare comp);
template<class T>
constexpr T // constexpr in C++14
constexpr T // constexpr since C++14
max(initializer_list<T> t);
template<class T, class Compare>
constexpr T // constexpr in C++14
constexpr T // constexpr since C++14
max(initializer_list<T> t, Compare comp);
template<class ForwardIterator>
constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
constexpr pair<ForwardIterator, ForwardIterator> // constexpr since C++14
minmax_element(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class Compare>
constexpr pair<ForwardIterator, ForwardIterator> // constexpr in C++14
constexpr pair<ForwardIterator, ForwardIterator> // constexpr since C++14
minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
template<class T>
constexpr pair<const T&, const T&> // constexpr in C++14
constexpr pair<const T&, const T&> // constexpr since C++14
minmax(const T& a, const T& b);
template<class T, class Compare>
constexpr pair<const T&, const T&> // constexpr in C++14
constexpr pair<const T&, const T&> // constexpr since C++14
minmax(const T& a, const T& b, Compare comp);
template<class T>
constexpr pair<T, T> // constexpr in C++14
constexpr pair<T, T> // constexpr since C++14
minmax(initializer_list<T> t);
template<class T, class Compare>
constexpr pair<T, T> // constexpr in C++14
constexpr pair<T, T> // constexpr since C++14
minmax(initializer_list<T> t, Compare comp);
template <class InputIterator1, class InputIterator2>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
template <class InputIterator1, class InputIterator2, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
lexicographical_compare(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, Compare comp);
@ -1811,19 +1812,19 @@ template<class InputIterator1, class InputIterator2>
InputIterator2 first2, InputIterator2 last2); // since C++20
template <class BidirectionalIterator>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
next_permutation(BidirectionalIterator first, BidirectionalIterator last);
template <class BidirectionalIterator, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
template <class BidirectionalIterator>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
template <class BidirectionalIterator, class Compare>
constexpr bool // constexpr in C++20
constexpr bool // constexpr since C++20
prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp);
} // std

32
libcxx/test/std/algorithms/alg.sorting/alg.sort/stable.sort/ranges.stable.sort.pass.cpp
View File

@ -13,11 +13,12 @@
// template<random_access_iterator I, sentinel_for<I> S, class Comp = ranges::less,
// class Proj = identity>
// requires sortable<I, Comp, Proj>
// I ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
// constexpr I // constexpr since C++26
// ranges::stable_sort(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
//
// template<random_access_range R, class Comp = ranges::less, class Proj = identity>
// requires sortable<iterator_t<R>, Comp, Proj>
// borrowed_iterator_t<R>
// constexpr borrowed_iterator_t<R> // constexpr since C++26
// ranges::stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
#include <algorithm>
@ -57,7 +58,7 @@ static_assert(!HasStableSortR<UncheckedRange<int*>, BadComparator>);
static_assert(!HasStableSortR<UncheckedRange<const int*>>); // Doesn't satisfy `sortable`.
template <class Iter, class Sent, std::size_t N>
void test_one(std::array<int, N> input, std::array<int, N> expected) {
TEST_CONSTEXPR_CXX26 void test_one(std::array<int, N> input, std::array<int, N> expected) {
{ // (iterator, sentinel) overload.
auto sorted = input;
auto b = Iter(sorted.data());
@ -81,7 +82,7 @@ void test_one(std::array<int, N> input, std::array<int, N> expected) {
}
template <class Iter, class Sent>
void test_iterators_2() {
TEST_CONSTEXPR_CXX26 void test_iterators_2() {
// Empty sequence.
test_one<Iter, Sent, 0>({}, {});
// 1-element sequence.
@ -105,25 +106,25 @@ void test_iterators_2() {
}
template <class Iter>
void test_iterators_1() {
TEST_CONSTEXPR_CXX26 void test_iterators_1() {
test_iterators_2<Iter, Iter>();
test_iterators_2<Iter, sentinel_wrapper<Iter>>();
}
void test_iterators() {
TEST_CONSTEXPR_CXX26 void test_iterators() {
test_iterators_1<random_access_iterator<int*>>();
test_iterators_1<contiguous_iterator<int*>>();
test_iterators_1<int*>();
}
void test() {
TEST_CONSTEXPR_CXX26 bool test() {
test_iterators();
struct OrderedValue {
int value;
double original_order;
bool operator==(const OrderedValue&) const = default;
auto operator<=>(const OrderedValue& rhs) const { return value <=> rhs.value; }
TEST_CONSTEXPR_CXX26 auto operator<=>(const OrderedValue& rhs) const { return value <=> rhs.value; }
};
{ // The sort is stable (equivalent elements remain in the same order).
@ -214,10 +215,10 @@ void test() {
{ // `std::invoke` is used in the implementation.
struct S {
int i;
S(int i_) : i(i_) {}
TEST_CONSTEXPR_CXX26 S(int i_) : i(i_) {}
bool comparator(const S& rhs) const { return i < rhs.i; }
const S& projection() const { return *this; }
TEST_CONSTEXPR_CXX26 bool comparator(const S& rhs) const { return i < rhs.i; }
TEST_CONSTEXPR_CXX26 const S& projection() const { return *this; }
bool operator==(const S&) const = default;
};
@ -242,8 +243,6 @@ void test() {
std::ranges::stable_sort(std::array{1, 2, 3});
}
// TODO: Enable the tests once the implementation switched to use iter_move/iter_swap
/*
{ // ProxyIterator
{
std::array in = {2, 1, 3};
@ -260,12 +259,15 @@ void test() {
assert((in == std::array{1, 2, 3}));
}
}
*/
return true;
}
int main(int, char**) {
test();
// Note: `stable_sort` is not `constexpr`.
#if TEST_STD_VER >= 26
static_assert(test());
#endif
return 0;
}

4
libcxx/test/std/algorithms/ranges_robust_against_dangling.pass.cpp
View File

@ -204,8 +204,12 @@ constexpr bool test_all() {
dangling_1st(std::ranges::stable_partition, in, unary_pred);
}
dangling_1st(std::ranges::sort, in);
#if TEST_STD_VER < 26
if (!std::is_constant_evaluated())
#endif
{
dangling_1st(std::ranges::stable_sort, in);
}
dangling_1st(std::ranges::partial_sort, in, mid);
dangling_1st(std::ranges::nth_element, in, mid);
if (!std::is_constant_evaluated())

4
libcxx/test/std/algorithms/ranges_robust_against_omitting_invoke.pass.cpp
View File

@ -171,8 +171,12 @@ constexpr bool test_all() {
test(std::ranges::stable_partition, in, &Foo::unary_pred, &Bar::val);
}
test(std::ranges::sort, in, &Foo::binary_pred, &Bar::val);
#if TEST_STD_VER < 26
if (!std::is_constant_evaluated())
#endif
{
test(std::ranges::stable_sort, in, &Foo::binary_pred, &Bar::val);
}
test_mid(std::ranges::partial_sort, in, mid, &Foo::binary_pred, &Bar::val);
test_mid(std::ranges::nth_element, in, mid, &Foo::binary_pred, &Bar::val);
if (!std::is_constant_evaluated())

4
libcxx/test/std/algorithms/ranges_robust_against_proxy_iterators.pass.cpp
View File

@ -174,8 +174,12 @@ constexpr void run_tests() {
test(std::ranges::stable_partition, in, unary_pred);
}
test(std::ranges::sort, in);
#if TEST_STD_VER < 26
if (!std::is_constant_evaluated())
#endif
{
test(std::ranges::stable_sort, in);
}
test_mid(std::ranges::partial_sort, in, mid);
test_mid(std::ranges::nth_element, in, mid);
if (!std::is_constant_evaluated())

4
libcxx/test/support/test_iterators.h
View File

@ -1208,6 +1208,10 @@ struct Proxy {
constexpr const T&& getData() const&& { return static_cast<const T&&>(data); }
// Explicitly declare the copy constructor as defaulted to avoid deprecation of the implicitly declared one
// because of the user-provided copy assignment operator.
Proxy(const Proxy&) = default;
template <class U>
requires std::constructible_from<T, U&&>
constexpr Proxy(U&& u) : data{std::forward<U>(u)} {}