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 <__execution/is_execution_policy.h>
24# include <__functional/operations.h>
25# include <__iterator/cpp17_iterator_concepts.h>
26# include <__iterator/iterator_traits.h>
27# include <__pstl/backend.h>
28# include <__pstl/dispatch.h>
29# include <__pstl/handle_exception.h>
30# include <__type_traits/enable_if.h>
31# include <__type_traits/remove_cvref.h>
32# include <__utility/forward.h>
33# include <__utility/move.h>
34# include <__utility/pair.h>
35
36_LIBCPP_BEGIN_NAMESPACE_STD
37
38template <class _ExecutionPolicy,
39 class _ForwardIterator,
40 class _Predicate,
41 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
42 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
43[[nodiscard]] bool
44any_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
45 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "any_of requires a ForwardIterator");
46 using _Implementation = __pstl::__dispatch<__pstl::__any_of, __pstl::__current_configuration, _RawPolicy>;
47 return __pstl::__handle_exception<_Implementation>(
48 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
49}
50
51template <class _ExecutionPolicy,
52 class _ForwardIterator,
53 class _Pred,
54 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
55 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
56[[nodiscard]] bool
57all_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
58 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "all_of requires a ForwardIterator");
59 using _Implementation = __pstl::__dispatch<__pstl::__all_of, __pstl::__current_configuration, _RawPolicy>;
60 return __pstl::__handle_exception<_Implementation>(
61 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
62}
63
64template <class _ExecutionPolicy,
65 class _ForwardIterator,
66 class _Pred,
67 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
68 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
69[[nodiscard]] bool
70none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
71 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "none_of requires a ForwardIterator");
72 using _Implementation = __pstl::__dispatch<__pstl::__none_of, __pstl::__current_configuration, _RawPolicy>;
73 return __pstl::__handle_exception<_Implementation>(
74 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
75}
76
77template <class _ExecutionPolicy,
78 class _ForwardIterator,
79 class _ForwardOutIterator,
80 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
81 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
82_ForwardOutIterator
83copy(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
84 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
85 _ForwardIterator, "copy(first, last, result) requires [first, last) to be ForwardIterators");
86 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
87 _ForwardOutIterator, "copy(first, last, result) requires result to be a ForwardIterator");
88 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
89 _ForwardOutIterator, decltype(*__first), "copy(first, last, result) requires result to be an OutputIterator");
90 using _Implementation = __pstl::__dispatch<__pstl::__copy, __pstl::__current_configuration, _RawPolicy>;
91 return __pstl::__handle_exception<_Implementation>(
92 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
93}
94
95template <class _ExecutionPolicy,
96 class _ForwardIterator,
97 class _ForwardOutIterator,
98 class _Size,
99 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
100 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
101_ForwardOutIterator
102copy_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __result) {
103 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
104 _ForwardIterator, "copy_n(first, n, result) requires first to be a ForwardIterator");
105 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
106 _ForwardOutIterator, "copy_n(first, n, result) requires result to be a ForwardIterator");
107 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
108 _ForwardOutIterator, decltype(*__first), "copy_n(first, n, result) requires result to be an OutputIterator");
109 using _Implementation = __pstl::__dispatch<__pstl::__copy_n, __pstl::__current_configuration, _RawPolicy>;
110 return __pstl::__handle_exception<_Implementation>(
111 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__result));
112}
113
114template <class _ExecutionPolicy,
115 class _ForwardIterator,
116 class _Predicate,
117 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
118 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
119[[nodiscard]] __iterator_difference_type<_ForwardIterator>
120count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
121 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
122 _ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");
123 using _Implementation = __pstl::__dispatch<__pstl::__count_if, __pstl::__current_configuration, _RawPolicy>;
124 return __pstl::__handle_exception<_Implementation>(
125 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
126}
127
128template <class _ExecutionPolicy,
129 class _ForwardIterator,
130 class _Tp,
131 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
132 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
133[[nodiscard]] __iterator_difference_type<_ForwardIterator>
134count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
135 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
136 _ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");
137 using _Implementation = __pstl::__dispatch<__pstl::__count, __pstl::__current_configuration, _RawPolicy>;
138 return __pstl::__handle_exception<_Implementation>(
139 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
140}
141
142template <class _ExecutionPolicy,
143 class _ForwardIterator,
144 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
145 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
146[[nodiscard]] _ForwardIterator
147max_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
148 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "max_element requires ForwardIterators");
149 using _Implementation = __pstl::__dispatch<__pstl::__max_element, __pstl::__current_configuration, _RawPolicy>;
150 return __pstl::__handle_exception<_Implementation>(
151 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less<>{});
152}
153
154template <class _ExecutionPolicy,
155 class _ForwardIterator,
156 class _Compare,
157 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
158 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
159[[nodiscard]] _ForwardIterator
160max_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
161 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "max_element requires ForwardIterators");
162 using _Implementation = __pstl::__dispatch<__pstl::__max_element, __pstl::__current_configuration, _RawPolicy>;
163 return __pstl::__handle_exception<_Implementation>(
164 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
165}
166
167template <class _ExecutionPolicy,
168 class _ForwardIterator,
169 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
170 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
171[[nodiscard]] _ForwardIterator
172min_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
173 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "min_element requires ForwardIterators");
174 using _Implementation = __pstl::__dispatch<__pstl::__min_element, __pstl::__current_configuration, _RawPolicy>;
175 return __pstl::__handle_exception<_Implementation>(
176 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less<>{});
177}
178
179template <class _ExecutionPolicy,
180 class _ForwardIterator,
181 class _Compare,
182 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
183 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
184[[nodiscard]] _ForwardIterator
185min_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
186 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "min_element requires ForwardIterators");
187 using _Implementation = __pstl::__dispatch<__pstl::__min_element, __pstl::__current_configuration, _RawPolicy>;
188 return __pstl::__handle_exception<_Implementation>(
189 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
190}
191
192template <class _ExecutionPolicy,
193 class _ForwardIterator,
194 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
195 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
196[[nodiscard]] pair<_ForwardIterator, _ForwardIterator>
197minmax_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
198 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "minmax_element requires ForwardIterators");
199 using _Implementation = __pstl::__dispatch<__pstl::__minmax_element, __pstl::__current_configuration, _RawPolicy>;
200 return __pstl::__handle_exception<_Implementation>(
201 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less<>{});
202}
203
204template <class _ExecutionPolicy,
205 class _ForwardIterator,
206 class _Compare,
207 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
208 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
209[[nodiscard]] pair<_ForwardIterator, _ForwardIterator>
210minmax_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
211 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "minmax_element requires ForwardIterators");
212 using _Implementation = __pstl::__dispatch<__pstl::__minmax_element, __pstl::__current_configuration, _RawPolicy>;
213 return __pstl::__handle_exception<_Implementation>(
214 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
215}
216
217template <class _ExecutionPolicy,
218 class _ForwardIterator1,
219 class _ForwardIterator2,
220 class _BinaryPredicate,
221 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
222 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
223[[nodiscard]] pair<_ForwardIterator1, _ForwardIterator2>
224mismatch(_ExecutionPolicy&& __policy,
225 _ForwardIterator1 __first1,
226 _ForwardIterator1 __last1,
227 _ForwardIterator2 __first2,
228 _ForwardIterator2 __last2,
229 _BinaryPredicate __pred) {
230 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
231 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
232 using _Implementation = __pstl::__dispatch<__pstl::__mismatch, __pstl::__current_configuration, _RawPolicy>;
233 return __pstl::__handle_exception<_Implementation>(
234 std::forward<_ExecutionPolicy>(__policy),
235 std::move(__first1),
236 std::move(__last1),
237 std::move(__first2),
238 std::move(__last2),
239 std::move(__pred));
240}
241
242template <class _ExecutionPolicy,
243 class _ForwardIterator1,
244 class _ForwardIterator2,
245 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
246 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
247[[nodiscard]] pair<_ForwardIterator1, _ForwardIterator2>
248mismatch(_ExecutionPolicy&& __policy,
249 _ForwardIterator1 __first1,
250 _ForwardIterator1 __last1,
251 _ForwardIterator2 __first2,
252 _ForwardIterator2 __last2) {
253 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
254 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
255 using _Implementation = __pstl::__dispatch<__pstl::__mismatch, __pstl::__current_configuration, _RawPolicy>;
256 return __pstl::__handle_exception<_Implementation>(
257 std::forward<_ExecutionPolicy>(__policy),
258 std::move(__first1),
259 std::move(__last1),
260 std::move(__first2),
261 std::move(__last2),
262 equal_to{});
263}
264
265template <class _ExecutionPolicy,
266 class _ForwardIterator1,
267 class _ForwardIterator2,
268 class _BinaryPredicate,
269 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
270 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
271[[nodiscard]] pair<_ForwardIterator1, _ForwardIterator2>
272mismatch(_ExecutionPolicy&& __policy,
273 _ForwardIterator1 __first1,
274 _ForwardIterator1 __last1,
275 _ForwardIterator2 __first2,
276 _BinaryPredicate __pred) {
277 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
278 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
279 using _Implementation = __pstl::__dispatch<__pstl::__mismatch_3leg, __pstl::__current_configuration, _RawPolicy>;
280 return __pstl::__handle_exception<_Implementation>(
281 std::forward<_ExecutionPolicy>(__policy),
282 std::move(__first1),
283 std::move(__last1),
284 std::move(__first2),
285 std::move(__pred));
286}
287
288template <class _ExecutionPolicy,
289 class _ForwardIterator1,
290 class _ForwardIterator2,
291 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
292 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
293[[nodiscard]] pair<_ForwardIterator1, _ForwardIterator2> mismatch(
294 _ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
295 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
296 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
297 using _Implementation = __pstl::__dispatch<__pstl::__mismatch_3leg, __pstl::__current_configuration, _RawPolicy>;
298 return __pstl::__handle_exception<_Implementation>(
299 std::forward<_ExecutionPolicy>(__policy),
300 std::move(__first1),
301 std::move(__last1),
302 std::move(__first2),
303 equal_to{});
304}
305
306template <class _ExecutionPolicy,
307 class _ForwardIterator,
308 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
309 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
310[[nodiscard]] _ForwardIterator
311adjacent_find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
312 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "adjacent_find requires ForwardIterators");
313 using _Implementation = __pstl::__dispatch<__pstl::__adjacent_find, __pstl::__current_configuration, _RawPolicy>;
314 return __pstl::__handle_exception<_Implementation>(
315 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), equal_to{});
316}
317
318template <class _ExecutionPolicy,
319 class _ForwardIterator,
320 class _BinaryPredicate,
321 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
322 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
323[[nodiscard]] _ForwardIterator adjacent_find(
324 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __predicate) {
325 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "adjacent_find requires ForwardIterators");
326 using _Implementation = __pstl::__dispatch<__pstl::__adjacent_find, __pstl::__current_configuration, _RawPolicy>;
327 return __pstl::__handle_exception<_Implementation>(
328 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__predicate));
329}
330
331template <class _ExecutionPolicy,
332 class _ForwardIterator1,
333 class _ForwardIterator2,
334 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
335 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
336[[nodiscard]] bool lexicographical_compare(
337 _ExecutionPolicy&& __policy,
338 _ForwardIterator1 __first1,
339 _ForwardIterator1 __last1,
340 _ForwardIterator2 __first2,
341 _ForwardIterator2 __last2) {
342 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "lexicographical_compare requires ForwardIterators");
343 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "lexicographical_compare requires ForwardIterators");
344 using _Implementation =
345 __pstl::__dispatch<__pstl::__lexicographical_compare, __pstl::__current_configuration, _RawPolicy>;
346 return __pstl::__handle_exception<_Implementation>(
347 std::forward<_ExecutionPolicy>(__policy),
348 std::move(__first1),
349 std::move(__last1),
350 std::move(__first2),
351 std::move(__last2),
352 less<>{});
353}
354
355template <class _ExecutionPolicy,
356 class _ForwardIterator1,
357 class _ForwardIterator2,
358 class _Comp,
359 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
360 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
361[[nodiscard]] bool lexicographical_compare(
362 _ExecutionPolicy&& __policy,
363 _ForwardIterator1 __first1,
364 _ForwardIterator1 __last1,
365 _ForwardIterator2 __first2,
366 _ForwardIterator2 __last2,
367 _Comp __comp) {
368 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "lexicographical_compare requires ForwardIterators");
369 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "lexicographical_compare requires ForwardIterators");
370 using _Implementation =
371 __pstl::__dispatch<__pstl::__lexicographical_compare, __pstl::__current_configuration, _RawPolicy>;
372 return __pstl::__handle_exception<_Implementation>(
373 std::forward<_ExecutionPolicy>(__policy),
374 std::move(__first1),
375 std::move(__last1),
376 std::move(__first2),
377 std::move(__last2),
378 std::move(__comp));
379}
380
381template <class _ExecutionPolicy,
382 class _ForwardIterator1,
383 class _ForwardIterator2,
384 class _Pred,
385 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
386 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
387[[nodiscard]] bool
388equal(_ExecutionPolicy&& __policy,
389 _ForwardIterator1 __first1,
390 _ForwardIterator1 __last1,
391 _ForwardIterator2 __first2,
392 _Pred __pred) {
393 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
394 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
395 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
396 return __pstl::__handle_exception<_Implementation>(
397 std::forward<_ExecutionPolicy>(__policy),
398 std::move(__first1),
399 std::move(__last1),
400 std::move(__first2),
401 std::move(__pred));
402}
403
404template <class _ExecutionPolicy,
405 class _ForwardIterator1,
406 class _ForwardIterator2,
407 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
408 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
409[[nodiscard]] bool
410equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
411 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
412 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
413 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
414 return __pstl::__handle_exception<_Implementation>(
415 std::forward<_ExecutionPolicy>(__policy),
416 std::move(__first1),
417 std::move(__last1),
418 std::move(__first2),
419 equal_to{});
420}
421
422template <class _ExecutionPolicy,
423 class _ForwardIterator1,
424 class _ForwardIterator2,
425 class _Pred,
426 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
427 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
428[[nodiscard]] bool
429equal(_ExecutionPolicy&& __policy,
430 _ForwardIterator1 __first1,
431 _ForwardIterator1 __last1,
432 _ForwardIterator2 __first2,
433 _ForwardIterator2 __last2,
434 _Pred __pred) {
435 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
436 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
437 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
438 return __pstl::__handle_exception<_Implementation>(
439 std::forward<_ExecutionPolicy>(__policy),
440 std::move(__first1),
441 std::move(__last1),
442 std::move(__first2),
443 std::move(__last2),
444 std::move(__pred));
445}
446
447template <class _ExecutionPolicy,
448 class _ForwardIterator1,
449 class _ForwardIterator2,
450 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
451 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
452[[nodiscard]] bool
453equal(_ExecutionPolicy&& __policy,
454 _ForwardIterator1 __first1,
455 _ForwardIterator1 __last1,
456 _ForwardIterator2 __first2,
457 _ForwardIterator2 __last2) {
458 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
459 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
460 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
461 return __pstl::__handle_exception<_Implementation>(
462 std::forward<_ExecutionPolicy>(__policy),
463 std::move(__first1),
464 std::move(__last1),
465 std::move(__first2),
466 std::move(__last2),
467 equal_to{});
468}
469
470template <class _ExecutionPolicy,
471 class _ForwardIterator,
472 class _Tp,
473 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
474 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
475void fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
476 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators");
477 using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>;
478 __pstl::__handle_exception<_Implementation>(
479 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
480}
481
482template <class _ExecutionPolicy,
483 class _ForwardIterator,
484 class _Size,
485 class _Tp,
486 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
487 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
488_ForwardIterator fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) {
489 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator");
490 using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>;
491 return __pstl::__handle_exception<_Implementation>(
492 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value);
493}
494
495template <class _ExecutionPolicy,
496 class _ForwardIterator1,
497 class _ForwardIterator2,
498 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
499 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
500[[nodiscard]] _ForwardIterator1
501find_end(_ExecutionPolicy&& __policy,
502 _ForwardIterator1 __first1,
503 _ForwardIterator1 __last1,
504 _ForwardIterator2 __first2,
505 _ForwardIterator2 __last2) {
506 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_end requires ForwardIterators");
507 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_end requires ForwardIterators");
508 using _Implementation = __pstl::__dispatch<__pstl::__find_end, __pstl::__current_configuration, _RawPolicy>;
509 return __pstl::__handle_exception<_Implementation>(
510 std::forward<_ExecutionPolicy>(__policy),
511 std::move(__first1),
512 std::move(__last1),
513 std::move(__first2),
514 std::move(__last2),
515 equal_to<>{});
516}
517
518template <class _ExecutionPolicy,
519 class _ForwardIterator1,
520 class _ForwardIterator2,
521 class _BinaryPredicate,
522 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
523 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
524[[nodiscard]] _ForwardIterator1
525find_end(_ExecutionPolicy&& __policy,
526 _ForwardIterator1 __first1,
527 _ForwardIterator1 __last1,
528 _ForwardIterator2 __first2,
529 _ForwardIterator2 __last2,
530 _BinaryPredicate __pred) {
531 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_end requires ForwardIterators");
532 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_end requires ForwardIterators");
533 using _Implementation = __pstl::__dispatch<__pstl::__find_end, __pstl::__current_configuration, _RawPolicy>;
534 return __pstl::__handle_exception<_Implementation>(
535 std::forward<_ExecutionPolicy>(__policy),
536 std::move(__first1),
537 std::move(__last1),
538 std::move(__first2),
539 std::move(__last2),
540 std::move(__pred));
541}
542
543template <class _ExecutionPolicy,
544 class _ForwardIterator,
545 class _Predicate,
546 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
547 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
548[[nodiscard]] _ForwardIterator
549find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
550 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
551 using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
552 return __pstl::__handle_exception<_Implementation>(
553 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
554}
555
556template <class _ExecutionPolicy,
557 class _ForwardIterator,
558 class _Predicate,
559 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
560 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
561[[nodiscard]] _ForwardIterator
562find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
563 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
564 using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
565 return __pstl::__handle_exception<_Implementation>(
566 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
567}
568
569template <class _ExecutionPolicy,
570 class _ForwardIterator,
571 class _Tp,
572 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
573 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
574[[nodiscard]] _ForwardIterator
575find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
576 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
577 using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;
578 return __pstl::__handle_exception<_Implementation>(
579 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
580}
581
582template <class _ExecutionPolicy,
583 class _ForwardIterator1,
584 class _ForwardIterator2,
585 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
586 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
587[[nodiscard]] _ForwardIterator1
588find_first_of(_ExecutionPolicy&& __policy,
589 _ForwardIterator1 __first1,
590 _ForwardIterator1 __last1,
591 _ForwardIterator2 __first2,
592 _ForwardIterator2 __last2) {
593 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
594 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
595 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
596 return __pstl::__handle_exception<_Implementation>(
597 std::forward<_ExecutionPolicy>(__policy),
598 std::move(__first1),
599 std::move(__last1),
600 std::move(__first2),
601 std::move(__last2),
602 std::equal_to<>{});
603}
604
605template <class _ExecutionPolicy,
606 class _ForwardIterator1,
607 class _ForwardIterator2,
608 class _BinaryPredicate,
609 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
610 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
611[[nodiscard]] _ForwardIterator1 find_first_of(
612 _ExecutionPolicy&& __policy,
613 _ForwardIterator1 __first1,
614 _ForwardIterator1 __last1,
615 _ForwardIterator2 __first2,
616 _ForwardIterator2 __last2,
617 _BinaryPredicate __pred) {
618 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
619 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
620 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
621 return __pstl::__handle_exception<_Implementation>(
622 std::forward<_ExecutionPolicy>(__policy),
623 std::move(__first1),
624 std::move(__last1),
625 std::move(__first2),
626 std::move(__last2),
627 std::move(__pred));
628}
629
630template <class _ExecutionPolicy,
631 class _ForwardIterator,
632 class _Function,
633 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
634 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
635void for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
636 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators");
637 using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>;
638 __pstl::__handle_exception<_Implementation>(
639 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func));
640}
641
642template <class _ExecutionPolicy,
643 class _ForwardIterator,
644 class _Size,
645 class _Function,
646 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
647 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
648_ForwardIterator for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
649 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator");
650 using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>;
651 return __pstl::__handle_exception<_Implementation>(
652 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func));
653}
654
655template <class _ExecutionPolicy,
656 class _ForwardIterator,
657 class _Generator,
658 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
659 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
660void generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
661 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators");
662 using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>;
663 __pstl::__handle_exception<_Implementation>(
664 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen));
665}
666
667template <class _ExecutionPolicy,
668 class _ForwardIterator,
669 class _Size,
670 class _Generator,
671 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
672 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
673_ForwardIterator generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) {
674 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator");
675 using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>;
676 return __pstl::__handle_exception<_Implementation>(
677 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen));
678}
679
680template <class _ExecutionPolicy,
681 class _BidirectionalIterator,
682 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
683 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
684void reverse(_ExecutionPolicy&& __policy, _BidirectionalIterator __first, _BidirectionalIterator __last) {
685 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse requires a BidirectionalIterator");
686 using _Implementation = __pstl::__dispatch<__pstl::__reverse, __pstl::__current_configuration, _RawPolicy>;
687 __pstl::__handle_exception<_Implementation>(
688 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last));
689}
690
691template <class _ExecutionPolicy,
692 class _BidirectionalIterator,
693 class _ForwardIterator,
694 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
695 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
696[[nodiscard]] _ForwardIterator
697reverse_copy(_ExecutionPolicy&& __policy,
698 _BidirectionalIterator __first,
699 _BidirectionalIterator __last,
700 _ForwardIterator __result) {
701 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse_copy requires a BidirectionalIterator");
702 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reverse_copy requires a ForwardIterator");
703 using _Implementation = __pstl::__dispatch<__pstl::__reverse_copy, __pstl::__current_configuration, _RawPolicy>;
704 return __pstl::__handle_exception<_Implementation>(
705 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
706}
707
708template <class _ExecutionPolicy,
709 class _ForwardIterator,
710 class _Predicate,
711 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
712 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
713[[nodiscard]] bool
714is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
715 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators");
716 using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>;
717 return __pstl::__handle_exception<_Implementation>(
718 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
719}
720
721template <class _ExecutionPolicy,
722 class _ForwardIterator1,
723 class _ForwardIterator2,
724 class _ForwardOutIterator,
725 class _Comp,
726 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
727 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
728_ForwardOutIterator
729merge(_ExecutionPolicy&& __policy,
730 _ForwardIterator1 __first1,
731 _ForwardIterator1 __last1,
732 _ForwardIterator2 __first2,
733 _ForwardIterator2 __last2,
734 _ForwardOutIterator __result,
735 _Comp __comp) {
736 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
737 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
738 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
739 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
740 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
741 return __pstl::__handle_exception<_Implementation>(
742 std::forward<_ExecutionPolicy>(__policy),
743 std::move(__first1),
744 std::move(__last1),
745 std::move(__first2),
746 std::move(__last2),
747 std::move(__result),
748 std::move(__comp));
749}
750
751template <class _ExecutionPolicy,
752 class _ForwardIterator1,
753 class _ForwardIterator2,
754 class _ForwardOutIterator,
755 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
756 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
757_ForwardOutIterator
758merge(_ExecutionPolicy&& __policy,
759 _ForwardIterator1 __first1,
760 _ForwardIterator1 __last1,
761 _ForwardIterator2 __first2,
762 _ForwardIterator2 __last2,
763 _ForwardOutIterator __result) {
764 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
765 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
766 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
767 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
768 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
769 return __pstl::__handle_exception<_Implementation>(
770 std::forward<_ExecutionPolicy>(__policy),
771 std::move(__first1),
772 std::move(__last1),
773 std::move(__first2),
774 std::move(__last2),
775 std::move(__result),
776 less{});
777}
778
779template <class _ExecutionPolicy,
780 class _ForwardIterator,
781 class _ForwardOutIterator,
782 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
783 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
784_ForwardOutIterator
785move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
786 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators");
787 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator");
788 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
789 _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator");
790 using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>;
791 return __pstl::__handle_exception<_Implementation>(
792 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
793}
794
795template <class _ExecutionPolicy,
796 class _ForwardIterator,
797 class _Pred,
798 class _Tp,
799 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
800 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
801void replace_if(_ExecutionPolicy&& __policy,
802 _ForwardIterator __first,
803 _ForwardIterator __last,
804 _Pred __pred,
805 const _Tp& __new_value) {
806 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators");
807 using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>;
808 __pstl::__handle_exception<_Implementation>(
809 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value);
810}
811
812template <class _ExecutionPolicy,
813 class _ForwardIterator,
814 class _Tp,
815 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
816 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
817void replace(_ExecutionPolicy&& __policy,
818 _ForwardIterator __first,
819 _ForwardIterator __last,
820 const _Tp& __old_value,
821 const _Tp& __new_value) {
822 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators");
823 using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>;
824 __pstl::__handle_exception<_Implementation>(
825 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value);
826}
827
828template <class _ExecutionPolicy,
829 class _ForwardIterator,
830 class _ForwardOutIterator,
831 class _Pred,
832 class _Tp,
833 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
834 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
835void replace_copy_if(
836 _ExecutionPolicy&& __policy,
837 _ForwardIterator __first,
838 _ForwardIterator __last,
839 _ForwardOutIterator __result,
840 _Pred __pred,
841 const _Tp& __new_value) {
842 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators");
843 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators");
844 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
845 _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator");
846 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
847 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>;
848 __pstl::__handle_exception<_Implementation>(
849 std::forward<_ExecutionPolicy>(__policy),
850 std::move(__first),
851 std::move(__last),
852 std::move(__result),
853 std::move(__pred),
854 __new_value);
855}
856
857template <class _ExecutionPolicy,
858 class _ForwardIterator,
859 class _ForwardOutIterator,
860 class _Tp,
861 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
862 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
863void replace_copy(_ExecutionPolicy&& __policy,
864 _ForwardIterator __first,
865 _ForwardIterator __last,
866 _ForwardOutIterator __result,
867 const _Tp& __old_value,
868 const _Tp& __new_value) {
869 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators");
870 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators");
871 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
872 _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator");
873 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
874 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>;
875 __pstl::__handle_exception<_Implementation>(
876 std::forward<_ExecutionPolicy>(__policy),
877 std::move(__first),
878 std::move(__last),
879 std::move(__result),
880 __old_value,
881 __new_value);
882}
883
884template <class _ExecutionPolicy,
885 class _ForwardIterator,
886 class _ForwardOutIterator,
887 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
888 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
889_ForwardOutIterator
890rotate_copy(_ExecutionPolicy&& __policy,
891 _ForwardIterator __first,
892 _ForwardIterator __middle,
893 _ForwardIterator __last,
894 _ForwardOutIterator __result) {
895 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators");
896 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators");
897 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
898 _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator");
899 using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>;
900 return __pstl::__handle_exception<_Implementation>(
901 std::forward<_ExecutionPolicy>(__policy),
902 std::move(__first),
903 std::move(__middle),
904 std::move(__last),
905 std::move(__result));
906}
907
908template <class _ExecutionPolicy,
909 class _ForwardIterator1,
910 class _ForwardIterator2,
911 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
912 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
913[[nodiscard]] _ForwardIterator1
914search(_ExecutionPolicy&& __policy,
915 _ForwardIterator1 __first1,
916 _ForwardIterator1 __last1,
917 _ForwardIterator2 __first2,
918 _ForwardIterator2 __last2) {
919 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "search requires ForwardIterators");
920 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "search requires ForwardIterators");
921 using _Implementation = __pstl::__dispatch<__pstl::__search, __pstl::__current_configuration, _RawPolicy>;
922 return __pstl::__handle_exception<_Implementation>(
923 std::forward<_ExecutionPolicy>(__policy),
924 std::move(__first1),
925 std::move(__last1),
926 std::move(__first2),
927 std::move(__last2),
928 equal_to<>{});
929}
930
931template <class _ExecutionPolicy,
932 class _ForwardIterator1,
933 class _ForwardIterator2,
934 class _BinaryPredicate,
935 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
936 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
937[[nodiscard]] _ForwardIterator1
938search(_ExecutionPolicy&& __policy,
939 _ForwardIterator1 __first1,
940 _ForwardIterator1 __last1,
941 _ForwardIterator2 __first2,
942 _ForwardIterator2 __last2,
943 _BinaryPredicate __pred) {
944 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "search requires ForwardIterators");
945 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "search requires ForwardIterators");
946 using _Implementation = __pstl::__dispatch<__pstl::__search, __pstl::__current_configuration, _RawPolicy>;
947 return __pstl::__handle_exception<_Implementation>(
948 std::forward<_ExecutionPolicy>(__policy),
949 std::move(__first1),
950 std::move(__last1),
951 std::move(__first2),
952 std::move(__last2),
953 std::move(__pred));
954}
955
956template <class _ExecutionPolicy,
957 class _ForwardIterator,
958 class _Size,
959 class _Tp,
960 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
961 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
962[[nodiscard]] _ForwardIterator search_n(
963 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
964 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
965 using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
966 return __pstl::__handle_exception<_Implementation>(
967 std::forward<_ExecutionPolicy>(__policy),
968 std::move(__first),
969 std::move(__last),
970 std::move(__count),
971 __value,
972 equal_to<>{});
973}
974
975template <class _ExecutionPolicy,
976 class _ForwardIterator,
977 class _Size,
978 class _Tp,
979 class _BinaryPredicate,
980 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
981 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
982[[nodiscard]] _ForwardIterator
983search_n(_ExecutionPolicy&& __policy,
984 _ForwardIterator __first,
985 _ForwardIterator __last,
986 _Size __count,
987 const _Tp& __value,
988 _BinaryPredicate __pred) {
989 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
990 using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
991 return __pstl::__handle_exception<_Implementation>(
992 std::forward<_ExecutionPolicy>(__policy),
993 std::move(__first),
994 std::move(__last),
995 std::move(__count),
996 __value,
997 std::move(__pred));
998}
999
1000template <class _ExecutionPolicy,
1001 class _RandomAccessIterator,
1002 class _Comp,
1003 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1004 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1005void sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1006 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
1007 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
1008 __pstl::__handle_exception<_Implementation>(
1009 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1010}
1011
1012template <class _ExecutionPolicy,
1013 class _RandomAccessIterator,
1014 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1015 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1016void sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1017 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
1018 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
1019 __pstl::__handle_exception<_Implementation>(
1020 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1021}
1022
1023template <class _ExecutionPolicy,
1024 class _RandomAccessIterator,
1025 class _Comp,
1026 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1027 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1028void stable_sort(
1029 _ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1030 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
1031 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
1032 __pstl::__handle_exception<_Implementation>(
1033 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1034}
1035
1036template <class _ExecutionPolicy,
1037 class _RandomAccessIterator,
1038 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1039 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1040void stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1041 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
1042 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
1043 __pstl::__handle_exception<_Implementation>(
1044 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1045}
1046
1047template <class _ExecutionPolicy,
1048 class _ForwardIterator1,
1049 class _ForwardIterator2,
1050 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1051 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1052_ForwardIterator2 swap_ranges(
1053 _ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
1054 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "swap_ranges requires ForwardIterators");
1055 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "swap_ranges requires ForwardIterators");
1056 using _Implementation = __pstl::__dispatch<__pstl::__swap_ranges, __pstl::__current_configuration, _RawPolicy>;
1057 return __pstl::__handle_exception<_Implementation>(
1058 std::forward<_ExecutionPolicy>(__policy), std::move(__first1), std::move(__last1), std::move(__first2));
1059}
1060
1061template <class _ExecutionPolicy,
1062 class _ForwardIterator,
1063 class _ForwardOutIterator,
1064 class _UnaryOperation,
1065 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1066 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1067_ForwardOutIterator
1068transform(_ExecutionPolicy&& __policy,
1069 _ForwardIterator __first,
1070 _ForwardIterator __last,
1071 _ForwardOutIterator __result,
1072 _UnaryOperation __op) {
1073 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators");
1074 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
1075 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1076 _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator");
1077 using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>;
1078 return __pstl::__handle_exception<_Implementation>(
1079 std::forward<_ExecutionPolicy>(__policy),
1080 std::move(__first),
1081 std::move(__last),
1082 std::move(__result),
1083 std::move(__op));
1084}
1085
1086template <class _ExecutionPolicy,
1087 class _ForwardIterator1,
1088 class _ForwardIterator2,
1089 class _ForwardOutIterator,
1090 class _BinaryOperation,
1091 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1092 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1093_ForwardOutIterator
1094transform(_ExecutionPolicy&& __policy,
1095 _ForwardIterator1 __first1,
1096 _ForwardIterator1 __last1,
1097 _ForwardIterator2 __first2,
1098 _ForwardOutIterator __result,
1099 _BinaryOperation __op) {
1100 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators");
1101 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators");
1102 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
1103 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1104 _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator");
1105 using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>;
1106 return __pstl::__handle_exception<_Implementation>(
1107 std::forward<_ExecutionPolicy>(__policy),
1108 std::move(__first1),
1109 std::move(__last1),
1110 std::move(__first2),
1111 std::move(__result),
1112 std::move(__op));
1113}
1114
1115template <class _ExecutionPolicy,
1116 class _RandomAccessIterator,
1117 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1118 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1119[[nodiscard]] bool is_heap(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1120 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap requires RandomAccessIterators");
1121 using _Implementation = __pstl::__dispatch<__pstl::__is_heap, __pstl::__current_configuration, _RawPolicy>;
1122 return __pstl::__handle_exception<_Implementation>(
1123 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1124}
1125
1126template <class _ExecutionPolicy,
1127 class _RandomAccessIterator,
1128 class _Comp,
1129 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1130 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1131[[nodiscard]] bool
1132is_heap(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1133 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap requires RandomAccessIterators");
1134 using _Implementation = __pstl::__dispatch<__pstl::__is_heap, __pstl::__current_configuration, _RawPolicy>;
1135 return __pstl::__handle_exception<_Implementation>(
1136 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1137}
1138
1139template <class _ExecutionPolicy,
1140 class _RandomAccessIterator,
1141 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1142 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1143[[nodiscard]] _RandomAccessIterator
1144is_heap_until(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1145 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap_until requires RandomAccessIterators");
1146 using _Implementation = __pstl::__dispatch<__pstl::__is_heap_until, __pstl::__current_configuration, _RawPolicy>;
1147 return __pstl::__handle_exception<_Implementation>(
1148 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1149}
1150
1151template <class _ExecutionPolicy,
1152 class _RandomAccessIterator,
1153 class _Comp,
1154 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1155 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1156[[nodiscard]] _RandomAccessIterator
1157is_heap_until(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1158 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap_until requires RandomAccessIterators");
1159 using _Implementation = __pstl::__dispatch<__pstl::__is_heap_until, __pstl::__current_configuration, _RawPolicy>;
1160 return __pstl::__handle_exception<_Implementation>(
1161 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1162}
1163
1164template <class _ExecutionPolicy,
1165 class _ForwardIterator,
1166 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1167 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1168[[nodiscard]] bool is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
1169 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
1170 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
1171 return __pstl::__handle_exception<_Implementation>(
1172 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1173}
1174
1175template <class _ExecutionPolicy,
1176 class _ForwardIterator,
1177 class _Comp,
1178 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1179 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1180[[nodiscard]] bool
1181is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
1182 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
1183 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
1184 return __pstl::__handle_exception<_Implementation>(
1185 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1186}
1187
1188template <class _ExecutionPolicy,
1189 class _ForwardIterator,
1190 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1191 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1192[[nodiscard]] _ForwardIterator
1193is_sorted_until(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
1194 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted_until requires ForwardIterators");
1195 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted_until, __pstl::__current_configuration, _RawPolicy>;
1196 return __pstl::__handle_exception<_Implementation>(
1197 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1198}
1199
1200template <class _ExecutionPolicy,
1201 class _ForwardIterator,
1202 class _Comp,
1203 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1204 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1205[[nodiscard]] _ForwardIterator
1206is_sorted_until(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
1207 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted_until requires ForwardIterators");
1208 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted_until, __pstl::__current_configuration, _RawPolicy>;
1209 return __pstl::__handle_exception<_Implementation>(
1210 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1211}
1212
1213_LIBCPP_END_NAMESPACE_STD
1214
1215#endif // _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
1216
1217_LIBCPP_POP_MACROS
1218
1219#endif // _LIBCPP___ALGORITHM_PSTL_H
1220