[libcxx-commits] [libcxx] 11e3ad2 - [libc++] Implement ranges::is_sorted{, _until}
Nikolas Klauser via libcxx-commits
libcxx-commits at lists.llvm.org
Fri May 27 01:28:51 PDT 2022
Author: Nikolas Klauser
Date: 2022-05-27T10:28:44+02:00
New Revision: 11e3ad299feee35d2a8a1291d9155b68636362e6
URL: https://github.com/llvm/llvm-project/commit/11e3ad299feee35d2a8a1291d9155b68636362e6
DIFF: https://github.com/llvm/llvm-project/commit/11e3ad299feee35d2a8a1291d9155b68636362e6.diff
LOG: [libc++] Implement ranges::is_sorted{, _until}
Reviewed By: Mordante, var-const, #libc
Spies: libcxx-commits, mgorny
Differential Revision: https://reviews.llvm.org/D125608
Added:
libcxx/include/__algorithm/ranges_is_sorted.h
libcxx/include/__algorithm/ranges_is_sorted_until.h
libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.pass.cpp
libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_until.pass.cpp
Modified:
libcxx/docs/Status/RangesAlgorithms.csv
libcxx/include/CMakeLists.txt
libcxx/include/algorithm
libcxx/include/module.modulemap
libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
libcxx/test/libcxx/private_headers.verify.cpp
libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
libcxx/test/support/almost_satisfies_types.h
Removed:
################################################################################
diff --git a/libcxx/docs/Status/RangesAlgorithms.csv b/libcxx/docs/Status/RangesAlgorithms.csv
index 283470af0f11c..c18f1d6d3c71e 100644
--- a/libcxx/docs/Status/RangesAlgorithms.csv
+++ b/libcxx/docs/Status/RangesAlgorithms.csv
@@ -27,8 +27,8 @@ Search,search,Not assigned,n/a,Not started
Search,search_n,Not assigned,n/a,Not started
Search,find_end,Not assigned,n/a,Not started
Read-only,is_partitioned,Nikolas Klauser,`D124440 <https://llvm.org/D124440>`_,✅
-Read-only,is_sorted,Not assigned,n/a,Not started
-Read-only,is_sorted_unitl,Not assigned,n/a,Not started
+Read-only,is_sorted,Nikolas Klauser,`D125608 <https://llvm.org/D125608>`_,✅
+Read-only,is_sorted_unitl,Nikolas Klauser,`D125608 <https://llvm.org/D125608>`_,✅
Read-only,includes,Not assigned,n/a,Not started
Read-only,is_heap,Not assigned,n/a,Not started
Read-only,is_heap_until,Not assigned,n/a,Not started
diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt
index 80261bf2a4537..f1ff3111f6ee8 100644
--- a/libcxx/include/CMakeLists.txt
+++ b/libcxx/include/CMakeLists.txt
@@ -83,6 +83,8 @@ set(files
__algorithm/ranges_for_each.h
__algorithm/ranges_for_each_n.h
__algorithm/ranges_is_partitioned.h
+ __algorithm/ranges_is_sorted.h
+ __algorithm/ranges_is_sorted_until.h
__algorithm/ranges_max.h
__algorithm/ranges_max_element.h
__algorithm/ranges_min.h
diff --git a/libcxx/include/__algorithm/ranges_is_sorted.h b/libcxx/include/__algorithm/ranges_is_sorted.h
new file mode 100644
index 0000000000000..938e69afba8d6
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_is_sorted.h
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H
+#define _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H
+
+#include <__algorithm/ranges_is_sorted_until.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __is_sorted {
+struct __fn {
+ template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
+ class _Proj = identity,
+ indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ bool operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+ return ranges::__is_sorted_until_impl(std::move(__first), __last, __comp, __proj) == __last;
+ }
+
+ template <forward_range _Range,
+ class _Proj = identity,
+ indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ bool operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+ auto __last = ranges::end(__range);
+ return ranges::__is_sorted_until_impl(ranges::begin(__range), __last, __comp, __proj) == __last;
+ }
+};
+} // namespace __is_sorted
+
+inline namespace __cpo {
+ inline constexpr auto is_sorted = __is_sorted::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H
diff --git a/libcxx/include/__algorithm/ranges_is_sorted_until.h b/libcxx/include/__algorithm/ranges_is_sorted_until.h
new file mode 100644
index 0000000000000..c8f0608e12555
--- /dev/null
+++ b/libcxx/include/__algorithm/ranges_is_sorted_until.h
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H
+#define _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+# pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Iter, class _Sent, class _Proj, class _Comp>
+_LIBCPP_HIDE_FROM_ABI constexpr
+_Iter __is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+ if (__first == __last)
+ return __first;
+ auto __i = __first;
+ while (++__i != __last) {
+ if (std::invoke(__comp, std::invoke(__proj, *__i), std::invoke(__proj, *__first)))
+ return __i;
+ __first = __i;
+ }
+ return __i;
+}
+
+namespace __is_sorted_until {
+struct __fn {
+ template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
+ class _Proj = identity,
+ indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+ return ranges::__is_sorted_until_impl(std::move(__first), std::move(__last), __comp, __proj);
+ }
+
+ template <forward_range _Range,
+ class _Proj = identity,
+ indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
+ _LIBCPP_HIDE_FROM_ABI constexpr
+ borrowed_iterator_t<_Range> operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+ return ranges::__is_sorted_until_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
+ }
+};
+} // namespace __is_sorted_until
+
+inline namespace __cpo {
+ inline constexpr auto is_sorted_until = __is_sorted_until::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H
diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 30f647c416f88..864ff1cdcaf63 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -329,6 +329,22 @@ namespace ranges {
indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
constexpr bool ranges::none_of(R&& r, Pred pred, Proj proj = {}); // since C++20
+ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+ indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+ constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
+
+ template<forward_range R, class Proj = identity,
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+ constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
+
+ template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+ indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+ constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {}); // since C++20
+
+ template<forward_range R, class Proj = identity,
+ indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+ constexpr borrowed_iterator_t<R>
+ ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // since C++20
}
constexpr bool // constexpr in C++20
@@ -1062,6 +1078,8 @@ template <class BidirectionalIterator, class Compare>
#include <__algorithm/ranges_for_each.h>
#include <__algorithm/ranges_for_each_n.h>
#include <__algorithm/ranges_is_partitioned.h>
+#include <__algorithm/ranges_is_sorted.h>
+#include <__algorithm/ranges_is_sorted_until.h>
#include <__algorithm/ranges_max.h>
#include <__algorithm/ranges_max_element.h>
#include <__algorithm/ranges_min.h>
diff --git a/libcxx/include/module.modulemap b/libcxx/include/module.modulemap
index 0e43ca4e44b1d..d186ebe1c3457 100644
--- a/libcxx/include/module.modulemap
+++ b/libcxx/include/module.modulemap
@@ -315,6 +315,8 @@ module std [system] {
module ranges_for_each { private header "__algorithm/ranges_for_each.h" }
module ranges_for_each_n { private header "__algorithm/ranges_for_each_n.h" }
module ranges_is_partitioned { private header "__algorithm/ranges_is_partitioned.h" }
+ module ranges_is_sorted { private header "__algorithm/ranges_is_sorted.h" }
+ module ranges_is_sorted_until { private header "__algorithm/ranges_is_sorted_until.h" }
module ranges_max { private header "__algorithm/ranges_max.h" }
module ranges_max_element { private header "__algorithm/ranges_max_element.h" }
module ranges_min { private header "__algorithm/ranges_min.h" }
diff --git a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
index 95f1ed7248df0..b59d9867acdab 100644
--- a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
+++ b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_comparators.pass.cpp
@@ -134,10 +134,10 @@ constexpr bool all_the_algorithms()
//(void)std::ranges::is_partitioned(a, UnaryTrue(&copies)); assert(copies == 0);
//(void)std::ranges::is_permutation(first, last, first2, last2, Equal(&copies)); assert(copies == 0);
//(void)std::ranges::is_permutation(a, b, Equal(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted(first, last, Less(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted(a, Less(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted_until(first, last, Less(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted_until(a, Less(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted(first, last, Less(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted(a, Less(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted_until(first, last, Less(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted_until(a, Less(&copies)); assert(copies == 0);
//if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(first, mid, last, Less(&copies)); assert(copies == 0); }
//if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(a, mid, Less(&copies)); assert(copies == 0); }
//(void)std::ranges::lexicographical_compare(first, last, first2, last2, Less(&copies)); assert(copies == 0);
diff --git a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
index 9efb19d6e3ee0..333e263aafdf9 100644
--- a/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
+++ b/libcxx/test/libcxx/algorithms/ranges_robust_against_copying_projections.pass.cpp
@@ -117,10 +117,10 @@ constexpr bool all_the_algorithms()
//(void)std::ranges::is_partitioned(a, UnaryTrue(), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::is_permutation(first, last, first2, last2, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
//(void)std::ranges::is_permutation(a, b, Equal(), Proj(&copies), Proj(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted(first, last, Less(), Proj(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted(a, Less(), Proj(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted_until(first, last, Less(), Proj(&copies)); assert(copies == 0);
- //(void)std::ranges::is_sorted_until(a, Less(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted(first, last, Less(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted(a, Less(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted_until(first, last, Less(), Proj(&copies)); assert(copies == 0);
+ (void)std::ranges::is_sorted_until(a, Less(), Proj(&copies)); assert(copies == 0);
//if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(first, mid, last, Less(), Proj(&copies)); assert(copies == 0); }
//if (!std::is_constant_evaluated()) { (void)std::ranges::inplace_merge(a, mid, Less(), Proj(&copies)); assert(copies == 0); }
//(void)std::ranges::lexicographical_compare(first, last, first2, last2, Less(), Proj(&copies), Proj(&copies)); assert(copies == 0);
diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp
index d7889f7bb2b8c..c0debf7b8b225 100644
--- a/libcxx/test/libcxx/private_headers.verify.cpp
+++ b/libcxx/test/libcxx/private_headers.verify.cpp
@@ -120,6 +120,8 @@ END-SCRIPT
#include <__algorithm/ranges_for_each.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each.h'}}
#include <__algorithm/ranges_for_each_n.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_for_each_n.h'}}
#include <__algorithm/ranges_is_partitioned.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_partitioned.h'}}
+#include <__algorithm/ranges_is_sorted.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_sorted.h'}}
+#include <__algorithm/ranges_is_sorted_until.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_is_sorted_until.h'}}
#include <__algorithm/ranges_max.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max.h'}}
#include <__algorithm/ranges_max_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max_element.h'}}
#include <__algorithm/ranges_min.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min.h'}}
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.pass.cpp
new file mode 100644
index 0000000000000..767b98c75488c
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted.pass.cpp
@@ -0,0 +1,178 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <algorithm>
+
+// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+// indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+// constexpr bool ranges::is_sorted(I first, S last, Comp comp = {}, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+// constexpr bool ranges::is_sorted(R&& r, Comp comp = {}, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class Iter, class Sent = Iter>
+concept HasIsSortedIt = requires(Iter iter, Sent sent) { std::ranges::is_sorted(iter, sent); };
+
+struct HasNoComparator {};
+
+static_assert(HasIsSortedIt<int*>);
+static_assert(!HasIsSortedIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasIsSortedIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasIsSortedIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasIsSortedIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasIsSortedIt<HasNoComparator*>);
+
+template <class Range>
+concept HasIsSortedR = requires(Range range) { std::ranges::is_sorted(range); };
+
+static_assert(HasIsSortedR<UncheckedRange<int*>>);
+static_assert(!HasIsSortedR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasIsSortedR<ForwardRangeNotIncrementable>);
+static_assert(!HasIsSortedR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasIsSortedR<ForwardRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasIsSortedR<UncheckedRange<HasNoComparator*>>);
+
+template <class Iter, class Sent = Iter>
+constexpr void test_iterators() {
+ { // simple test
+ {
+ int a[] = {1, 2, 3, 4, 3};
+ std::same_as<bool> decltype(auto) ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 5)));
+ assert(!ret);
+ }
+ {
+ int a[] = {1, 2, 3, 4, 3};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+ std::same_as<bool> decltype(auto) ret = std::ranges::is_sorted(range);
+ assert(!ret);
+ }
+ }
+
+ { // second element isn't sorted
+ {
+ int a[] = {1, 0, 3, 4, 5};
+ auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 5)));
+ assert(!ret);
+ }
+ {
+ int a[] = {1, 0, 3, 4, 5};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+ auto ret = std::ranges::is_sorted(range);
+ assert(!ret);
+ }
+ }
+
+ { // all elements are sorted
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 5)));
+ assert(ret);
+ }
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+ auto ret = std::ranges::is_sorted(range);
+ assert(ret);
+ }
+ }
+
+ { // check that the comparator is used
+ {
+ int a[] = {5, 4, 3, 2};
+ auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 4)), std::ranges::greater{});
+ assert(ret);
+ }
+ {
+ int a[] = {5, 4, 3, 2};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 4)));
+ auto ret = std::ranges::is_sorted(range, std::ranges::greater{});
+ assert(ret);
+ }
+ }
+
+ { // check that an empty range works
+ {
+ int a[] = {};
+ auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a)));
+ assert(ret);
+ }
+ {
+ int a[] = {};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a)));
+ auto ret = std::ranges::is_sorted(range);
+ assert(ret);
+ }
+ }
+
+ { // check that a range with a single element works
+ {
+ int a[] = {32};
+ auto ret = std::ranges::is_sorted(Iter(a), Sent(Iter(a + 1)));
+ assert(ret);
+ }
+ {
+ int a[] = {32};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 1)));
+ auto ret = std::ranges::is_sorted(range);
+ assert(ret);
+ }
+ }
+}
+
+constexpr bool test() {
+ test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>();
+ test_iterators<forward_iterator<int*>>();
+ test_iterators<bidirectional_iterator<int*>>();
+ test_iterators<random_access_iterator<int*>>();
+ test_iterators<contiguous_iterator<int*>>();
+ test_iterators<int*>();
+ test_iterators<const int*>();
+
+ { // check that the projection is used
+ struct S {
+ int i;
+ constexpr S(int i_) : i(i_) {}
+ };
+ {
+ S a[] = {1, 2, 3};
+ auto ret = std::ranges::is_sorted(a, a + 3, {}, &S::i);
+ assert(ret);
+ }
+ {
+ S a[] = {1, 2, 3};
+ auto ret = std::ranges::is_sorted(a, {}, &S::i);
+ assert(ret);
+ }
+ }
+
+ { // check that a dangling range works
+ assert(std::ranges::is_sorted(std::array{1, 2, 3, 4}));
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_until.pass.cpp b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_until.pass.cpp
new file mode 100644
index 0000000000000..4174cb341d897
--- /dev/null
+++ b/libcxx/test/std/algorithms/alg.sorting/alg.sort/is.sorted/ranges.is_sorted_until.pass.cpp
@@ -0,0 +1,180 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <algorithm>
+
+// template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+// indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>
+// constexpr I ranges::is_sorted_until(I first, S last, Comp comp = {}, Proj proj = {});
+// template<forward_range R, class Proj = identity,
+// indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
+// constexpr borrowed_iterator_t<R>
+// ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <concepts>
+#include <functional>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "test_iterators.h"
+
+template <class Iter, class Sent = Iter>
+concept HasIsSortedUntilIt = requires(Iter iter, Sent sent) { std::ranges::is_sorted_until(iter, sent); };
+
+struct HasNoComparator {};
+
+static_assert(HasIsSortedUntilIt<int*>);
+static_assert(!HasIsSortedUntilIt<ForwardIteratorNotDerivedFrom>);
+static_assert(!HasIsSortedUntilIt<ForwardIteratorNotIncrementable>);
+static_assert(!HasIsSortedUntilIt<int*, SentinelForNotSemiregular>);
+static_assert(!HasIsSortedUntilIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
+static_assert(!HasIsSortedUntilIt<HasNoComparator*>);
+
+template <class Range>
+concept HasIsSortedUntilR = requires(Range range) { std::ranges::is_sorted_until(range); };
+
+static_assert(HasIsSortedUntilR<UncheckedRange<int*>>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotDerivedFrom>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotIncrementable>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotSentinelSemiregular>);
+static_assert(!HasIsSortedUntilR<ForwardRangeNotSentinelEqualityComparableWith>);
+static_assert(!HasIsSortedUntilR<UncheckedRange<HasNoComparator*>>);
+
+template <class Iter, class Sent = Iter>
+constexpr void test_iterators() {
+ { // simple test
+ {
+ int a[] = {1, 2, 3, 4, 3};
+ std::same_as<Iter> auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 5)));
+ assert(base(ret) == a + 4);
+ }
+ {
+ int a[] = {1, 2, 3, 4, 3};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+ std::same_as<Iter> auto ret = std::ranges::is_sorted_until(range);
+ assert(base(ret) == a + 4);
+ }
+ }
+
+ { // second element isn't sorted
+ {
+ int a[] = {1, 0, 3, 4, 5};
+ auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 5)));
+ assert(base(ret) == a + 1);
+ }
+ {
+ int a[] = {1, 0, 3, 4, 5};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+ auto ret = std::ranges::is_sorted_until(range);
+ assert(base(ret) == a + 1);
+ }
+ }
+
+ { // all elements are sorted
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 5)));
+ assert(base(ret) == a + 5);
+ }
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 5)));
+ auto ret = std::ranges::is_sorted_until(range);
+ assert(base(ret) == a + 5);
+ }
+ }
+
+ { // check that the comparator is used
+ {
+ int a[] = {5, 4, 3, 2};
+ auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 4)), std::ranges::greater{});
+ assert(base(ret) == a + 4);
+ }
+ {
+ int a[] = {5, 4, 3, 2};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 4)));
+ auto ret = std::ranges::is_sorted_until(range, std::ranges::greater{});
+ assert(base(ret) == a + 4);
+ }
+ }
+
+ { // check that an empty range works
+ {
+ int a[] = {};
+ auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a)));
+ assert(base(ret) == a);
+ }
+ {
+ int a[] = {};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a)));
+ auto ret = std::ranges::is_sorted_until(range);
+ assert(base(ret) == a);
+ }
+ }
+
+ { // check that a range with a single element works
+ {
+ int a[] = {32};
+ auto ret = std::ranges::is_sorted_until(Iter(a), Sent(Iter(a + 1)));
+ assert(base(ret) == a + 1);
+ }
+ {
+ int a[] = {32};
+ auto range = std::ranges::subrange(Iter(a), Sent(Iter(a + 1)));
+ auto ret = std::ranges::is_sorted_until(range);
+ assert(base(ret) == a + 1);
+ }
+ }
+}
+
+constexpr bool test() {
+ test_iterators<forward_iterator<int*>, sentinel_wrapper<forward_iterator<int*>>>();
+ test_iterators<forward_iterator<int*>>();
+ test_iterators<bidirectional_iterator<int*>>();
+ test_iterators<random_access_iterator<int*>>();
+ test_iterators<contiguous_iterator<int*>>();
+ test_iterators<int*>();
+ test_iterators<const int*>();
+
+ { // check that the projection is used
+ struct S {
+ int i;
+ constexpr S(int i_) : i(i_) {}
+ };
+ {
+ S a[] = {1, 2, 3};
+ auto ret = std::ranges::is_sorted_until(a, a + 3, {}, &S::i);
+ assert(base(ret) == a + 3);
+ }
+ {
+ S a[] = {1, 2, 3};
+ auto ret = std::ranges::is_sorted_until(a, {}, &S::i);
+ assert(base(ret) == a + 3);
+ }
+ }
+
+ { // check that std::ranges::dangling is returned
+ [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
+ std::ranges::is_sorted_until(std::array{1, 2, 3});
+ }
+
+ return true;
+}
+
+int main(int, char**) {
+ test();
+ static_assert(test());
+
+ return 0;
+}
diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
index 47707c091c475..75c0905c3a0e8 100644
--- a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
+++ b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp
@@ -91,8 +91,8 @@ static_assert(test(std::ranges::find_if_not, a, odd));
//static_assert(test(std::ranges::is_heap_until, a));
//static_assert(test(std::ranges::is_partitioned, a, odd));
//static_assert(test(std::ranges::is_permutation, a, a));
-//static_assert(test(std::ranges::is_sorted, a));
-//static_assert(test(std::ranges::is_sorted_until, a));
+static_assert(test(std::ranges::is_sorted, a));
+static_assert(test(std::ranges::is_sorted_until, a));
//static_assert(test(std::ranges::lexicographical_compare, a, a));
//static_assert(test(std::ranges::lower_bound, a, 42));
//static_assert(test(std::ranges::make_heap, a));
diff --git a/libcxx/test/support/almost_satisfies_types.h b/libcxx/test/support/almost_satisfies_types.h
index 99ea852d2ff9a..eaab3e4693f41 100644
--- a/libcxx/test/support/almost_satisfies_types.h
+++ b/libcxx/test/support/almost_satisfies_types.h
@@ -142,6 +142,49 @@ class WeaklyIncrementableNotMovable {
static_assert(!std::movable<WeaklyIncrementableNotMovable>);
static_assert(!std::weakly_incrementable<WeaklyIncrementableNotMovable>);
+// almost a forward_iterator
+class ForwardIteratorNotDerivedFrom {
+public:
+ using
diff erence_type = long;
+ using value_type = int;
+ using iterator_category = std::input_iterator_tag;
+
+ ForwardIteratorNotDerivedFrom& operator++();
+ ForwardIteratorNotDerivedFrom operator++(int);
+ const int& operator*() const;
+ bool operator==(const ForwardIteratorNotDerivedFrom&) const = default;
+};
+
+using ForwardRangeNotDerivedFrom = UncheckedRange<ForwardIteratorNotDerivedFrom>;
+
+static_assert(std::input_iterator<ForwardIteratorNotDerivedFrom>);
+static_assert(std::incrementable<ForwardIteratorNotDerivedFrom>);
+static_assert(std::sentinel_for<ForwardIteratorNotDerivedFrom, ForwardIteratorNotDerivedFrom>);
+static_assert(!std::forward_iterator<ForwardIteratorNotDerivedFrom>);
+
+class ForwardIteratorNotIncrementable {
+public:
+ using
diff erence_type = long;
+ using value_type = int;
+ using iterator_category = std::forward_iterator_tag;
+
+ ForwardIteratorNotIncrementable& operator++();
+ int operator++(int);
+ const int& operator*() const;
+ bool operator==(const ForwardIteratorNotIncrementable&) const = default;
+};
+
+using ForwardRangeNotIncrementable = UncheckedRange<ForwardIteratorNotIncrementable>;
+
+static_assert(std::input_iterator<ForwardIteratorNotIncrementable>);
+static_assert(!std::incrementable<ForwardIteratorNotIncrementable>);
+static_assert(std::sentinel_for<ForwardIteratorNotIncrementable, ForwardIteratorNotIncrementable>);
+static_assert(!std::forward_iterator<ForwardIteratorNotIncrementable>);
+
+using ForwardRangeNotSentinelSemiregular = UncheckedRange<forward_iterator<int*>, SentinelForNotSemiregular>;
+using ForwardRangeNotSentinelEqualityComparableWith =
+ UncheckedRange<forward_iterator<int*>, SentinelForNotWeaklyEqualityComparableWith>;
+
class BidirectionalIteratorNotDerivedFrom {
public:
using
diff erence_type = long;
More information about the libcxx-commits
mailing list