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# 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]] _LIBCPP_HIDE_FROM_ABI 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]] _LIBCPP_HIDE_FROM_ABI 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]] _LIBCPP_HIDE_FROM_ABI 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_LIBCPP_HIDE_FROM_ABI _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_LIBCPP_HIDE_FROM_ABI _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]] _LIBCPP_HIDE_FROM_ABI __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]] _LIBCPP_HIDE_FROM_ABI __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 _ForwardIterator1,
144 class _ForwardIterator2,
145 class _BinaryPredicate,
146 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
147 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
148[[nodiscard]] _LIBCPP_HIDE_FROM_ABI pair<_ForwardIterator1, _ForwardIterator2>
149mismatch(_ExecutionPolicy&& __policy,
150 _ForwardIterator1 __first1,
151 _ForwardIterator1 __last1,
152 _ForwardIterator2 __first2,
153 _ForwardIterator2 __last2,
154 _BinaryPredicate __pred) {
155 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
156 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
157 using _Implementation = __pstl::__dispatch<__pstl::__mismatch, __pstl::__current_configuration, _RawPolicy>;
158 return __pstl::__handle_exception<_Implementation>(
159 std::forward<_ExecutionPolicy>(__policy),
160 std::move(__first1),
161 std::move(__last1),
162 std::move(__first2),
163 std::move(__last2),
164 std::move(__pred));
165}
166
167template <class _ExecutionPolicy,
168 class _ForwardIterator1,
169 class _ForwardIterator2,
170 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
171 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
172[[nodiscard]] _LIBCPP_HIDE_FROM_ABI pair<_ForwardIterator1, _ForwardIterator2>
173mismatch(_ExecutionPolicy&& __policy,
174 _ForwardIterator1 __first1,
175 _ForwardIterator1 __last1,
176 _ForwardIterator2 __first2,
177 _ForwardIterator2 __last2) {
178 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
179 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
180 using _Implementation = __pstl::__dispatch<__pstl::__mismatch, __pstl::__current_configuration, _RawPolicy>;
181 return __pstl::__handle_exception<_Implementation>(
182 std::forward<_ExecutionPolicy>(__policy),
183 std::move(__first1),
184 std::move(__last1),
185 std::move(__first2),
186 std::move(__last2),
187 equal_to{});
188}
189
190template <class _ExecutionPolicy,
191 class _ForwardIterator1,
192 class _ForwardIterator2,
193 class _BinaryPredicate,
194 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
195 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
196[[nodiscard]] _LIBCPP_HIDE_FROM_ABI pair<_ForwardIterator1, _ForwardIterator2>
197mismatch(_ExecutionPolicy&& __policy,
198 _ForwardIterator1 __first1,
199 _ForwardIterator1 __last1,
200 _ForwardIterator2 __first2,
201 _BinaryPredicate __pred) {
202 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
203 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
204 using _Implementation = __pstl::__dispatch<__pstl::__mismatch_3leg, __pstl::__current_configuration, _RawPolicy>;
205 return __pstl::__handle_exception<_Implementation>(
206 std::forward<_ExecutionPolicy>(__policy),
207 std::move(__first1),
208 std::move(__last1),
209 std::move(__first2),
210 std::move(__pred));
211}
212
213template <class _ExecutionPolicy,
214 class _ForwardIterator1,
215 class _ForwardIterator2,
216 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
217 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
218[[nodiscard]] _LIBCPP_HIDE_FROM_ABI pair<_ForwardIterator1, _ForwardIterator2> mismatch(
219 _ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
220 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
221 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
222 using _Implementation = __pstl::__dispatch<__pstl::__mismatch_3leg, __pstl::__current_configuration, _RawPolicy>;
223 return __pstl::__handle_exception<_Implementation>(
224 std::forward<_ExecutionPolicy>(__policy),
225 std::move(__first1),
226 std::move(__last1),
227 std::move(__first2),
228 equal_to{});
229}
230
231template <class _ExecutionPolicy,
232 class _ForwardIterator,
233 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
234 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
235[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
236adjacent_find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
237 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "adjacent_find requires ForwardIterators");
238 using _Implementation = __pstl::__dispatch<__pstl::__adjacent_find, __pstl::__current_configuration, _RawPolicy>;
239 return __pstl::__handle_exception<_Implementation>(
240 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), equal_to{});
241}
242
243template <class _ExecutionPolicy,
244 class _ForwardIterator,
245 class _BinaryPredicate,
246 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
247 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
248[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator adjacent_find(
249 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __predicate) {
250 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "adjacent_find requires ForwardIterators");
251 using _Implementation = __pstl::__dispatch<__pstl::__adjacent_find, __pstl::__current_configuration, _RawPolicy>;
252 return __pstl::__handle_exception<_Implementation>(
253 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__predicate));
254}
255
256template <class _ExecutionPolicy,
257 class _ForwardIterator1,
258 class _ForwardIterator2,
259 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
260 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
261[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool lexicographical_compare(
262 _ExecutionPolicy&& __policy,
263 _ForwardIterator1 __first1,
264 _ForwardIterator1 __last1,
265 _ForwardIterator2 __first2,
266 _ForwardIterator2 __last2) {
267 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "lexicographical_compare requires ForwardIterators");
268 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "lexicographical_compare requires ForwardIterators");
269 using _Implementation =
270 __pstl::__dispatch<__pstl::__lexicographical_compare, __pstl::__current_configuration, _RawPolicy>;
271 return __pstl::__handle_exception<_Implementation>(
272 std::forward<_ExecutionPolicy>(__policy),
273 std::move(__first1),
274 std::move(__last1),
275 std::move(__first2),
276 std::move(__last2),
277 less<>{});
278}
279
280template <class _ExecutionPolicy,
281 class _ForwardIterator1,
282 class _ForwardIterator2,
283 class _Comp,
284 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
285 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
286[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool lexicographical_compare(
287 _ExecutionPolicy&& __policy,
288 _ForwardIterator1 __first1,
289 _ForwardIterator1 __last1,
290 _ForwardIterator2 __first2,
291 _ForwardIterator2 __last2,
292 _Comp __comp) {
293 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "lexicographical_compare requires ForwardIterators");
294 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "lexicographical_compare requires ForwardIterators");
295 using _Implementation =
296 __pstl::__dispatch<__pstl::__lexicographical_compare, __pstl::__current_configuration, _RawPolicy>;
297 return __pstl::__handle_exception<_Implementation>(
298 std::forward<_ExecutionPolicy>(__policy),
299 std::move(__first1),
300 std::move(__last1),
301 std::move(__first2),
302 std::move(__last2),
303 std::move(__comp));
304}
305
306template <class _ExecutionPolicy,
307 class _ForwardIterator1,
308 class _ForwardIterator2,
309 class _Pred,
310 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
311 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
312[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
313equal(_ExecutionPolicy&& __policy,
314 _ForwardIterator1 __first1,
315 _ForwardIterator1 __last1,
316 _ForwardIterator2 __first2,
317 _Pred __pred) {
318 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
319 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
320 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
321 return __pstl::__handle_exception<_Implementation>(
322 std::forward<_ExecutionPolicy>(__policy),
323 std::move(__first1),
324 std::move(__last1),
325 std::move(__first2),
326 std::move(__pred));
327}
328
329template <class _ExecutionPolicy,
330 class _ForwardIterator1,
331 class _ForwardIterator2,
332 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
333 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
334[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
335equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
336 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
337 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
338 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
339 return __pstl::__handle_exception<_Implementation>(
340 std::forward<_ExecutionPolicy>(__policy),
341 std::move(__first1),
342 std::move(__last1),
343 std::move(__first2),
344 equal_to{});
345}
346
347template <class _ExecutionPolicy,
348 class _ForwardIterator1,
349 class _ForwardIterator2,
350 class _Pred,
351 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
352 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
353[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
354equal(_ExecutionPolicy&& __policy,
355 _ForwardIterator1 __first1,
356 _ForwardIterator1 __last1,
357 _ForwardIterator2 __first2,
358 _ForwardIterator2 __last2,
359 _Pred __pred) {
360 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
361 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
362 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
363 return __pstl::__handle_exception<_Implementation>(
364 std::forward<_ExecutionPolicy>(__policy),
365 std::move(__first1),
366 std::move(__last1),
367 std::move(__first2),
368 std::move(__last2),
369 std::move(__pred));
370}
371
372template <class _ExecutionPolicy,
373 class _ForwardIterator1,
374 class _ForwardIterator2,
375 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
376 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
377[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
378equal(_ExecutionPolicy&& __policy,
379 _ForwardIterator1 __first1,
380 _ForwardIterator1 __last1,
381 _ForwardIterator2 __first2,
382 _ForwardIterator2 __last2) {
383 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
384 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
385 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
386 return __pstl::__handle_exception<_Implementation>(
387 std::forward<_ExecutionPolicy>(__policy),
388 std::move(__first1),
389 std::move(__last1),
390 std::move(__first2),
391 std::move(__last2),
392 equal_to{});
393}
394
395template <class _ExecutionPolicy,
396 class _ForwardIterator,
397 class _Tp,
398 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
399 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
400_LIBCPP_HIDE_FROM_ABI void
401fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
402 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators");
403 using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>;
404 __pstl::__handle_exception<_Implementation>(
405 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
406}
407
408template <class _ExecutionPolicy,
409 class _ForwardIterator,
410 class _Size,
411 class _Tp,
412 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
413 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
414_LIBCPP_HIDE_FROM_ABI void
415fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) {
416 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator");
417 using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>;
418 __pstl::__handle_exception<_Implementation>(
419 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value);
420}
421
422template <class _ExecutionPolicy,
423 class _ForwardIterator,
424 class _Predicate,
425 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
426 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
427[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
428find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
429 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
430 using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
431 return __pstl::__handle_exception<_Implementation>(
432 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
433}
434
435template <class _ExecutionPolicy,
436 class _ForwardIterator,
437 class _Predicate,
438 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
439 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
440[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
441find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
442 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
443 using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
444 return __pstl::__handle_exception<_Implementation>(
445 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
446}
447
448template <class _ExecutionPolicy,
449 class _ForwardIterator,
450 class _Tp,
451 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
452 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
453[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
454find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
455 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
456 using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;
457 return __pstl::__handle_exception<_Implementation>(
458 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
459}
460
461template <class _ExecutionPolicy,
462 class _ForwardIterator1,
463 class _ForwardIterator2,
464 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
465 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
466[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator1 find_first_of(
467 _ExecutionPolicy&& __policy,
468 _ForwardIterator1 __first1,
469 _ForwardIterator1 __last1,
470 _ForwardIterator2 __first2,
471 _ForwardIterator2 __last2) {
472 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
473 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
474 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
475 return __pstl::__handle_exception<_Implementation>(
476 std::forward<_ExecutionPolicy>(__policy),
477 std::move(__first1),
478 std::move(__last1),
479 std::move(__first2),
480 std::move(__last2),
481 std::equal_to<>{});
482}
483
484template <class _ExecutionPolicy,
485 class _ForwardIterator1,
486 class _ForwardIterator2,
487 class _BinaryPredicate,
488 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
489 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
490[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator1 find_first_of(
491 _ExecutionPolicy&& __policy,
492 _ForwardIterator1 __first1,
493 _ForwardIterator1 __last1,
494 _ForwardIterator2 __first2,
495 _ForwardIterator2 __last2,
496 _BinaryPredicate __pred) {
497 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
498 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
499 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
500 return __pstl::__handle_exception<_Implementation>(
501 std::forward<_ExecutionPolicy>(__policy),
502 std::move(__first1),
503 std::move(__last1),
504 std::move(__first2),
505 std::move(__last2),
506 std::move(__pred));
507}
508
509template <class _ExecutionPolicy,
510 class _ForwardIterator,
511 class _Function,
512 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
513 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
514_LIBCPP_HIDE_FROM_ABI void
515for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
516 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators");
517 using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>;
518 __pstl::__handle_exception<_Implementation>(
519 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func));
520}
521
522template <class _ExecutionPolicy,
523 class _ForwardIterator,
524 class _Size,
525 class _Function,
526 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
527 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
528_LIBCPP_HIDE_FROM_ABI void
529for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
530 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator");
531 using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>;
532 __pstl::__handle_exception<_Implementation>(
533 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func));
534}
535
536template <class _ExecutionPolicy,
537 class _ForwardIterator,
538 class _Generator,
539 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
540 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
541_LIBCPP_HIDE_FROM_ABI void
542generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
543 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators");
544 using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>;
545 __pstl::__handle_exception<_Implementation>(
546 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen));
547}
548
549template <class _ExecutionPolicy,
550 class _ForwardIterator,
551 class _Size,
552 class _Generator,
553 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
554 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
555_LIBCPP_HIDE_FROM_ABI void
556generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) {
557 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator");
558 using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>;
559 __pstl::__handle_exception<_Implementation>(
560 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen));
561}
562
563template <class _ExecutionPolicy,
564 class _BidirectionalIterator,
565 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
566 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
567_LIBCPP_HIDE_FROM_ABI void
568reverse(_ExecutionPolicy&& __policy, _BidirectionalIterator __first, _BidirectionalIterator __last) {
569 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse requires a BidirectionalIterator");
570 using _Implementation = __pstl::__dispatch<__pstl::__reverse, __pstl::__current_configuration, _RawPolicy>;
571 __pstl::__handle_exception<_Implementation>(
572 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last));
573}
574
575template <class _ExecutionPolicy,
576 class _BidirectionalIterator,
577 class _ForwardIterator,
578 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
579 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
580[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator reverse_copy(
581 _ExecutionPolicy&& __policy,
582 _BidirectionalIterator __first,
583 _BidirectionalIterator __last,
584 _ForwardIterator __result) {
585 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse_copy requires a BidirectionalIterator");
586 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reverse_copy requires a ForwardIterator");
587 using _Implementation = __pstl::__dispatch<__pstl::__reverse_copy, __pstl::__current_configuration, _RawPolicy>;
588 return __pstl::__handle_exception<_Implementation>(
589 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
590}
591
592template <class _ExecutionPolicy,
593 class _ForwardIterator,
594 class _Predicate,
595 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
596 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
597[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
598is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
599 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators");
600 using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>;
601 return __pstl::__handle_exception<_Implementation>(
602 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
603}
604
605template <class _ExecutionPolicy,
606 class _ForwardIterator1,
607 class _ForwardIterator2,
608 class _ForwardOutIterator,
609 class _Comp,
610 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
611 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
612_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
613merge(_ExecutionPolicy&& __policy,
614 _ForwardIterator1 __first1,
615 _ForwardIterator1 __last1,
616 _ForwardIterator2 __first2,
617 _ForwardIterator2 __last2,
618 _ForwardOutIterator __result,
619 _Comp __comp) {
620 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
621 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
622 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
623 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
624 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
625 return __pstl::__handle_exception<_Implementation>(
626 std::forward<_ExecutionPolicy>(__policy),
627 std::move(__first1),
628 std::move(__last1),
629 std::move(__first2),
630 std::move(__last2),
631 std::move(__result),
632 std::move(__comp));
633}
634
635template <class _ExecutionPolicy,
636 class _ForwardIterator1,
637 class _ForwardIterator2,
638 class _ForwardOutIterator,
639 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
640 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
641_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
642merge(_ExecutionPolicy&& __policy,
643 _ForwardIterator1 __first1,
644 _ForwardIterator1 __last1,
645 _ForwardIterator2 __first2,
646 _ForwardIterator2 __last2,
647 _ForwardOutIterator __result) {
648 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
649 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
650 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
651 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
652 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
653 return __pstl::__handle_exception<_Implementation>(
654 std::forward<_ExecutionPolicy>(__policy),
655 std::move(__first1),
656 std::move(__last1),
657 std::move(__first2),
658 std::move(__last2),
659 std::move(__result),
660 less{});
661}
662
663template <class _ExecutionPolicy,
664 class _ForwardIterator,
665 class _ForwardOutIterator,
666 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
667 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
668_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
669move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
670 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators");
671 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator");
672 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
673 _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator");
674 using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>;
675 return __pstl::__handle_exception<_Implementation>(
676 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
677}
678
679template <class _ExecutionPolicy,
680 class _ForwardIterator,
681 class _Pred,
682 class _Tp,
683 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
684 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
685_LIBCPP_HIDE_FROM_ABI void
686replace_if(_ExecutionPolicy&& __policy,
687 _ForwardIterator __first,
688 _ForwardIterator __last,
689 _Pred __pred,
690 const _Tp& __new_value) {
691 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators");
692 using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>;
693 __pstl::__handle_exception<_Implementation>(
694 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value);
695}
696
697template <class _ExecutionPolicy,
698 class _ForwardIterator,
699 class _Tp,
700 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
701 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
702_LIBCPP_HIDE_FROM_ABI void
703replace(_ExecutionPolicy&& __policy,
704 _ForwardIterator __first,
705 _ForwardIterator __last,
706 const _Tp& __old_value,
707 const _Tp& __new_value) {
708 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators");
709 using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>;
710 __pstl::__handle_exception<_Implementation>(
711 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value);
712}
713
714template <class _ExecutionPolicy,
715 class _ForwardIterator,
716 class _ForwardOutIterator,
717 class _Pred,
718 class _Tp,
719 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
720 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
721_LIBCPP_HIDE_FROM_ABI void replace_copy_if(
722 _ExecutionPolicy&& __policy,
723 _ForwardIterator __first,
724 _ForwardIterator __last,
725 _ForwardOutIterator __result,
726 _Pred __pred,
727 const _Tp& __new_value) {
728 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators");
729 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators");
730 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
731 _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator");
732 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
733 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>;
734 __pstl::__handle_exception<_Implementation>(
735 std::forward<_ExecutionPolicy>(__policy),
736 std::move(__first),
737 std::move(__last),
738 std::move(__result),
739 std::move(__pred),
740 __new_value);
741}
742
743template <class _ExecutionPolicy,
744 class _ForwardIterator,
745 class _ForwardOutIterator,
746 class _Tp,
747 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
748 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
749_LIBCPP_HIDE_FROM_ABI void replace_copy(
750 _ExecutionPolicy&& __policy,
751 _ForwardIterator __first,
752 _ForwardIterator __last,
753 _ForwardOutIterator __result,
754 const _Tp& __old_value,
755 const _Tp& __new_value) {
756 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators");
757 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators");
758 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
759 _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator");
760 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
761 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>;
762 __pstl::__handle_exception<_Implementation>(
763 std::forward<_ExecutionPolicy>(__policy),
764 std::move(__first),
765 std::move(__last),
766 std::move(__result),
767 __old_value,
768 __new_value);
769}
770
771template <class _ExecutionPolicy,
772 class _ForwardIterator,
773 class _ForwardOutIterator,
774 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
775 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
776_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator rotate_copy(
777 _ExecutionPolicy&& __policy,
778 _ForwardIterator __first,
779 _ForwardIterator __middle,
780 _ForwardIterator __last,
781 _ForwardOutIterator __result) {
782 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators");
783 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators");
784 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
785 _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator");
786 using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>;
787 return __pstl::__handle_exception<_Implementation>(
788 std::forward<_ExecutionPolicy>(__policy),
789 std::move(__first),
790 std::move(__middle),
791 std::move(__last),
792 std::move(__result));
793}
794
795template <class _ExecutionPolicy,
796 class _ForwardIterator1,
797 class _ForwardIterator2,
798 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
799 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
800[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator1
801search(_ExecutionPolicy&& __policy,
802 _ForwardIterator1 __first1,
803 _ForwardIterator1 __last1,
804 _ForwardIterator2 __first2,
805 _ForwardIterator2 __last2) {
806 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "search requires ForwardIterators");
807 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "search requires ForwardIterators");
808 using _Implementation = __pstl::__dispatch<__pstl::__search, __pstl::__current_configuration, _RawPolicy>;
809 return __pstl::__handle_exception<_Implementation>(
810 std::forward<_ExecutionPolicy>(__policy),
811 std::move(__first1),
812 std::move(__last1),
813 std::move(__first2),
814 std::move(__last2),
815 equal_to<>{});
816}
817
818template <class _ExecutionPolicy,
819 class _ForwardIterator1,
820 class _ForwardIterator2,
821 class _BinaryPredicate,
822 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
823 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
824[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator1
825search(_ExecutionPolicy&& __policy,
826 _ForwardIterator1 __first1,
827 _ForwardIterator1 __last1,
828 _ForwardIterator2 __first2,
829 _ForwardIterator2 __last2,
830 _BinaryPredicate __pred) {
831 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "search requires ForwardIterators");
832 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "search requires ForwardIterators");
833 using _Implementation = __pstl::__dispatch<__pstl::__search, __pstl::__current_configuration, _RawPolicy>;
834 return __pstl::__handle_exception<_Implementation>(
835 std::forward<_ExecutionPolicy>(__policy),
836 std::move(__first1),
837 std::move(__last1),
838 std::move(__first2),
839 std::move(__last2),
840 std::move(__pred));
841}
842
843template <class _ExecutionPolicy,
844 class _ForwardIterator,
845 class _Size,
846 class _Tp,
847 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
848 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
849[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator search_n(
850 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
851 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
852 using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
853 return __pstl::__handle_exception<_Implementation>(
854 std::forward<_ExecutionPolicy>(__policy),
855 std::move(__first),
856 std::move(__last),
857 std::move(__count),
858 __value,
859 equal_to<>{});
860}
861
862template <class _ExecutionPolicy,
863 class _ForwardIterator,
864 class _Size,
865 class _Tp,
866 class _BinaryPredicate,
867 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
868 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
869[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator search_n(
870 _ExecutionPolicy&& __policy,
871 _ForwardIterator __first,
872 _ForwardIterator __last,
873 _Size __count,
874 const _Tp& __value,
875 _BinaryPredicate __pred) {
876 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
877 using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
878 return __pstl::__handle_exception<_Implementation>(
879 std::forward<_ExecutionPolicy>(__policy),
880 std::move(__first),
881 std::move(__last),
882 std::move(__count),
883 __value,
884 std::move(__pred));
885}
886
887template <class _ExecutionPolicy,
888 class _RandomAccessIterator,
889 class _Comp,
890 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
891 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
892_LIBCPP_HIDE_FROM_ABI void
893sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
894 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
895 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
896 __pstl::__handle_exception<_Implementation>(
897 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
898}
899
900template <class _ExecutionPolicy,
901 class _RandomAccessIterator,
902 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
903 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
904_LIBCPP_HIDE_FROM_ABI void
905sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
906 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
907 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
908 __pstl::__handle_exception<_Implementation>(
909 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
910}
911
912template <class _ExecutionPolicy,
913 class _RandomAccessIterator,
914 class _Comp,
915 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
916 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
917_LIBCPP_HIDE_FROM_ABI void
918stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
919 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
920 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
921 __pstl::__handle_exception<_Implementation>(
922 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
923}
924
925template <class _ExecutionPolicy,
926 class _RandomAccessIterator,
927 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
928 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
929_LIBCPP_HIDE_FROM_ABI void
930stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
931 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
932 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
933 __pstl::__handle_exception<_Implementation>(
934 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
935}
936
937template <class _ExecutionPolicy,
938 class _ForwardIterator,
939 class _ForwardOutIterator,
940 class _UnaryOperation,
941 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
942 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
943_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
944 _ExecutionPolicy&& __policy,
945 _ForwardIterator __first,
946 _ForwardIterator __last,
947 _ForwardOutIterator __result,
948 _UnaryOperation __op) {
949 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators");
950 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
951 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
952 _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator");
953 using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>;
954 return __pstl::__handle_exception<_Implementation>(
955 std::forward<_ExecutionPolicy>(__policy),
956 std::move(__first),
957 std::move(__last),
958 std::move(__result),
959 std::move(__op));
960}
961
962template <class _ExecutionPolicy,
963 class _ForwardIterator1,
964 class _ForwardIterator2,
965 class _ForwardOutIterator,
966 class _BinaryOperation,
967 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
968 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
969_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
970 _ExecutionPolicy&& __policy,
971 _ForwardIterator1 __first1,
972 _ForwardIterator1 __last1,
973 _ForwardIterator2 __first2,
974 _ForwardOutIterator __result,
975 _BinaryOperation __op) {
976 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators");
977 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators");
978 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
979 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
980 _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator");
981 using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>;
982 return __pstl::__handle_exception<_Implementation>(
983 std::forward<_ExecutionPolicy>(__policy),
984 std::move(__first1),
985 std::move(__last1),
986 std::move(__first2),
987 std::move(__result),
988 std::move(__op));
989}
990
991template <class _ExecutionPolicy,
992 class _ForwardIterator,
993 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
994 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
995[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
996is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
997 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
998 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
999 return __pstl::__handle_exception<_Implementation>(
1000 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1001}
1002
1003template <class _ExecutionPolicy,
1004 class _ForwardIterator,
1005 class _Comp,
1006 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1007 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1008[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
1009is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
1010 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
1011 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
1012 return __pstl::__handle_exception<_Implementation>(
1013 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1014}
1015
1016template <class _ExecutionPolicy,
1017 class _ForwardIterator,
1018 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1019 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1020[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
1021is_sorted_until(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
1022 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted_until requires ForwardIterators");
1023 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted_until, __pstl::__current_configuration, _RawPolicy>;
1024 return __pstl::__handle_exception<_Implementation>(
1025 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1026}
1027
1028template <class _ExecutionPolicy,
1029 class _ForwardIterator,
1030 class _Comp,
1031 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1032 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1033[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
1034is_sorted_until(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
1035 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted_until requires ForwardIterators");
1036 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted_until, __pstl::__current_configuration, _RawPolicy>;
1037 return __pstl::__handle_exception<_Implementation>(
1038 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1039}
1040
1041_LIBCPP_END_NAMESPACE_STD
1042
1043#endif // _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
1044
1045_LIBCPP_POP_MACROS
1046
1047#endif // _LIBCPP___ALGORITHM_PSTL_H
1048