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<input_iterator I, sentinel_for<I> S, class T, class Proj = identity,
14 //          indirect_unary_predicate<projected<I, Proj>> Pred>
15 //   requires indirectly_writable<I, const T&>
16 //   constexpr I ranges::replace_if(I first, S last, Pred pred, const T& new_value, Proj proj = {});
17 // template<input_range R, class T, class Proj = identity,
18 //          indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
19 //   requires indirectly_writable<iterator_t<R>, const T&>
20 //   constexpr borrowed_iterator_t<R>
21 //     ranges::replace_if(R&& r, Pred pred, const T& new_value, Proj proj = {});
22 
23 #include <algorithm>
24 #include <array>
25 #include <cassert>
26 #include <ranges>
27 
28 #include "almost_satisfies_types.h"
29 #include "test_iterators.h"
30 
31 struct FalsePredicate {
operator ()FalsePredicate32   bool operator()(auto&&) { return false; }
33 };
34 
35 template <class Iter, class Sent = sentinel_wrapper<Iter>>
36 concept HasReplaceIt = requires(Iter iter, Sent sent) { std::ranges::replace_if(iter, sent, FalsePredicate{}, 0); };
37 
38 static_assert(HasReplaceIt<int*>);
39 static_assert(!HasReplaceIt<InputIteratorNotDerivedFrom>);
40 static_assert(!HasReplaceIt<InputIteratorNotIndirectlyReadable>);
41 static_assert(!HasReplaceIt<InputIteratorNotInputOrOutputIterator>);
42 static_assert(!HasReplaceIt<int*, SentinelForNotSemiregular>);
43 static_assert(!HasReplaceIt<int*, SentinelForNotWeaklyEqualityComparableWith>);
44 static_assert(!HasReplaceIt<int**>); // not indirectly_writable
45 static_assert(!HasReplaceIt<IndirectBinaryPredicateNotIndirectlyReadable>);
46 
47 template <class Range>
48 concept HasReplaceR = requires(Range range) { std::ranges::replace_if(range, FalsePredicate{}, 0); };
49 
50 static_assert(HasReplaceR<UncheckedRange<int*>>);
51 static_assert(!HasReplaceR<InputRangeNotDerivedFrom>);
52 static_assert(!HasReplaceR<InputRangeNotIndirectlyReadable>);
53 static_assert(!HasReplaceR<InputRangeNotInputOrOutputIterator>);
54 static_assert(!HasReplaceR<InputRangeNotSentinelSemiregular>);
55 static_assert(!HasReplaceR<InputRangeNotSentinelEqualityComparableWith>);
56 static_assert(!HasReplaceR<UncheckedRange<int**>>); // not indirectly_writable
57 static_assert(!HasReplaceR<InputRangeIndirectBinaryPredicateNotIndirectlyReadable>);
58 
59 template <class Iter, class Sent, int N, class Pred>
test(std::array<int,N> a_,Pred pred,int val,std::array<int,N> expected)60 constexpr void test(std::array<int, N> a_, Pred pred, int val, std::array<int, N> expected) {
61   {
62     auto a = a_;
63     std::same_as<Iter> auto ret = std::ranges::replace_if(Iter(a.data()), Sent(Iter(a.data() + N)),
64                                                           pred,
65                                                           val);
66     assert(base(ret) == a.data() + N);
67     assert(a == expected);
68   }
69   {
70     auto a = a_;
71     auto range = std::ranges::subrange(Iter(a.data()), Sent(Iter(a.data() + N)));
72     std::same_as<Iter> auto ret = std::ranges::replace_if(range, pred, val);
73     assert(base(ret) == a.data() + N);
74     assert(a == expected);
75   }
76 }
77 
78 template <class Iter, class Sent = Iter>
test_iterators()79 constexpr void test_iterators() {
80   // simple test
81   test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i < 3; }, 23, {23, 23, 3, 4});
82   // no match
83   test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i < 0; }, 23, {1, 2, 3, 4});
84   // all match
85   test<Iter, Sent, 4>({1, 2, 3, 4}, [](int i) { return i > 0; }, 23, {23, 23, 23, 23});
86   // empty range
87   test<Iter, Sent, 0>({}, [](int i) { return i > 0; }, 23, {});
88   // single element range
89   test<Iter, Sent, 1>({1}, [](int i) { return i > 0; }, 2, {2});
90 }
91 
test()92 constexpr bool test() {
93   test_iterators<cpp17_input_iterator<int*>, sentinel_wrapper<cpp17_input_iterator<int*>>>();
94   test_iterators<cpp20_input_iterator<int*>, sentinel_wrapper<cpp20_input_iterator<int*>>>();
95   test_iterators<forward_iterator<int*>>();
96   test_iterators<bidirectional_iterator<int*>>();
97   test_iterators<random_access_iterator<int*>>();
98   test_iterators<contiguous_iterator<int*>>();
99   test_iterators<int*>();
100 
101   { // check that the projection is used
102     struct S {
103       constexpr S(int i_) : i(i_) {}
104       int i;
105     };
106     {
107       S a[] = {1, 2, 3, 4};
108       std::ranges::replace_if(a, a + 4, [](int i) { return i == 3; }, S{0}, &S::i);
109     }
110     {
111       S a[] = {1, 2, 3, 4};
112       std::ranges::replace_if(a, [](int i) { return i == 3; }, S{0}, &S::i);
113     }
114   }
115 
116   { // check that std::invoke is used
117     struct S {
118       constexpr S(int i_) : i(i_) {}
119       constexpr bool check() const { return false; }
120       constexpr const S& identity() const { return *this; }
121       int i;
122     };
123     {
124       S a[] = {1, 2, 3, 4};
125       auto ret = std::ranges::replace_if(std::begin(a), std::end(a), &S::check, S{2}, &S::identity);
126       assert(ret == std::end(a));
127     }
128     {
129       S a[] = {1, 2, 3, 4};
130       auto ret = std::ranges::replace_if(a, &S::check, S{2}, &S::identity);
131       assert(ret == std::end(a));
132     }
133   }
134 
135   { // check that std::ranges::dangling is returned
136     [[maybe_unused]] std::same_as<std::ranges::dangling> decltype(auto) ret =
137         std::ranges::replace_if(std::array {1, 2, 3, 4}, [](int) { return false; }, 1);
138   }
139 
140   { // check that the complexity requirements are met
141     {
142       int predicateCount = 0;
143       auto pred = [&](int) { ++predicateCount; return false; };
144       auto projectionCount = 0;
145       auto proj = [&](int i) { ++projectionCount; return i; };
146       int a[] = {1, 2, 3, 4, 5};
147       auto ret = std::ranges::replace_if(a, a + 5, pred, 1, proj);
148       assert(ret == a + 5);
149       assert(predicateCount == 5);
150       assert(projectionCount == 5);
151     }
152     {
153       int predicateCount = 0;
154       auto pred = [&](int) { ++predicateCount; return false; };
155       auto projectionCount = 0;
156       auto proj = [&](int i) { ++projectionCount; return i; };
157       int a[] = {1, 2, 3, 4, 5};
158       auto ret = std::ranges::replace_if(a, pred, 1, proj);
159       assert(ret == a + 5);
160       assert(predicateCount == 5);
161       assert(projectionCount == 5);
162     }
163   }
164 
165   return true;
166 }
167 
main(int,char **)168 int main(int, char**) {
169   test();
170   static_assert(test());
171 
172   return 0;
173 }
174