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