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#ifndef _LIBCPP___ALGORITHM_PSTL_H
10#define _LIBCPP___ALGORITHM_PSTL_H
11
12#include <__config>
13
14#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15# pragma GCC system_header
16#endif
17
18_LIBCPP_PUSH_MACROS
19#include <__undef_macros>
20
21#if _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
22
23# include <__functional/operations.h>
24# include <__iterator/cpp17_iterator_concepts.h>
25# include <__iterator/iterator_traits.h>
26# include <__pstl/backend.h>
27# include <__pstl/dispatch.h>
28# include <__pstl/handle_exception.h>
29# include <__type_traits/enable_if.h>
30# include <__type_traits/is_execution_policy.h>
31# include <__type_traits/remove_cvref.h>
32# include <__utility/forward.h>
33# include <__utility/move.h>
34
35_LIBCPP_BEGIN_NAMESPACE_STD
36
37template <class _ExecutionPolicy,
38 class _ForwardIterator,
39 class _Predicate,
40 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
41 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
42[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
43any_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
44 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "any_of requires a ForwardIterator");
45 using _Implementation = __pstl::__dispatch<__pstl::__any_of, __pstl::__current_configuration, _RawPolicy>;
46 return __pstl::__handle_exception<_Implementation>(
47 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
48}
49
50template <class _ExecutionPolicy,
51 class _ForwardIterator,
52 class _Pred,
53 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
54 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
55[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
56all_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
57 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "all_of requires a ForwardIterator");
58 using _Implementation = __pstl::__dispatch<__pstl::__all_of, __pstl::__current_configuration, _RawPolicy>;
59 return __pstl::__handle_exception<_Implementation>(
60 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
61}
62
63template <class _ExecutionPolicy,
64 class _ForwardIterator,
65 class _Pred,
66 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
67 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
68[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
69none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
70 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "none_of requires a ForwardIterator");
71 using _Implementation = __pstl::__dispatch<__pstl::__none_of, __pstl::__current_configuration, _RawPolicy>;
72 return __pstl::__handle_exception<_Implementation>(
73 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
74}
75
76template <class _ExecutionPolicy,
77 class _ForwardIterator,
78 class _ForwardOutIterator,
79 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
80 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
81_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
82copy(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
83 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
84 _ForwardIterator, "copy(first, last, result) requires [first, last) to be ForwardIterators");
85 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
86 _ForwardOutIterator, "copy(first, last, result) requires result to be a ForwardIterator");
87 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
88 _ForwardOutIterator, decltype(*__first), "copy(first, last, result) requires result to be an OutputIterator");
89 using _Implementation = __pstl::__dispatch<__pstl::__copy, __pstl::__current_configuration, _RawPolicy>;
90 return __pstl::__handle_exception<_Implementation>(
91 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
92}
93
94template <class _ExecutionPolicy,
95 class _ForwardIterator,
96 class _ForwardOutIterator,
97 class _Size,
98 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
99 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
100_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
101copy_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __result) {
102 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
103 _ForwardIterator, "copy_n(first, n, result) requires first to be a ForwardIterator");
104 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
105 _ForwardOutIterator, "copy_n(first, n, result) requires result to be a ForwardIterator");
106 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
107 _ForwardOutIterator, decltype(*__first), "copy_n(first, n, result) requires result to be an OutputIterator");
108 using _Implementation = __pstl::__dispatch<__pstl::__copy_n, __pstl::__current_configuration, _RawPolicy>;
109 return __pstl::__handle_exception<_Implementation>(
110 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__result));
111}
112
113template <class _ExecutionPolicy,
114 class _ForwardIterator,
115 class _Predicate,
116 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
117 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
118[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __iterator_difference_type<_ForwardIterator>
119count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
120 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
121 _ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");
122 using _Implementation = __pstl::__dispatch<__pstl::__count_if, __pstl::__current_configuration, _RawPolicy>;
123 return __pstl::__handle_exception<_Implementation>(
124 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
125}
126
127template <class _ExecutionPolicy,
128 class _ForwardIterator,
129 class _Tp,
130 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
131 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
132[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __iterator_difference_type<_ForwardIterator>
133count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
134 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
135 _ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");
136 using _Implementation = __pstl::__dispatch<__pstl::__count, __pstl::__current_configuration, _RawPolicy>;
137 return __pstl::__handle_exception<_Implementation>(
138 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
139}
140
141template <class _ExecutionPolicy,
142 class _ForwardIterator1,
143 class _ForwardIterator2,
144 class _Pred,
145 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
146 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
147[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
148equal(_ExecutionPolicy&& __policy,
149 _ForwardIterator1 __first1,
150 _ForwardIterator1 __last1,
151 _ForwardIterator2 __first2,
152 _Pred __pred) {
153 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
154 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
155 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
156 return __pstl::__handle_exception<_Implementation>(
157 std::forward<_ExecutionPolicy>(__policy),
158 std::move(__first1),
159 std::move(__last1),
160 std::move(__first2),
161 std::move(__pred));
162}
163
164template <class _ExecutionPolicy,
165 class _ForwardIterator1,
166 class _ForwardIterator2,
167 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
168 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
169[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
170equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
171 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
172 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
173 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
174 return __pstl::__handle_exception<_Implementation>(
175 std::forward<_ExecutionPolicy>(__policy),
176 std::move(__first1),
177 std::move(__last1),
178 std::move(__first2),
179 equal_to{});
180}
181
182template <class _ExecutionPolicy,
183 class _ForwardIterator1,
184 class _ForwardIterator2,
185 class _Pred,
186 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
187 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
188[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
189equal(_ExecutionPolicy&& __policy,
190 _ForwardIterator1 __first1,
191 _ForwardIterator1 __last1,
192 _ForwardIterator2 __first2,
193 _ForwardIterator2 __last2,
194 _Pred __pred) {
195 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
196 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
197 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
198 return __pstl::__handle_exception<_Implementation>(
199 std::forward<_ExecutionPolicy>(__policy),
200 std::move(__first1),
201 std::move(__last1),
202 std::move(__first2),
203 std::move(__last2),
204 std::move(__pred));
205}
206
207template <class _ExecutionPolicy,
208 class _ForwardIterator1,
209 class _ForwardIterator2,
210 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
211 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
212[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
213equal(_ExecutionPolicy&& __policy,
214 _ForwardIterator1 __first1,
215 _ForwardIterator1 __last1,
216 _ForwardIterator2 __first2,
217 _ForwardIterator2 __last2) {
218 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
219 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
220 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
221 return __pstl::__handle_exception<_Implementation>(
222 std::forward<_ExecutionPolicy>(__policy),
223 std::move(__first1),
224 std::move(__last1),
225 std::move(__first2),
226 std::move(__last2),
227 equal_to{});
228}
229
230template <class _ExecutionPolicy,
231 class _ForwardIterator,
232 class _Tp,
233 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
234 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
235_LIBCPP_HIDE_FROM_ABI void
236fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
237 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators");
238 using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>;
239 __pstl::__handle_exception<_Implementation>(
240 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
241}
242
243template <class _ExecutionPolicy,
244 class _ForwardIterator,
245 class _Size,
246 class _Tp,
247 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
248 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
249_LIBCPP_HIDE_FROM_ABI void
250fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) {
251 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator");
252 using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>;
253 __pstl::__handle_exception<_Implementation>(
254 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value);
255}
256
257template <class _ExecutionPolicy,
258 class _ForwardIterator,
259 class _Predicate,
260 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
261 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
262[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
263find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
264 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
265 using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
266 return __pstl::__handle_exception<_Implementation>(
267 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
268}
269
270template <class _ExecutionPolicy,
271 class _ForwardIterator,
272 class _Predicate,
273 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
274 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
275[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
276find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
277 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
278 using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
279 return __pstl::__handle_exception<_Implementation>(
280 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
281}
282
283template <class _ExecutionPolicy,
284 class _ForwardIterator,
285 class _Tp,
286 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
287 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
288[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
289find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
290 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
291 using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;
292 return __pstl::__handle_exception<_Implementation>(
293 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
294}
295
296template <class _ExecutionPolicy,
297 class _ForwardIterator1,
298 class _ForwardIterator2,
299 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
300 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
301[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator1 find_first_of(
302 _ExecutionPolicy&& __policy,
303 _ForwardIterator1 __first1,
304 _ForwardIterator1 __last1,
305 _ForwardIterator2 __first2,
306 _ForwardIterator2 __last2) {
307 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
308 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
309 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
310 return __pstl::__handle_exception<_Implementation>(
311 std::forward<_ExecutionPolicy>(__policy),
312 std::move(__first1),
313 std::move(__last1),
314 std::move(__first2),
315 std::move(__last2),
316 std::equal_to<>{});
317}
318
319template <class _ExecutionPolicy,
320 class _ForwardIterator1,
321 class _ForwardIterator2,
322 class _BinaryPredicate,
323 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
324 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
325[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator1 find_first_of(
326 _ExecutionPolicy&& __policy,
327 _ForwardIterator1 __first1,
328 _ForwardIterator1 __last1,
329 _ForwardIterator2 __first2,
330 _ForwardIterator2 __last2,
331 _BinaryPredicate __pred) {
332 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
333 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
334 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
335 return __pstl::__handle_exception<_Implementation>(
336 std::forward<_ExecutionPolicy>(__policy),
337 std::move(__first1),
338 std::move(__last1),
339 std::move(__first2),
340 std::move(__last2),
341 std::move(__pred));
342}
343
344template <class _ExecutionPolicy,
345 class _ForwardIterator,
346 class _Function,
347 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
348 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
349_LIBCPP_HIDE_FROM_ABI void
350for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
351 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators");
352 using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>;
353 __pstl::__handle_exception<_Implementation>(
354 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func));
355}
356
357template <class _ExecutionPolicy,
358 class _ForwardIterator,
359 class _Size,
360 class _Function,
361 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
362 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
363_LIBCPP_HIDE_FROM_ABI void
364for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
365 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator");
366 using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>;
367 __pstl::__handle_exception<_Implementation>(
368 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func));
369}
370
371template <class _ExecutionPolicy,
372 class _ForwardIterator,
373 class _Generator,
374 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
375 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
376_LIBCPP_HIDE_FROM_ABI void
377generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
378 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators");
379 using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>;
380 __pstl::__handle_exception<_Implementation>(
381 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen));
382}
383
384template <class _ExecutionPolicy,
385 class _ForwardIterator,
386 class _Size,
387 class _Generator,
388 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
389 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
390_LIBCPP_HIDE_FROM_ABI void
391generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) {
392 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator");
393 using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>;
394 __pstl::__handle_exception<_Implementation>(
395 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen));
396}
397
398template <class _ExecutionPolicy,
399 class _BidirectionalIterator,
400 class _ForwardIterator,
401 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
402 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
403[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator reverse_copy(
404 _ExecutionPolicy&& __policy,
405 _BidirectionalIterator __first,
406 _BidirectionalIterator __last,
407 _ForwardIterator __result) {
408 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse_copy requires a BidirectionalIterator");
409 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reverse_copy requires a ForwardIterator");
410 using _Implementation = __pstl::__dispatch<__pstl::__reverse_copy, __pstl::__current_configuration, _RawPolicy>;
411 return __pstl::__handle_exception<_Implementation>(
412 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
413}
414
415template <class _ExecutionPolicy,
416 class _ForwardIterator,
417 class _Predicate,
418 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
419 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
420[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
421is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
422 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators");
423 using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>;
424 return __pstl::__handle_exception<_Implementation>(
425 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
426}
427
428template <class _ExecutionPolicy,
429 class _ForwardIterator1,
430 class _ForwardIterator2,
431 class _ForwardOutIterator,
432 class _Comp,
433 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
434 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
435_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
436merge(_ExecutionPolicy&& __policy,
437 _ForwardIterator1 __first1,
438 _ForwardIterator1 __last1,
439 _ForwardIterator2 __first2,
440 _ForwardIterator2 __last2,
441 _ForwardOutIterator __result,
442 _Comp __comp) {
443 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
444 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
445 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
446 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
447 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
448 return __pstl::__handle_exception<_Implementation>(
449 std::forward<_ExecutionPolicy>(__policy),
450 std::move(__first1),
451 std::move(__last1),
452 std::move(__first2),
453 std::move(__last2),
454 std::move(__result),
455 std::move(__comp));
456}
457
458template <class _ExecutionPolicy,
459 class _ForwardIterator1,
460 class _ForwardIterator2,
461 class _ForwardOutIterator,
462 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
463 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
464_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
465merge(_ExecutionPolicy&& __policy,
466 _ForwardIterator1 __first1,
467 _ForwardIterator1 __last1,
468 _ForwardIterator2 __first2,
469 _ForwardIterator2 __last2,
470 _ForwardOutIterator __result) {
471 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
472 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
473 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
474 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
475 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
476 return __pstl::__handle_exception<_Implementation>(
477 std::forward<_ExecutionPolicy>(__policy),
478 std::move(__first1),
479 std::move(__last1),
480 std::move(__first2),
481 std::move(__last2),
482 std::move(__result),
483 less{});
484}
485
486template <class _ExecutionPolicy,
487 class _ForwardIterator,
488 class _ForwardOutIterator,
489 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
490 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
491_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
492move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
493 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators");
494 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator");
495 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
496 _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator");
497 using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>;
498 return __pstl::__handle_exception<_Implementation>(
499 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
500}
501
502template <class _ExecutionPolicy,
503 class _ForwardIterator,
504 class _Pred,
505 class _Tp,
506 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
507 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
508_LIBCPP_HIDE_FROM_ABI void
509replace_if(_ExecutionPolicy&& __policy,
510 _ForwardIterator __first,
511 _ForwardIterator __last,
512 _Pred __pred,
513 const _Tp& __new_value) {
514 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators");
515 using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>;
516 __pstl::__handle_exception<_Implementation>(
517 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value);
518}
519
520template <class _ExecutionPolicy,
521 class _ForwardIterator,
522 class _Tp,
523 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
524 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
525_LIBCPP_HIDE_FROM_ABI void
526replace(_ExecutionPolicy&& __policy,
527 _ForwardIterator __first,
528 _ForwardIterator __last,
529 const _Tp& __old_value,
530 const _Tp& __new_value) {
531 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators");
532 using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>;
533 __pstl::__handle_exception<_Implementation>(
534 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value);
535}
536
537template <class _ExecutionPolicy,
538 class _ForwardIterator,
539 class _ForwardOutIterator,
540 class _Pred,
541 class _Tp,
542 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
543 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
544_LIBCPP_HIDE_FROM_ABI void replace_copy_if(
545 _ExecutionPolicy&& __policy,
546 _ForwardIterator __first,
547 _ForwardIterator __last,
548 _ForwardOutIterator __result,
549 _Pred __pred,
550 const _Tp& __new_value) {
551 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators");
552 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators");
553 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
554 _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator");
555 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
556 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>;
557 __pstl::__handle_exception<_Implementation>(
558 std::forward<_ExecutionPolicy>(__policy),
559 std::move(__first),
560 std::move(__last),
561 std::move(__result),
562 std::move(__pred),
563 __new_value);
564}
565
566template <class _ExecutionPolicy,
567 class _ForwardIterator,
568 class _ForwardOutIterator,
569 class _Tp,
570 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
571 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
572_LIBCPP_HIDE_FROM_ABI void replace_copy(
573 _ExecutionPolicy&& __policy,
574 _ForwardIterator __first,
575 _ForwardIterator __last,
576 _ForwardOutIterator __result,
577 const _Tp& __old_value,
578 const _Tp& __new_value) {
579 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators");
580 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators");
581 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
582 _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator");
583 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
584 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>;
585 __pstl::__handle_exception<_Implementation>(
586 std::forward<_ExecutionPolicy>(__policy),
587 std::move(__first),
588 std::move(__last),
589 std::move(__result),
590 __old_value,
591 __new_value);
592}
593
594template <class _ExecutionPolicy,
595 class _ForwardIterator,
596 class _ForwardOutIterator,
597 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
598 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
599_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator rotate_copy(
600 _ExecutionPolicy&& __policy,
601 _ForwardIterator __first,
602 _ForwardIterator __middle,
603 _ForwardIterator __last,
604 _ForwardOutIterator __result) {
605 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators");
606 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators");
607 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
608 _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator");
609 using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>;
610 return __pstl::__handle_exception<_Implementation>(
611 std::forward<_ExecutionPolicy>(__policy),
612 std::move(__first),
613 std::move(__middle),
614 std::move(__last),
615 std::move(__result));
616}
617
618template <class _ExecutionPolicy,
619 class _RandomAccessIterator,
620 class _Comp,
621 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
622 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
623_LIBCPP_HIDE_FROM_ABI void
624sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
625 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
626 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
627 __pstl::__handle_exception<_Implementation>(
628 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
629}
630
631template <class _ExecutionPolicy,
632 class _RandomAccessIterator,
633 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
634 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
635_LIBCPP_HIDE_FROM_ABI void
636sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
637 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
638 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
639 __pstl::__handle_exception<_Implementation>(
640 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
641}
642
643template <class _ExecutionPolicy,
644 class _RandomAccessIterator,
645 class _Comp,
646 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
647 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
648_LIBCPP_HIDE_FROM_ABI void
649stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
650 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
651 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
652 __pstl::__handle_exception<_Implementation>(
653 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
654}
655
656template <class _ExecutionPolicy,
657 class _RandomAccessIterator,
658 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
659 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
660_LIBCPP_HIDE_FROM_ABI void
661stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
662 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
663 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
664 __pstl::__handle_exception<_Implementation>(
665 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
666}
667
668template <class _ExecutionPolicy,
669 class _ForwardIterator,
670 class _ForwardOutIterator,
671 class _UnaryOperation,
672 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
673 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
674_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
675 _ExecutionPolicy&& __policy,
676 _ForwardIterator __first,
677 _ForwardIterator __last,
678 _ForwardOutIterator __result,
679 _UnaryOperation __op) {
680 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators");
681 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
682 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
683 _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator");
684 using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>;
685 return __pstl::__handle_exception<_Implementation>(
686 std::forward<_ExecutionPolicy>(__policy),
687 std::move(__first),
688 std::move(__last),
689 std::move(__result),
690 std::move(__op));
691}
692
693template <class _ExecutionPolicy,
694 class _ForwardIterator1,
695 class _ForwardIterator2,
696 class _ForwardOutIterator,
697 class _BinaryOperation,
698 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
699 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
700_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
701 _ExecutionPolicy&& __policy,
702 _ForwardIterator1 __first1,
703 _ForwardIterator1 __last1,
704 _ForwardIterator2 __first2,
705 _ForwardOutIterator __result,
706 _BinaryOperation __op) {
707 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators");
708 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators");
709 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
710 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
711 _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator");
712 using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>;
713 return __pstl::__handle_exception<_Implementation>(
714 std::forward<_ExecutionPolicy>(__policy),
715 std::move(__first1),
716 std::move(__last1),
717 std::move(__first2),
718 std::move(__result),
719 std::move(__op));
720}
721
722template <class _ExecutionPolicy,
723 class _ForwardIterator,
724 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
725 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
726[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
727is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
728 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
729 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
730 return __pstl::__handle_exception<_Implementation>(
731 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
732}
733
734template <class _ExecutionPolicy,
735 class _ForwardIterator,
736 class _Comp,
737 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
738 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
739[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
740is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
741 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
742 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
743 return __pstl::__handle_exception<_Implementation>(
744 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
745}
746
747_LIBCPP_END_NAMESPACE_STD
748
749#endif // _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
750
751_LIBCPP_POP_MACROS
752
753#endif // _LIBCPP___ALGORITHM_PSTL_H
754