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