1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// <algorithm>
10
11// UNSUPPORTED: c++03, c++11, c++14, c++17
12
13// template<class T, class Proj = identity,
14// indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
15// constexpr const T&
16// ranges::clamp(const T& v, const T& lo, const T& hi, Comp comp = {}, Proj proj = {});
17
18#include <algorithm>
19#include <cassert>
20#include <concepts>
21#include <functional>
22#include <iterator>
23#include <utility>
24
25template <class T, class Comp = std::ranges::less, class Proj = std::identity>
26concept HasClamp =
27 requires(T&& val, T&& low, T&& high, Comp&& comp, Proj&& proj) {
28 std::ranges::clamp(std::forward<T>(val), std::forward<T>(low), std::forward<T>(high),
29 std::forward<Comp>(comp), std::forward<Proj>(proj));
30 };
31
32struct NoComp {};
33struct CreateNoComp {
34 auto operator()(int) const { return NoComp(); }
35};
36
37static_assert(HasClamp<int, std::ranges::less, std::identity>);
38static_assert(!HasClamp<NoComp>);
39static_assert(!HasClamp<int, NoComp>);
40static_assert(!HasClamp<int, std::ranges::less, CreateNoComp>);
41
42struct EnsureValueCategoryComp {
43 constexpr bool operator()(const int&& x, const int&& y) const { return x < y; }
44 constexpr bool operator()(const int&& x, int& y) const { return x < y; }
45 constexpr bool operator()(int& x, const int&& y) const { return x < y; }
46 constexpr bool operator()(int& x, int& y) const { return x < y; }
47 constexpr bool operator()(std::same_as<const int&> auto&& x, std::same_as<const int&> auto&& y) const {
48 return x < y;
49 }
50};
51
52constexpr bool test() {
53 { // low < val < high
54 int val = 2;
55 int low = 1;
56 int high = 3;
57 std::same_as<const int&> decltype(auto) ret = std::ranges::clamp(val, low, high);
58 assert(ret == 2);
59 assert(&ret == &val);
60 }
61
62 { // low > val < high
63 assert(std::ranges::clamp(10, 20, 30) == 20);
64 }
65
66 { // low < val > high
67 assert(std::ranges::clamp(15, 5, 10) == 10);
68 }
69
70 { // low == val == high
71 int val = 10;
72 assert(&std::ranges::clamp(val, 10, 10) == &val);
73 }
74
75 { // Check that a custom comparator works.
76 assert(std::ranges::clamp(10, 30, 20, std::ranges::greater{}) == 20);
77 }
78
79 { // Check that a custom projection works.
80 struct S {
81 int i;
82 constexpr bool operator==(S const& other) const { return i == other.i; }
83 };
84
85 auto val = S{.i: 10};
86 auto low = S{.i: 20};
87 auto high = S{.i: 30};
88 auto proj = [](S const& s) -> int const& { return s.i; };
89
90 assert(std::ranges::clamp(val, low, high, std::less{}, proj) == low);
91 }
92
93 { // Ensure that we respect the value category of the projection when calling the comparator.
94 // This additional example was provided by Tim Song in https://github.com/microsoft/STL/issues/3970#issuecomment-1685120958.
95 struct MoveProj {
96 constexpr int const&& operator()(int const& x) const { return std::move(x); }
97 };
98
99 static_assert(std::indirect_strict_weak_order<EnsureValueCategoryComp, std::projected<const int*, MoveProj>>);
100
101 assert(std::ranges::clamp(0, 1, 2, EnsureValueCategoryComp{}, MoveProj{}) == 1);
102 }
103
104 { // Make sure we don't call the projection more than three times per [alg.clamp], see #64717
105 int counter = 0;
106 auto projection_function = [&counter](const int value) -> int {
107 counter++;
108 return value;
109 };
110 assert(std::ranges::clamp(3, 2, 4, std::ranges::less{}, projection_function) == 3);
111#if defined(_LIBCPP_HARDENING_MODE) && \
112 _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_EXTENSIVE && \
113 _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_DEBUG
114 assert(counter <= 3);
115#endif
116 }
117
118 return true;
119}
120
121int main(int, char**) {
122 test();
123 static_assert(test());
124
125 return 0;
126}
127

source code of libcxx/test/std/algorithms/alg.sorting/alg.clamp/ranges.clamp.pass.cpp