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 _ForwardOutIterator,
117 class _Predicate,
118 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
119 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
120[[nodiscard]] _ForwardOutIterator
121copy_if(_ExecutionPolicy&& __policy,
122 _ForwardIterator __first,
123 _ForwardIterator __last,
124 _ForwardOutIterator __result,
125 _Predicate __pred) {
126 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "copy_if requires ForwardIterators");
127 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "copy_if requires ForwardIterators");
128 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first), "copy_if requires an OutputIterator");
129 using _Implementation = __pstl::__dispatch<__pstl::__copy_if, __pstl::__current_configuration, _RawPolicy>;
130 return __pstl::__handle_exception<_Implementation>(
131 std::forward<_ExecutionPolicy>(__policy),
132 std::move(__first),
133 std::move(__last),
134 std::move(__result),
135 std::move(__pred));
136}
137
138template <class _ExecutionPolicy,
139 class _ForwardIterator,
140 class _Predicate,
141 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
142 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
143[[nodiscard]] __iterator_difference_type<_ForwardIterator>
144count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
145 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
146 _ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");
147 using _Implementation = __pstl::__dispatch<__pstl::__count_if, __pstl::__current_configuration, _RawPolicy>;
148 return __pstl::__handle_exception<_Implementation>(
149 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
150}
151
152template <class _ExecutionPolicy,
153 class _ForwardIterator,
154 class _Tp,
155 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
156 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
157[[nodiscard]] __iterator_difference_type<_ForwardIterator>
158count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
159 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
160 _ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");
161 using _Implementation = __pstl::__dispatch<__pstl::__count, __pstl::__current_configuration, _RawPolicy>;
162 return __pstl::__handle_exception<_Implementation>(
163 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
164}
165
166template <class _ExecutionPolicy,
167 class _ForwardIterator,
168 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
169 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
170[[nodiscard]] _ForwardIterator
171max_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
172 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "max_element requires ForwardIterators");
173 using _Implementation = __pstl::__dispatch<__pstl::__max_element, __pstl::__current_configuration, _RawPolicy>;
174 return __pstl::__handle_exception<_Implementation>(
175 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less<>{});
176}
177
178template <class _ExecutionPolicy,
179 class _ForwardIterator,
180 class _Compare,
181 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
182 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
183[[nodiscard]] _ForwardIterator
184max_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
185 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "max_element requires ForwardIterators");
186 using _Implementation = __pstl::__dispatch<__pstl::__max_element, __pstl::__current_configuration, _RawPolicy>;
187 return __pstl::__handle_exception<_Implementation>(
188 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
189}
190
191template <class _ExecutionPolicy,
192 class _ForwardIterator,
193 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
194 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
195[[nodiscard]] _ForwardIterator
196min_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
197 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "min_element requires ForwardIterators");
198 using _Implementation = __pstl::__dispatch<__pstl::__min_element, __pstl::__current_configuration, _RawPolicy>;
199 return __pstl::__handle_exception<_Implementation>(
200 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less<>{});
201}
202
203template <class _ExecutionPolicy,
204 class _ForwardIterator,
205 class _Compare,
206 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
207 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
208[[nodiscard]] _ForwardIterator
209min_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
210 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "min_element requires ForwardIterators");
211 using _Implementation = __pstl::__dispatch<__pstl::__min_element, __pstl::__current_configuration, _RawPolicy>;
212 return __pstl::__handle_exception<_Implementation>(
213 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
214}
215
216template <class _ExecutionPolicy,
217 class _ForwardIterator,
218 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
219 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
220[[nodiscard]] pair<_ForwardIterator, _ForwardIterator>
221minmax_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
222 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "minmax_element requires ForwardIterators");
223 using _Implementation = __pstl::__dispatch<__pstl::__minmax_element, __pstl::__current_configuration, _RawPolicy>;
224 return __pstl::__handle_exception<_Implementation>(
225 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less<>{});
226}
227
228template <class _ExecutionPolicy,
229 class _ForwardIterator,
230 class _Compare,
231 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
232 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
233[[nodiscard]] pair<_ForwardIterator, _ForwardIterator>
234minmax_element(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
235 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "minmax_element requires ForwardIterators");
236 using _Implementation = __pstl::__dispatch<__pstl::__minmax_element, __pstl::__current_configuration, _RawPolicy>;
237 return __pstl::__handle_exception<_Implementation>(
238 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
239}
240
241template <class _ExecutionPolicy,
242 class _ForwardIterator1,
243 class _ForwardIterator2,
244 class _BinaryPredicate,
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 _BinaryPredicate __pred) {
254 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
255 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
256 using _Implementation = __pstl::__dispatch<__pstl::__mismatch, __pstl::__current_configuration, _RawPolicy>;
257 return __pstl::__handle_exception<_Implementation>(
258 std::forward<_ExecutionPolicy>(__policy),
259 std::move(__first1),
260 std::move(__last1),
261 std::move(__first2),
262 std::move(__last2),
263 std::move(__pred));
264}
265
266template <class _ExecutionPolicy,
267 class _ForwardIterator1,
268 class _ForwardIterator2,
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 _ForwardIterator2 __last2) {
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, __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(__last2),
286 equal_to{});
287}
288
289template <class _ExecutionPolicy,
290 class _ForwardIterator1,
291 class _ForwardIterator2,
292 class _BinaryPredicate,
293 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
294 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
295[[nodiscard]] pair<_ForwardIterator1, _ForwardIterator2>
296mismatch(_ExecutionPolicy&& __policy,
297 _ForwardIterator1 __first1,
298 _ForwardIterator1 __last1,
299 _ForwardIterator2 __first2,
300 _BinaryPredicate __pred) {
301 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
302 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
303 using _Implementation = __pstl::__dispatch<__pstl::__mismatch_3leg, __pstl::__current_configuration, _RawPolicy>;
304 return __pstl::__handle_exception<_Implementation>(
305 std::forward<_ExecutionPolicy>(__policy),
306 std::move(__first1),
307 std::move(__last1),
308 std::move(__first2),
309 std::move(__pred));
310}
311
312template <class _ExecutionPolicy,
313 class _ForwardIterator1,
314 class _ForwardIterator2,
315 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
316 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
317[[nodiscard]] pair<_ForwardIterator1, _ForwardIterator2> mismatch(
318 _ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
319 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "mismatch requires ForwardIterators");
320 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "mismatch requires ForwardIterators");
321 using _Implementation = __pstl::__dispatch<__pstl::__mismatch_3leg, __pstl::__current_configuration, _RawPolicy>;
322 return __pstl::__handle_exception<_Implementation>(
323 std::forward<_ExecutionPolicy>(__policy),
324 std::move(__first1),
325 std::move(__last1),
326 std::move(__first2),
327 equal_to{});
328}
329
330template <class _ExecutionPolicy,
331 class _ForwardIterator,
332 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
333 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
334[[nodiscard]] _ForwardIterator
335adjacent_find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
336 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "adjacent_find requires ForwardIterators");
337 using _Implementation = __pstl::__dispatch<__pstl::__adjacent_find, __pstl::__current_configuration, _RawPolicy>;
338 return __pstl::__handle_exception<_Implementation>(
339 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), equal_to{});
340}
341
342template <class _ExecutionPolicy,
343 class _ForwardIterator,
344 class _BinaryPredicate,
345 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
346 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
347[[nodiscard]] _ForwardIterator adjacent_find(
348 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __predicate) {
349 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "adjacent_find requires ForwardIterators");
350 using _Implementation = __pstl::__dispatch<__pstl::__adjacent_find, __pstl::__current_configuration, _RawPolicy>;
351 return __pstl::__handle_exception<_Implementation>(
352 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__predicate));
353}
354
355template <class _ExecutionPolicy,
356 class _ForwardIterator1,
357 class _ForwardIterator2,
358 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
359 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
360[[nodiscard]] bool lexicographical_compare(
361 _ExecutionPolicy&& __policy,
362 _ForwardIterator1 __first1,
363 _ForwardIterator1 __last1,
364 _ForwardIterator2 __first2,
365 _ForwardIterator2 __last2) {
366 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "lexicographical_compare requires ForwardIterators");
367 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "lexicographical_compare requires ForwardIterators");
368 using _Implementation =
369 __pstl::__dispatch<__pstl::__lexicographical_compare, __pstl::__current_configuration, _RawPolicy>;
370 return __pstl::__handle_exception<_Implementation>(
371 std::forward<_ExecutionPolicy>(__policy),
372 std::move(__first1),
373 std::move(__last1),
374 std::move(__first2),
375 std::move(__last2),
376 less<>{});
377}
378
379template <class _ExecutionPolicy,
380 class _ForwardIterator1,
381 class _ForwardIterator2,
382 class _Comp,
383 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
384 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
385[[nodiscard]] bool lexicographical_compare(
386 _ExecutionPolicy&& __policy,
387 _ForwardIterator1 __first1,
388 _ForwardIterator1 __last1,
389 _ForwardIterator2 __first2,
390 _ForwardIterator2 __last2,
391 _Comp __comp) {
392 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "lexicographical_compare requires ForwardIterators");
393 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "lexicographical_compare requires ForwardIterators");
394 using _Implementation =
395 __pstl::__dispatch<__pstl::__lexicographical_compare, __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(__last2),
402 std::move(__comp));
403}
404
405template <class _ExecutionPolicy,
406 class _ForwardIterator1,
407 class _ForwardIterator2,
408 class _Pred,
409 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
410 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
411[[nodiscard]] bool
412equal(_ExecutionPolicy&& __policy,
413 _ForwardIterator1 __first1,
414 _ForwardIterator1 __last1,
415 _ForwardIterator2 __first2,
416 _Pred __pred) {
417 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
418 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
419 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
420 return __pstl::__handle_exception<_Implementation>(
421 std::forward<_ExecutionPolicy>(__policy),
422 std::move(__first1),
423 std::move(__last1),
424 std::move(__first2),
425 std::move(__pred));
426}
427
428template <class _ExecutionPolicy,
429 class _ForwardIterator1,
430 class _ForwardIterator2,
431 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
432 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
433[[nodiscard]] bool
434equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
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_3leg, __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 equal_to{});
444}
445
446template <class _ExecutionPolicy,
447 class _ForwardIterator1,
448 class _ForwardIterator2,
449 class _Pred,
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 _Pred __pred) {
459 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
460 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
461 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
462 return __pstl::__handle_exception<_Implementation>(
463 std::forward<_ExecutionPolicy>(__policy),
464 std::move(__first1),
465 std::move(__last1),
466 std::move(__first2),
467 std::move(__last2),
468 std::move(__pred));
469}
470
471template <class _ExecutionPolicy,
472 class _ForwardIterator1,
473 class _ForwardIterator2,
474 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
475 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
476[[nodiscard]] bool
477equal(_ExecutionPolicy&& __policy,
478 _ForwardIterator1 __first1,
479 _ForwardIterator1 __last1,
480 _ForwardIterator2 __first2,
481 _ForwardIterator2 __last2) {
482 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
483 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
484 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
485 return __pstl::__handle_exception<_Implementation>(
486 std::forward<_ExecutionPolicy>(__policy),
487 std::move(__first1),
488 std::move(__last1),
489 std::move(__first2),
490 std::move(__last2),
491 equal_to{});
492}
493
494template <class _ExecutionPolicy,
495 class _ForwardIterator,
496 class _Tp,
497 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
498 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
499void fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
500 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators");
501 using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>;
502 __pstl::__handle_exception<_Implementation>(
503 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
504}
505
506template <class _ExecutionPolicy,
507 class _ForwardIterator,
508 class _Size,
509 class _Tp,
510 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
511 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
512_ForwardIterator fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) {
513 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator");
514 using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>;
515 return __pstl::__handle_exception<_Implementation>(
516 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value);
517}
518
519template <class _ExecutionPolicy,
520 class _ForwardIterator1,
521 class _ForwardIterator2,
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 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_end requires ForwardIterators");
531 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_end requires ForwardIterators");
532 using _Implementation = __pstl::__dispatch<__pstl::__find_end, __pstl::__current_configuration, _RawPolicy>;
533 return __pstl::__handle_exception<_Implementation>(
534 std::forward<_ExecutionPolicy>(__policy),
535 std::move(__first1),
536 std::move(__last1),
537 std::move(__first2),
538 std::move(__last2),
539 equal_to<>{});
540}
541
542template <class _ExecutionPolicy,
543 class _ForwardIterator1,
544 class _ForwardIterator2,
545 class _BinaryPredicate,
546 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
547 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
548[[nodiscard]] _ForwardIterator1
549find_end(_ExecutionPolicy&& __policy,
550 _ForwardIterator1 __first1,
551 _ForwardIterator1 __last1,
552 _ForwardIterator2 __first2,
553 _ForwardIterator2 __last2,
554 _BinaryPredicate __pred) {
555 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_end requires ForwardIterators");
556 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_end requires ForwardIterators");
557 using _Implementation = __pstl::__dispatch<__pstl::__find_end, __pstl::__current_configuration, _RawPolicy>;
558 return __pstl::__handle_exception<_Implementation>(
559 std::forward<_ExecutionPolicy>(__policy),
560 std::move(__first1),
561 std::move(__last1),
562 std::move(__first2),
563 std::move(__last2),
564 std::move(__pred));
565}
566
567template <class _ExecutionPolicy,
568 class _ForwardIterator,
569 class _Predicate,
570 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
571 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
572[[nodiscard]] _ForwardIterator
573find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
574 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
575 using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
576 return __pstl::__handle_exception<_Implementation>(
577 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
578}
579
580template <class _ExecutionPolicy,
581 class _ForwardIterator,
582 class _Predicate,
583 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
584 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
585[[nodiscard]] _ForwardIterator
586find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
587 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
588 using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
589 return __pstl::__handle_exception<_Implementation>(
590 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
591}
592
593template <class _ExecutionPolicy,
594 class _ForwardIterator,
595 class _Tp,
596 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
597 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
598[[nodiscard]] _ForwardIterator
599find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
600 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
601 using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;
602 return __pstl::__handle_exception<_Implementation>(
603 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
604}
605
606template <class _ExecutionPolicy,
607 class _ForwardIterator1,
608 class _ForwardIterator2,
609 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
610 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
611[[nodiscard]] _ForwardIterator1
612find_first_of(_ExecutionPolicy&& __policy,
613 _ForwardIterator1 __first1,
614 _ForwardIterator1 __last1,
615 _ForwardIterator2 __first2,
616 _ForwardIterator2 __last2) {
617 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
618 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
619 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
620 return __pstl::__handle_exception<_Implementation>(
621 std::forward<_ExecutionPolicy>(__policy),
622 std::move(__first1),
623 std::move(__last1),
624 std::move(__first2),
625 std::move(__last2),
626 std::equal_to<>{});
627}
628
629template <class _ExecutionPolicy,
630 class _ForwardIterator1,
631 class _ForwardIterator2,
632 class _BinaryPredicate,
633 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
634 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
635[[nodiscard]] _ForwardIterator1 find_first_of(
636 _ExecutionPolicy&& __policy,
637 _ForwardIterator1 __first1,
638 _ForwardIterator1 __last1,
639 _ForwardIterator2 __first2,
640 _ForwardIterator2 __last2,
641 _BinaryPredicate __pred) {
642 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "find_first_of requires ForwardIterators");
643 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "find_first_of requires ForwardIterators");
644 using _Implementation = __pstl::__dispatch<__pstl::__find_first_of, __pstl::__current_configuration, _RawPolicy>;
645 return __pstl::__handle_exception<_Implementation>(
646 std::forward<_ExecutionPolicy>(__policy),
647 std::move(__first1),
648 std::move(__last1),
649 std::move(__first2),
650 std::move(__last2),
651 std::move(__pred));
652}
653
654template <class _ExecutionPolicy,
655 class _ForwardIterator,
656 class _Function,
657 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
658 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
659void for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
660 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators");
661 using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>;
662 __pstl::__handle_exception<_Implementation>(
663 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func));
664}
665
666template <class _ExecutionPolicy,
667 class _ForwardIterator,
668 class _Size,
669 class _Function,
670 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
671 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
672_ForwardIterator for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
673 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator");
674 using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>;
675 return __pstl::__handle_exception<_Implementation>(
676 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func));
677}
678
679template <class _ExecutionPolicy,
680 class _ForwardIterator,
681 class _Generator,
682 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
683 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
684void generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
685 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators");
686 using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>;
687 __pstl::__handle_exception<_Implementation>(
688 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen));
689}
690
691template <class _ExecutionPolicy,
692 class _ForwardIterator,
693 class _Size,
694 class _Generator,
695 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
696 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
697_ForwardIterator generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) {
698 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator");
699 using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>;
700 return __pstl::__handle_exception<_Implementation>(
701 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen));
702}
703
704template <class _ExecutionPolicy,
705 class _BidirectionalIterator,
706 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
707 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
708void reverse(_ExecutionPolicy&& __policy, _BidirectionalIterator __first, _BidirectionalIterator __last) {
709 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse requires a BidirectionalIterator");
710 using _Implementation = __pstl::__dispatch<__pstl::__reverse, __pstl::__current_configuration, _RawPolicy>;
711 __pstl::__handle_exception<_Implementation>(
712 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last));
713}
714
715template <class _ExecutionPolicy,
716 class _BidirectionalIterator,
717 class _ForwardIterator,
718 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
719 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
720[[nodiscard]] _ForwardIterator
721reverse_copy(_ExecutionPolicy&& __policy,
722 _BidirectionalIterator __first,
723 _BidirectionalIterator __last,
724 _ForwardIterator __result) {
725 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(_BidirectionalIterator, "reverse_copy requires a BidirectionalIterator");
726 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reverse_copy requires a ForwardIterator");
727 using _Implementation = __pstl::__dispatch<__pstl::__reverse_copy, __pstl::__current_configuration, _RawPolicy>;
728 return __pstl::__handle_exception<_Implementation>(
729 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
730}
731
732template <class _ExecutionPolicy,
733 class _ForwardIterator,
734 class _Predicate,
735 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
736 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
737[[nodiscard]] bool
738is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
739 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators");
740 using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>;
741 return __pstl::__handle_exception<_Implementation>(
742 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
743}
744
745template <class _ExecutionPolicy,
746 class _ForwardIterator,
747 class _Predicate,
748 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
749 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
750[[nodiscard]] _ForwardIterator
751partition(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
752 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "partition requires ForwardIterators");
753 using _Implementation = __pstl::__dispatch<__pstl::__partition, __pstl::__current_configuration, _RawPolicy>;
754 return __pstl::__handle_exception<_Implementation>(
755 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
756}
757
758template <class _ExecutionPolicy,
759 class _BidirectionalIterator,
760 class _Predicate,
761 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
762 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
763[[nodiscard]] _BidirectionalIterator stable_partition(
764 _ExecutionPolicy&& __policy, _BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred) {
765 _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(
766 _BidirectionalIterator, "stable_partition requires BidirectionalIterators");
767 using _Implementation = __pstl::__dispatch<__pstl::__stable_partition, __pstl::__current_configuration, _RawPolicy>;
768 return __pstl::__handle_exception<_Implementation>(
769 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
770}
771
772template <class _ExecutionPolicy,
773 class _ForwardIterator,
774 class _ForwardOutIterator1,
775 class _ForwardOutIterator2,
776 class _Predicate,
777 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
778 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
779[[nodiscard]] pair<_ForwardOutIterator1, _ForwardOutIterator2> partition_copy(
780 _ExecutionPolicy&& __policy,
781 _ForwardIterator __first,
782 _ForwardIterator __last,
783 _ForwardOutIterator1 __out_true,
784 _ForwardOutIterator2 __out_false,
785 _Predicate __pred) {
786 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "partition_copy requires ForwardIterators");
787 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator1, "partition_copy requires ForwardIterators");
788 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator2, "partition_copy requires ForwardIterators");
789 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
790 _ForwardOutIterator1, decltype(*__first), "partition_copy requires an OutputIterator");
791 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
792 _ForwardOutIterator2, decltype(*__first), "partition_copy requires an OutputIterator");
793 using _Implementation = __pstl::__dispatch<__pstl::__partition_copy, __pstl::__current_configuration, _RawPolicy>;
794 return __pstl::__handle_exception<_Implementation>(
795 std::forward<_ExecutionPolicy>(__policy),
796 std::move(__first),
797 std::move(__last),
798 std::move(__out_true),
799 std::move(__out_false),
800 std::move(__pred));
801}
802
803template <class _ExecutionPolicy,
804 class _ForwardIterator1,
805 class _ForwardIterator2,
806 class _ForwardOutIterator,
807 class _Comp,
808 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
809 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
810_ForwardOutIterator
811merge(_ExecutionPolicy&& __policy,
812 _ForwardIterator1 __first1,
813 _ForwardIterator1 __last1,
814 _ForwardIterator2 __first2,
815 _ForwardIterator2 __last2,
816 _ForwardOutIterator __result,
817 _Comp __comp) {
818 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
819 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
820 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
821 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
822 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
823 return __pstl::__handle_exception<_Implementation>(
824 std::forward<_ExecutionPolicy>(__policy),
825 std::move(__first1),
826 std::move(__last1),
827 std::move(__first2),
828 std::move(__last2),
829 std::move(__result),
830 std::move(__comp));
831}
832
833template <class _ExecutionPolicy,
834 class _ForwardIterator1,
835 class _ForwardIterator2,
836 class _ForwardOutIterator,
837 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
838 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
839_ForwardOutIterator
840merge(_ExecutionPolicy&& __policy,
841 _ForwardIterator1 __first1,
842 _ForwardIterator1 __last1,
843 _ForwardIterator2 __first2,
844 _ForwardIterator2 __last2,
845 _ForwardOutIterator __result) {
846 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
847 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
848 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
849 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
850 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
851 return __pstl::__handle_exception<_Implementation>(
852 std::forward<_ExecutionPolicy>(__policy),
853 std::move(__first1),
854 std::move(__last1),
855 std::move(__first2),
856 std::move(__last2),
857 std::move(__result),
858 less{});
859}
860
861template <class _ExecutionPolicy,
862 class _ForwardIterator,
863 class _ForwardOutIterator,
864 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
865 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
866_ForwardOutIterator
867move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
868 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators");
869 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator");
870 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
871 _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator");
872 using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>;
873 return __pstl::__handle_exception<_Implementation>(
874 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
875}
876
877template <class _ExecutionPolicy,
878 class _ForwardIterator,
879 class _Pred,
880 class _Tp,
881 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
882 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
883void replace_if(_ExecutionPolicy&& __policy,
884 _ForwardIterator __first,
885 _ForwardIterator __last,
886 _Pred __pred,
887 const _Tp& __new_value) {
888 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators");
889 using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>;
890 __pstl::__handle_exception<_Implementation>(
891 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value);
892}
893
894template <class _ExecutionPolicy,
895 class _ForwardIterator,
896 class _Tp,
897 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
898 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
899void replace(_ExecutionPolicy&& __policy,
900 _ForwardIterator __first,
901 _ForwardIterator __last,
902 const _Tp& __old_value,
903 const _Tp& __new_value) {
904 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators");
905 using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>;
906 __pstl::__handle_exception<_Implementation>(
907 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value);
908}
909
910template <class _ExecutionPolicy,
911 class _ForwardIterator,
912 class _ForwardOutIterator,
913 class _Pred,
914 class _Tp,
915 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
916 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
917void replace_copy_if(
918 _ExecutionPolicy&& __policy,
919 _ForwardIterator __first,
920 _ForwardIterator __last,
921 _ForwardOutIterator __result,
922 _Pred __pred,
923 const _Tp& __new_value) {
924 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators");
925 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators");
926 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
927 _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator");
928 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
929 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>;
930 __pstl::__handle_exception<_Implementation>(
931 std::forward<_ExecutionPolicy>(__policy),
932 std::move(__first),
933 std::move(__last),
934 std::move(__result),
935 std::move(__pred),
936 __new_value);
937}
938
939template <class _ExecutionPolicy,
940 class _ForwardIterator,
941 class _ForwardOutIterator,
942 class _Tp,
943 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
944 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
945void replace_copy(_ExecutionPolicy&& __policy,
946 _ForwardIterator __first,
947 _ForwardIterator __last,
948 _ForwardOutIterator __result,
949 const _Tp& __old_value,
950 const _Tp& __new_value) {
951 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators");
952 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators");
953 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
954 _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator");
955 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
956 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>;
957 __pstl::__handle_exception<_Implementation>(
958 std::forward<_ExecutionPolicy>(__policy),
959 std::move(__first),
960 std::move(__last),
961 std::move(__result),
962 __old_value,
963 __new_value);
964}
965
966template <class _ExecutionPolicy,
967 class _ForwardIterator,
968 class _ForwardOutIterator,
969 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
970 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
971_ForwardOutIterator
972rotate_copy(_ExecutionPolicy&& __policy,
973 _ForwardIterator __first,
974 _ForwardIterator __middle,
975 _ForwardIterator __last,
976 _ForwardOutIterator __result) {
977 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators");
978 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators");
979 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
980 _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator");
981 using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>;
982 return __pstl::__handle_exception<_Implementation>(
983 std::forward<_ExecutionPolicy>(__policy),
984 std::move(__first),
985 std::move(__middle),
986 std::move(__last),
987 std::move(__result));
988}
989
990template <class _ExecutionPolicy,
991 class _ForwardIterator1,
992 class _ForwardIterator2,
993 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
994 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
995[[nodiscard]] _ForwardIterator1
996search(_ExecutionPolicy&& __policy,
997 _ForwardIterator1 __first1,
998 _ForwardIterator1 __last1,
999 _ForwardIterator2 __first2,
1000 _ForwardIterator2 __last2) {
1001 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "search requires ForwardIterators");
1002 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "search requires ForwardIterators");
1003 using _Implementation = __pstl::__dispatch<__pstl::__search, __pstl::__current_configuration, _RawPolicy>;
1004 return __pstl::__handle_exception<_Implementation>(
1005 std::forward<_ExecutionPolicy>(__policy),
1006 std::move(__first1),
1007 std::move(__last1),
1008 std::move(__first2),
1009 std::move(__last2),
1010 equal_to<>{});
1011}
1012
1013template <class _ExecutionPolicy,
1014 class _ForwardIterator1,
1015 class _ForwardIterator2,
1016 class _BinaryPredicate,
1017 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1018 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1019[[nodiscard]] _ForwardIterator1
1020search(_ExecutionPolicy&& __policy,
1021 _ForwardIterator1 __first1,
1022 _ForwardIterator1 __last1,
1023 _ForwardIterator2 __first2,
1024 _ForwardIterator2 __last2,
1025 _BinaryPredicate __pred) {
1026 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "search requires ForwardIterators");
1027 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "search requires ForwardIterators");
1028 using _Implementation = __pstl::__dispatch<__pstl::__search, __pstl::__current_configuration, _RawPolicy>;
1029 return __pstl::__handle_exception<_Implementation>(
1030 std::forward<_ExecutionPolicy>(__policy),
1031 std::move(__first1),
1032 std::move(__last1),
1033 std::move(__first2),
1034 std::move(__last2),
1035 std::move(__pred));
1036}
1037
1038template <class _ExecutionPolicy,
1039 class _ForwardIterator,
1040 class _Size,
1041 class _Tp,
1042 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1043 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1044[[nodiscard]] _ForwardIterator search_n(
1045 _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
1046 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
1047 using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
1048 return __pstl::__handle_exception<_Implementation>(
1049 std::forward<_ExecutionPolicy>(__policy),
1050 std::move(__first),
1051 std::move(__last),
1052 std::move(__count),
1053 __value,
1054 equal_to<>{});
1055}
1056
1057template <class _ExecutionPolicy,
1058 class _ForwardIterator,
1059 class _Size,
1060 class _Tp,
1061 class _BinaryPredicate,
1062 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1063 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1064[[nodiscard]] _ForwardIterator
1065search_n(_ExecutionPolicy&& __policy,
1066 _ForwardIterator __first,
1067 _ForwardIterator __last,
1068 _Size __count,
1069 const _Tp& __value,
1070 _BinaryPredicate __pred) {
1071 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "search_n requires ForwardIterators");
1072 using _Implementation = __pstl::__dispatch<__pstl::__search_n, __pstl::__current_configuration, _RawPolicy>;
1073 return __pstl::__handle_exception<_Implementation>(
1074 std::forward<_ExecutionPolicy>(__policy),
1075 std::move(__first),
1076 std::move(__last),
1077 std::move(__count),
1078 __value,
1079 std::move(__pred));
1080}
1081
1082template <class _ExecutionPolicy,
1083 class _RandomAccessIterator,
1084 class _Comp,
1085 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1086 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1087void sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1088 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
1089 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
1090 __pstl::__handle_exception<_Implementation>(
1091 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1092}
1093
1094template <class _ExecutionPolicy,
1095 class _RandomAccessIterator,
1096 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1097 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1098void sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1099 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
1100 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
1101 __pstl::__handle_exception<_Implementation>(
1102 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1103}
1104
1105template <class _ExecutionPolicy,
1106 class _RandomAccessIterator,
1107 class _Comp,
1108 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1109 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1110void stable_sort(
1111 _ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1112 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
1113 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
1114 __pstl::__handle_exception<_Implementation>(
1115 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1116}
1117
1118template <class _ExecutionPolicy,
1119 class _RandomAccessIterator,
1120 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1121 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1122void stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1123 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
1124 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
1125 __pstl::__handle_exception<_Implementation>(
1126 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1127}
1128
1129template <class _ExecutionPolicy,
1130 class _ForwardIterator1,
1131 class _ForwardIterator2,
1132 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1133 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1134_ForwardIterator2 swap_ranges(
1135 _ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
1136 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "swap_ranges requires ForwardIterators");
1137 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "swap_ranges requires ForwardIterators");
1138 using _Implementation = __pstl::__dispatch<__pstl::__swap_ranges, __pstl::__current_configuration, _RawPolicy>;
1139 return __pstl::__handle_exception<_Implementation>(
1140 std::forward<_ExecutionPolicy>(__policy), std::move(__first1), std::move(__last1), std::move(__first2));
1141}
1142
1143template <class _ExecutionPolicy,
1144 class _ForwardIterator,
1145 class _ForwardOutIterator,
1146 class _UnaryOperation,
1147 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1148 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1149_ForwardOutIterator
1150transform(_ExecutionPolicy&& __policy,
1151 _ForwardIterator __first,
1152 _ForwardIterator __last,
1153 _ForwardOutIterator __result,
1154 _UnaryOperation __op) {
1155 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators");
1156 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
1157 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1158 _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator");
1159 using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>;
1160 return __pstl::__handle_exception<_Implementation>(
1161 std::forward<_ExecutionPolicy>(__policy),
1162 std::move(__first),
1163 std::move(__last),
1164 std::move(__result),
1165 std::move(__op));
1166}
1167
1168template <class _ExecutionPolicy,
1169 class _ForwardIterator1,
1170 class _ForwardIterator2,
1171 class _ForwardOutIterator,
1172 class _BinaryOperation,
1173 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1174 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1175_ForwardOutIterator
1176transform(_ExecutionPolicy&& __policy,
1177 _ForwardIterator1 __first1,
1178 _ForwardIterator1 __last1,
1179 _ForwardIterator2 __first2,
1180 _ForwardOutIterator __result,
1181 _BinaryOperation __op) {
1182 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators");
1183 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators");
1184 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
1185 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1186 _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator");
1187 using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>;
1188 return __pstl::__handle_exception<_Implementation>(
1189 std::forward<_ExecutionPolicy>(__policy),
1190 std::move(__first1),
1191 std::move(__last1),
1192 std::move(__first2),
1193 std::move(__result),
1194 std::move(__op));
1195}
1196
1197template <class _ExecutionPolicy,
1198 class _RandomAccessIterator,
1199 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1200 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1201[[nodiscard]] bool is_heap(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1202 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap requires RandomAccessIterators");
1203 using _Implementation = __pstl::__dispatch<__pstl::__is_heap, __pstl::__current_configuration, _RawPolicy>;
1204 return __pstl::__handle_exception<_Implementation>(
1205 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1206}
1207
1208template <class _ExecutionPolicy,
1209 class _RandomAccessIterator,
1210 class _Comp,
1211 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1212 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1213[[nodiscard]] bool
1214is_heap(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1215 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap requires RandomAccessIterators");
1216 using _Implementation = __pstl::__dispatch<__pstl::__is_heap, __pstl::__current_configuration, _RawPolicy>;
1217 return __pstl::__handle_exception<_Implementation>(
1218 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1219}
1220
1221template <class _ExecutionPolicy,
1222 class _RandomAccessIterator,
1223 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1224 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1225[[nodiscard]] _RandomAccessIterator
1226is_heap_until(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
1227 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap_until requires RandomAccessIterators");
1228 using _Implementation = __pstl::__dispatch<__pstl::__is_heap_until, __pstl::__current_configuration, _RawPolicy>;
1229 return __pstl::__handle_exception<_Implementation>(
1230 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1231}
1232
1233template <class _ExecutionPolicy,
1234 class _RandomAccessIterator,
1235 class _Comp,
1236 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1237 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1238[[nodiscard]] _RandomAccessIterator
1239is_heap_until(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
1240 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "is_heap_until requires RandomAccessIterators");
1241 using _Implementation = __pstl::__dispatch<__pstl::__is_heap_until, __pstl::__current_configuration, _RawPolicy>;
1242 return __pstl::__handle_exception<_Implementation>(
1243 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1244}
1245
1246template <class _ExecutionPolicy,
1247 class _ForwardIterator,
1248 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1249 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1250[[nodiscard]] bool is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
1251 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
1252 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
1253 return __pstl::__handle_exception<_Implementation>(
1254 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1255}
1256
1257template <class _ExecutionPolicy,
1258 class _ForwardIterator,
1259 class _Comp,
1260 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1261 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1262[[nodiscard]] bool
1263is_sorted(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
1264 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted requires ForwardIterators");
1265 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted, __pstl::__current_configuration, _RawPolicy>;
1266 return __pstl::__handle_exception<_Implementation>(
1267 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1268}
1269
1270template <class _ExecutionPolicy,
1271 class _ForwardIterator,
1272 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1273 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1274[[nodiscard]] _ForwardIterator
1275is_sorted_until(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
1276 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted_until requires ForwardIterators");
1277 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted_until, __pstl::__current_configuration, _RawPolicy>;
1278 return __pstl::__handle_exception<_Implementation>(
1279 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
1280}
1281
1282template <class _ExecutionPolicy,
1283 class _ForwardIterator,
1284 class _Comp,
1285 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1286 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1287[[nodiscard]] _ForwardIterator
1288is_sorted_until(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp __comp) {
1289 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_sorted_until requires ForwardIterators");
1290 using _Implementation = __pstl::__dispatch<__pstl::__is_sorted_until, __pstl::__current_configuration, _RawPolicy>;
1291 return __pstl::__handle_exception<_Implementation>(
1292 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
1293}
1294
1295template <class _ExecutionPolicy,
1296 class _ForwardIterator1,
1297 class _ForwardIterator2,
1298 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1299 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1300[[nodiscard]] bool
1301includes(_ExecutionPolicy&& __policy,
1302 _ForwardIterator1 __first1,
1303 _ForwardIterator1 __last1,
1304 _ForwardIterator2 __first2,
1305 _ForwardIterator2 __last2) {
1306 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "includes requires ForwardIterators");
1307 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "includes requires ForwardIterators");
1308 using _Implementation = __pstl::__dispatch<__pstl::__includes, __pstl::__current_configuration, _RawPolicy>;
1309 return __pstl::__handle_exception<_Implementation>(
1310 std::forward<_ExecutionPolicy>(__policy),
1311 std::move(__first1),
1312 std::move(__last1),
1313 std::move(__first2),
1314 std::move(__last2),
1315 less{});
1316}
1317
1318template <class _ExecutionPolicy,
1319 class _ForwardIterator1,
1320 class _ForwardIterator2,
1321 class _Compare,
1322 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1323 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1324[[nodiscard]] bool
1325includes(_ExecutionPolicy&& __policy,
1326 _ForwardIterator1 __first1,
1327 _ForwardIterator1 __last1,
1328 _ForwardIterator2 __first2,
1329 _ForwardIterator2 __last2,
1330 _Compare __comp) {
1331 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "includes requires ForwardIterators");
1332 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "includes requires ForwardIterators");
1333 using _Implementation = __pstl::__dispatch<__pstl::__includes, __pstl::__current_configuration, _RawPolicy>;
1334 return __pstl::__handle_exception<_Implementation>(
1335 std::forward<_ExecutionPolicy>(__policy),
1336 std::move(__first1),
1337 std::move(__last1),
1338 std::move(__first2),
1339 std::move(__last2),
1340 std::move(__comp));
1341}
1342
1343template <class _ExecutionPolicy,
1344 class _ForwardIterator1,
1345 class _ForwardIterator2,
1346 class _ForwardOutIterator,
1347 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1348 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1349[[nodiscard]] _ForwardOutIterator
1350set_union(_ExecutionPolicy&& __policy,
1351 _ForwardIterator1 __first1,
1352 _ForwardIterator1 __last1,
1353 _ForwardIterator2 __first2,
1354 _ForwardIterator2 __last2,
1355 _ForwardOutIterator __result) {
1356 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_union requires ForwardIterators");
1357 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_union requires ForwardIterators");
1358 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1359 _ForwardOutIterator, decltype(*__first1), "set_union requires result to be an OutputIterator");
1360 using _Implementation = __pstl::__dispatch<__pstl::__set_union, __pstl::__current_configuration, _RawPolicy>;
1361 return __pstl::__handle_exception<_Implementation>(
1362 std::forward<_ExecutionPolicy>(__policy),
1363 std::move(__first1),
1364 std::move(__last1),
1365 std::move(__first2),
1366 std::move(__last2),
1367 std::move(__result),
1368 less{});
1369}
1370
1371template <class _ExecutionPolicy,
1372 class _ForwardIterator1,
1373 class _ForwardIterator2,
1374 class _ForwardOutIterator,
1375 class _Compare,
1376 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1377 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1378[[nodiscard]] _ForwardOutIterator
1379set_union(_ExecutionPolicy&& __policy,
1380 _ForwardIterator1 __first1,
1381 _ForwardIterator1 __last1,
1382 _ForwardIterator2 __first2,
1383 _ForwardIterator2 __last2,
1384 _ForwardOutIterator __result,
1385 _Compare __comp) {
1386 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_union requires ForwardIterators");
1387 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_union requires ForwardIterators");
1388 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1389 _ForwardOutIterator, decltype(*__first1), "set_union requires result to be an OutputIterator");
1390 using _Implementation = __pstl::__dispatch<__pstl::__set_union, __pstl::__current_configuration, _RawPolicy>;
1391 return __pstl::__handle_exception<_Implementation>(
1392 std::forward<_ExecutionPolicy>(__policy),
1393 std::move(__first1),
1394 std::move(__last1),
1395 std::move(__first2),
1396 std::move(__last2),
1397 std::move(__result),
1398 std::move(__comp));
1399}
1400
1401template <class _ExecutionPolicy,
1402 class _ForwardIterator1,
1403 class _ForwardIterator2,
1404 class _ForwardOutIterator,
1405 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1406 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1407[[nodiscard]] _ForwardOutIterator set_intersection(
1408 _ExecutionPolicy&& __policy,
1409 _ForwardIterator1 __first1,
1410 _ForwardIterator1 __last1,
1411 _ForwardIterator2 __first2,
1412 _ForwardIterator2 __last2,
1413 _ForwardOutIterator __result) {
1414 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_intersection requires ForwardIterators");
1415 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_intersection requires ForwardIterators");
1416 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1417 _ForwardOutIterator, decltype(*__first1), "set_intersection requires result to be an OutputIterator");
1418 using _Implementation = __pstl::__dispatch<__pstl::__set_intersection, __pstl::__current_configuration, _RawPolicy>;
1419 return __pstl::__handle_exception<_Implementation>(
1420 std::forward<_ExecutionPolicy>(__policy),
1421 std::move(__first1),
1422 std::move(__last1),
1423 std::move(__first2),
1424 std::move(__last2),
1425 std::move(__result),
1426 less{});
1427}
1428
1429template <class _ExecutionPolicy,
1430 class _ForwardIterator1,
1431 class _ForwardIterator2,
1432 class _ForwardOutIterator,
1433 class _Compare,
1434 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1435 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1436[[nodiscard]] _ForwardOutIterator set_intersection(
1437 _ExecutionPolicy&& __policy,
1438 _ForwardIterator1 __first1,
1439 _ForwardIterator1 __last1,
1440 _ForwardIterator2 __first2,
1441 _ForwardIterator2 __last2,
1442 _ForwardOutIterator __result,
1443 _Compare __comp) {
1444 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_intersection requires ForwardIterators");
1445 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_intersection requires ForwardIterators");
1446 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1447 _ForwardOutIterator, decltype(*__first1), "set_intersection requires result to be an OutputIterator");
1448 using _Implementation = __pstl::__dispatch<__pstl::__set_intersection, __pstl::__current_configuration, _RawPolicy>;
1449 return __pstl::__handle_exception<_Implementation>(
1450 std::forward<_ExecutionPolicy>(__policy),
1451 std::move(__first1),
1452 std::move(__last1),
1453 std::move(__first2),
1454 std::move(__last2),
1455 std::move(__result),
1456 std::move(__comp));
1457}
1458
1459template <class _ExecutionPolicy,
1460 class _ForwardIterator1,
1461 class _ForwardIterator2,
1462 class _ForwardOutIterator,
1463 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1464 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1465[[nodiscard]] _ForwardOutIterator set_difference(
1466 _ExecutionPolicy&& __policy,
1467 _ForwardIterator1 __first1,
1468 _ForwardIterator1 __last1,
1469 _ForwardIterator2 __first2,
1470 _ForwardIterator2 __last2,
1471 _ForwardOutIterator __result) {
1472 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_difference requires ForwardIterators");
1473 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_difference requires ForwardIterators");
1474 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1475 _ForwardOutIterator, decltype(*__first1), "set_difference requires result to be an OutputIterator");
1476 using _Implementation = __pstl::__dispatch<__pstl::__set_difference, __pstl::__current_configuration, _RawPolicy>;
1477 return __pstl::__handle_exception<_Implementation>(
1478 std::forward<_ExecutionPolicy>(__policy),
1479 std::move(__first1),
1480 std::move(__last1),
1481 std::move(__first2),
1482 std::move(__last2),
1483 std::move(__result),
1484 less{});
1485}
1486
1487template <class _ExecutionPolicy,
1488 class _ForwardIterator1,
1489 class _ForwardIterator2,
1490 class _ForwardOutIterator,
1491 class _Compare,
1492 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1493 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1494[[nodiscard]] _ForwardOutIterator set_difference(
1495 _ExecutionPolicy&& __policy,
1496 _ForwardIterator1 __first1,
1497 _ForwardIterator1 __last1,
1498 _ForwardIterator2 __first2,
1499 _ForwardIterator2 __last2,
1500 _ForwardOutIterator __result,
1501 _Compare __comp) {
1502 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_difference requires ForwardIterators");
1503 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_difference requires ForwardIterators");
1504 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1505 _ForwardOutIterator, decltype(*__first1), "set_difference requires result to be an OutputIterator");
1506 using _Implementation = __pstl::__dispatch<__pstl::__set_difference, __pstl::__current_configuration, _RawPolicy>;
1507 return __pstl::__handle_exception<_Implementation>(
1508 std::forward<_ExecutionPolicy>(__policy),
1509 std::move(__first1),
1510 std::move(__last1),
1511 std::move(__first2),
1512 std::move(__last2),
1513 std::move(__result),
1514 std::move(__comp));
1515}
1516
1517template <class _ExecutionPolicy,
1518 class _ForwardIterator1,
1519 class _ForwardIterator2,
1520 class _ForwardOutIterator,
1521 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1522 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1523[[nodiscard]] _ForwardOutIterator set_symmetric_difference(
1524 _ExecutionPolicy&& __policy,
1525 _ForwardIterator1 __first1,
1526 _ForwardIterator1 __last1,
1527 _ForwardIterator2 __first2,
1528 _ForwardIterator2 __last2,
1529 _ForwardOutIterator __result) {
1530 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_symmetric_difference requires ForwardIterators");
1531 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_symmetric_difference requires ForwardIterators");
1532 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1533 _ForwardOutIterator, decltype(*__first1), "set_symmetric_difference requires result to be an OutputIterator");
1534 using _Implementation =
1535 __pstl::__dispatch<__pstl::__set_symmetric_difference, __pstl::__current_configuration, _RawPolicy>;
1536 return __pstl::__handle_exception<_Implementation>(
1537 std::forward<_ExecutionPolicy>(__policy),
1538 std::move(__first1),
1539 std::move(__last1),
1540 std::move(__first2),
1541 std::move(__last2),
1542 std::move(__result),
1543 less{});
1544}
1545
1546template <class _ExecutionPolicy,
1547 class _ForwardIterator1,
1548 class _ForwardIterator2,
1549 class _ForwardOutIterator,
1550 class _Compare,
1551 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
1552 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
1553[[nodiscard]] _ForwardOutIterator set_symmetric_difference(
1554 _ExecutionPolicy&& __policy,
1555 _ForwardIterator1 __first1,
1556 _ForwardIterator1 __last1,
1557 _ForwardIterator2 __first2,
1558 _ForwardIterator2 __last2,
1559 _ForwardOutIterator __result,
1560 _Compare __comp) {
1561 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "set_symmetric_difference requires ForwardIterators");
1562 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "set_symmetric_difference requires ForwardIterators");
1563 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
1564 _ForwardOutIterator, decltype(*__first1), "set_symmetric_difference requires result to be an OutputIterator");
1565 using _Implementation =
1566 __pstl::__dispatch<__pstl::__set_symmetric_difference, __pstl::__current_configuration, _RawPolicy>;
1567 return __pstl::__handle_exception<_Implementation>(
1568 std::forward<_ExecutionPolicy>(__policy),
1569 std::move(__first1),
1570 std::move(__last1),
1571 std::move(__first2),
1572 std::move(__last2),
1573 std::move(__result),
1574 std::move(__comp));
1575}
1576
1577_LIBCPP_END_NAMESPACE_STD
1578
1579#endif // _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
1580
1581_LIBCPP_POP_MACROS
1582
1583#endif // _LIBCPP___ALGORITHM_PSTL_H
1584