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___PSTL_BACKEND_FWD_H
10#define _LIBCPP___PSTL_BACKEND_FWD_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//
22// This header declares available PSTL backends and the functions that must be implemented in order for the
23// PSTL algorithms to be provided.
24//
25// Backends often do not implement the full set of functions themselves -- a configuration of the PSTL is
26// usually a set of backends "stacked" together which each implement some algorithms under some execution
27// policies. It is only necessary for the "stack" of backends to implement all algorithms under all execution
28// policies, but a single backend is not required to implement everything on its own.
29//
30// The signatures used by each backend function are documented below.
31//
32// Exception handling
33// ==================
34//
35// PSTL backends are expected to report errors (i.e. failure to allocate) by returning a disengaged `optional` from
36// their implementation. Exceptions shouldn't be used to report an internal failure-to-allocate, since all exceptions
37// are turned into a program termination at the front-end level. When a backend returns a disengaged `optional` to the
38// frontend, the frontend will turn that into a call to `std::__throw_bad_alloc();` to report the internal failure to
39// the user.
40//
41
42#if _LIBCPP_STD_VER >= 17
43
44_LIBCPP_BEGIN_NAMESPACE_STD
45namespace __pstl {
46
47template <class... _Backends>
48struct __backend_configuration;
49
50struct __default_backend_tag;
51struct __serial_backend_tag;
52struct __statpart_backend_tag;
53
54# if _LIBCPP_HAS_THREADS
55using __current_configuration _LIBCPP_NODEBUG =
56 __backend_configuration<__statpart_backend_tag, __default_backend_tag, __serial_backend_tag>;
57# else // ...New vendors can add parallel backends here...
58using __current_configuration _LIBCPP_NODEBUG = __backend_configuration<__serial_backend_tag, __default_backend_tag>;
59# endif
60
61template <class _Backend, class _ExecutionPolicy>
62struct __adjacent_difference;
63// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
64// optional<_ForwardIterator2>
65// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
66// _ForwardIterator2 __first2, _BinaryOperation &&__op) const noexcept;
67
68template <class _Backend, class _ExecutionPolicy>
69struct __adjacent_find;
70// template <class _Policy, class _ForwardIterator, class _BinaryPredicate>
71// optional<_ForwardIterator>
72// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last,
73// _BinaryPredicate __predicate) const noexcept;
74
75template <class _Backend, class _ExecutionPolicy>
76struct __all_of;
77// template <class _Policy, class _ForwardIterator, class _Predicate>
78// optional<bool>
79// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
80
81template <class _Backend, class _ExecutionPolicy>
82struct __any_of;
83// template <class _Policy, class _ForwardIterator, class _Predicate>
84// optional<bool>
85// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
86
87template <class _Backend, class _ExecutionPolicy>
88struct __copy;
89// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
90// optional<_ForwardOutIterator>
91// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
92// _ForwardOutIterator __out_it) const noexcept;
93
94template <class _Backend, class _ExecutionPolicy>
95struct __copy_if;
96// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Predicate>
97// optional<_ForwardOutIterator>
98// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
99// _ForwardOutIterator __out_it, _Predicate __pred) const noexcept;
100
101template <class _Backend, class _ExecutionPolicy>
102struct __copy_n;
103// template <class _Policy, class _ForwardIterator, class _Size, class _ForwardOutIterator>
104// optional<_ForwardOutIterator>
105// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _ForwardOutIterator __out_it) const noexcept;
106
107template <class _Backend, class _ExecutionPolicy>
108struct __count;
109// template <class _Policy, class _ForwardIterator, class _Tp>
110// optional<__iter_diff_t<_ForwardIterator>>
111// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
112
113template <class _Backend, class _ExecutionPolicy>
114struct __count_if;
115// template <class _Policy, class _ForwardIterator, class _Predicate>
116// optional<__iter_diff_t<_ForwardIterator>>
117// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
118
119template <class _Backend, class _ExecutionPolicy>
120struct __destroy;
121// template <class _Policy, class _ForwardIterator>
122// optional<__empty>
123// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last) const noexcept;
124
125template <class _Backend, class _ExecutionPolicy>
126struct __destroy_n;
127// template <class _Policy, class _ForwardIterator, class _Size>
128// optional<_ForwardIterator>
129// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
130
131template <class _Backend, class _ExecutionPolicy>
132struct __equal;
133// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
134// optional<bool>
135// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
136// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
137// _Predicate __pred) const noexcept;
138
139template <class _Backend, class _ExecutionPolicy>
140struct __equal_3leg;
141// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
142// optional<bool>
143// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
144// _ForwardIterator2 __first2,
145// _Predicate __pred) const noexcept;
146
147template <class _Backend, class _ExecutionPolicy>
148struct __fill;
149// template <class _Policy, class _ForwardIterator, class _Tp>
150// optional<__empty>
151// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
152
153template <class _Backend, class _ExecutionPolicy>
154struct __fill_n;
155// template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
156// optional<_ForwardIterator>
157// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Tp const& __value) const noexcept;
158
159template <class _Backend, class _ExecutionPolicy>
160struct __find;
161// template <class _Policy, class _ForwardIterator, class _Tp>
162// optional<_ForwardIterator>
163// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept;
164
165template <class _Backend, class _ExecutionPolicy>
166struct __find_end;
167// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
168// optional<_ForwardIterator1>
169// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
170// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred) const noexcept;
171
172template <class _Backend, class _ExecutionPolicy>
173struct __find_first_of;
174// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
175// optional<_ForwardIterator1>
176// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
177// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred) const noexcept;
178
179template <class _Backend, class _ExecutionPolicy>
180struct __find_if;
181// template <class _Policy, class _ForwardIterator, class _Predicate>
182// optional<_ForwardIterator>
183// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
184
185template <class _Backend, class _ExecutionPolicy>
186struct __find_if_not;
187// template <class _Policy, class _ForwardIterator, class _Predicate>
188// optional<_ForwardIterator>
189// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
190
191template <class _Backend, class _ExecutionPolicy>
192struct __for_each;
193// template <class _Policy, class _ForwardIterator, class _Function>
194// optional<__empty>
195// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __func) const noexcept;
196
197template <class _Backend, class _ExecutionPolicy>
198struct __for_each_n;
199// template <class _Policy, class _ForwardIterator, class _Size, class _Function>
200// optional<_ForwardIterator>
201// operator()(_Policy&&, _ForwardIterator __first, _Size __size, _Function __func) const noexcept;
202
203template <class _Backend, class _ExecutionPolicy>
204struct __generate;
205// template <class _Policy, class _ForwardIterator, class _Generator>
206// optional<__empty>
207// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) const noexcept;
208
209template <class _Backend, class _ExecutionPolicy>
210struct __generate_n;
211// template <class _Policy, class _ForwardIterator, class _Size, class _Generator>
212// optional<_ForwardIterator>
213// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Generator __gen) const noexcept;
214
215template <class _Backend, class _ExecutionPolicy>
216struct __includes;
217// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
218// optional<bool>
219// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
220// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
221// _Compare __comp) const noexcept;
222
223template <class _Backend, class _ExecutionPolicy>
224struct __inclusive_scan;
225// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
226// class _BinaryOperation>
227// optional<_ForwardIterator2>
228// operator()(_Policy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
229// _ForwardIterator2 __result,
230// _BinaryOperation __reduce) const noexcept;
231
232template <class _Backend, class _ExecutionPolicy>
233struct __inclusive_scan_init;
234// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
235// class _BinaryOperation, class _Tp>
236// optional<_ForwardIterator2>
237// operator()(_Policy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
238// _ForwardIterator2 __result,
239// _BinaryOperation __reduce,
240// _Tp __value) const noexcept;
241
242template <class _Backend, class _ExecutionPolicy>
243struct __is_heap;
244// template <class _Policy, class _RandomAccessIterator, class _Comp>
245// optional<bool>
246// operator()(_Policy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last,
247// _Comp __comp) const noexcept;
248
249template <class _Backend, class _ExecutionPolicy>
250struct __is_heap_until;
251// template <class _Policy, class _RandomAccessIterator, class _Comp>
252// optional<_RandomAccessIterator>
253// operator()(_Policy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last,
254// _Comp __comp) const noexcept;
255
256template <class _Backend, class _ExecutionPolicy>
257struct __is_partitioned;
258// template <class _Policy, class _ForwardIterator, class _Predicate>
259// optional<bool>
260// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
261
262template <class _Backend, class _ExecutionPolicy>
263struct __is_sorted;
264// template <class _Policy, class _ForwardIterator, class _Comp>
265// optional<bool>
266// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp&& __comp) const noexcept;
267
268template <class _Backend, class _ExecutionPolicy>
269struct __is_sorted_until;
270// template <class _Policy, class _ForwardIterator, class _Comp>
271// optional<_ForwardIterator>
272// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Comp&& __comp) const noexcept;
273
274template <class _Backend, class _ExecutionPolicy>
275struct __lexicographical_compare;
276// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Comp>
277// optional<bool>
278// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
279// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Comp __comp) const noexcept;
280
281template <class _Backend, class _ExecutionPolicy>
282struct __max_element;
283// template <class _Policy, class _ForwardIterator, class _Compare>
284// optional<_ForwardIterator>
285// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) const noexcept;
286
287template <class _Backend, class _ExecutionPolicy>
288struct __merge;
289// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Comp>
290// optional<_ForwardOutIterator>
291// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
292// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
293// _ForwardOutIterator __result, _Comp __comp) const noexcept;
294
295template <class _Backend, class _ExecutionPolicy>
296struct __min_element;
297// template <class _Policy, class _ForwardIterator, class _Compare>
298// optional<_ForwardIterator>
299// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) const noexcept;
300
301template <class _Backend, class _ExecutionPolicy>
302struct __minmax_element;
303// template <class _Policy, class _ForwardIterator, class _Compare>
304// optional<pair<_ForwardIterator, _ForwardIterator>>
305// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) const noexcept;
306
307template <class _Backend, class _ExecutionPolicy>
308struct __mismatch;
309// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Comp>
310// optional<pair<_ForwardIterator1, _ForwardIterator2>>
311// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
312// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
313// _Comp __comp) const noexcept;
314
315template <class _Backend, class _ExecutionPolicy>
316struct __mismatch_3leg;
317// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Comp>
318// optional<pair<_ForwardIterator1, _ForwardIterator2>>
319// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
320// _ForwardIterator2 __first2, _Comp __comp) const noexcept;
321
322template <class _Backend, class _ExecutionPolicy>
323struct __move;
324// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
325// optional<_ForwardOutIterator>
326// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
327// _ForwardOutIterator __out_it) const noexcept;
328
329template <class _Backend, class _ExecutionPolicy>
330struct __none_of;
331// template <class _Policy, class _ForwardIterator, class _Predicate>
332// optional<bool>
333// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
334
335template <class _Backend, class _ExecutionPolicy>
336struct __partition;
337// template <class _Policy, class _ForwardIterator, class _Predicate>
338// optional<_ForwardIterator>
339// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
340
341template <class _Backend, class _ExecutionPolicy>
342struct __partition_copy;
343// template <class _Policy, class _ForwardIterator,
344// class _ForwardOutIterator1, class _ForwardOutIterator2, class _Predicate>
345// optional<pair<_ForwardOutIterator1, _ForwardOutIterator2>>
346// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last,
347// _ForwardOutIterator1 __out_true, _ForwardOutIterator2 __out_false,
348// _Predicate __pred) const noexcept;
349
350template <class _Backend, class _ExecutionPolicy>
351struct __reduce;
352// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation>
353// optional<_Tp>
354// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
355// _Tp __init, _BinaryOperation __op) const noexcept;
356
357template <class _Backend, class _ExecutionPolicy>
358struct __replace;
359// template <class _Policy, class _ForwardIterator, class _Tp>
360// optional<__empty>
361// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
362// _Tp const& __old, _Tp const& __new) const noexcept;
363
364template <class _Backend, class _ExecutionPolicy>
365struct __replace_copy;
366// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Tp>
367// optional<__empty>
368// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
369// _ForwardOutIterator __out_it,
370// _Tp const& __old_value,
371// _Tp const& __new_value) const noexcept;
372
373template <class _Backend, class _ExecutionPolicy>
374struct __replace_copy_if;
375// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Predicate, class _Tp>
376// optional<__empty>
377// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
378// _ForwardOutIterator __out_it,
379// _Predicate __pred,
380// _Tp const& __new_value) const noexcept;
381
382template <class _Backend, class _ExecutionPolicy>
383struct __replace_if;
384// template <class _Policy, class _ForwardIterator, class _Predicate, class _Tp>
385// optional<__empty>
386// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
387// _Predicate __pred, _Tp const& __new_value) const noexcept;
388
389template <class _Backend, class _ExecutionPolicy>
390struct __reverse;
391// template <class _Policy, class _BidirectionalIterator>
392// optional<__empty>
393// operator()(_Policy&&, _BidirectionalIterator __first, _BidirectionalIterator __last) const noexcept;
394
395template <class _Backend, class _ExecutionPolicy>
396struct __reverse_copy;
397// template <class _Policy, class _BidirectionalIterator, class _ForwardIterator>
398// optional<_ForwardIterator>
399// operator()(_Policy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
400// _ForwardIterator __result) const noexcept;
401
402template <class _Backend, class _ExecutionPolicy>
403struct __rotate_copy;
404// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
405// optional<_ForwardOutIterator>
406// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
407// _ForwardOutIterator __out_it) const noexcept;
408
409template <class _Backend, class _ExecutionPolicy>
410struct __search;
411// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
412// optional<_ForwardIterator1>
413// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
414// _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred) const noexcept;
415
416template <class _Backend, class _ExecutionPolicy>
417struct __search_n;
418// template <class _Policy, class _ForwardIterator, class _Size, class _T, class _Predicate>
419// optional<_ForwardIterator>
420// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
421// _Size __count, const _T& __value, _Predicate __pred) const noexcept;
422
423template <class _Backend, class _ExecutionPolicy>
424struct __set_difference;
425// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Compare>
426// optional<_ForwardOutIterator>
427// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
428// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
429// _ForwardOutIterator __result,
430// _Compare __comp) const noexcept;
431
432template <class _Backend, class _ExecutionPolicy>
433struct __set_intersection;
434// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Compare>
435// optional<_ForwardOutIterator>
436// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
437// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
438// _ForwardOutIterator __result,
439// _Compare __comp) const noexcept;
440
441template <class _Backend, class _ExecutionPolicy>
442struct __set_symmetric_difference;
443// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Compare>
444// optional<_ForwardOutIterator>
445// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
446// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
447// _ForwardOutIterator __result,
448// _Compare __comp) const noexcept;
449
450template <class _Backend, class _ExecutionPolicy>
451struct __set_union;
452// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Compare>
453// optional<_ForwardOutIterator>
454// operator()(_Policy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
455// _ForwardIterator2 __first2, _ForwardIterator2 __last2,
456// _ForwardOutIterator __result,
457// _Compare __comp) const noexcept;
458
459template <class _Backend, class _ExecutionPolicy>
460struct __sort;
461// template <class _Policy, class _RandomAccessIterator, class _Comp>
462// optional<__empty>
463// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
464
465template <class _Backend, class _ExecutionPolicy>
466struct __stable_partition;
467// template <class _Policy, class _BidirectionalIterator, class _Predicate>
468// optional<_BidirectionalIterator>
469// operator()(_Policy&& __policy, _BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred)
470// const noexcept;
471
472template <class _Backend, class _ExecutionPolicy>
473struct __stable_sort;
474// template <class _Policy, class _RandomAccessIterator, class _Comp>
475// optional<__empty>
476// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
477
478template <class _Backend, class _ExecutionPolicy>
479struct __swap_ranges;
480// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2>
481// optional<_ForwardIterator2>
482// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
483// _ForwardIterator2 __first2) const noexcept;
484
485template <class _Backend, class _ExecutionPolicy>
486struct __transform;
487// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
488// optional<_ForwardOutIterator>
489// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
490// _ForwardOutIterator __result,
491// _UnaryOperation __op) const noexcept;
492
493template <class _Backend, class _ExecutionPolicy>
494struct __transform_binary;
495// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
496// class _ForwardOutIterator,
497// class _BinaryOperation>
498// optional<_ForwardOutIterator>
499// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
500// _ForwardIterator2 __first2,
501// _ForwardOutIterator __result,
502// _BinaryOperation __op) const noexcept;
503
504template <class _Backend, class _ExecutionPolicy>
505struct __transform_inclusive_scan;
506// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
507// class _BinaryOperation, class _UnaryOperation>
508// optional<_ForwardIterator2>
509// operator()(_Policy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
510// _ForwardIterator2 __result,
511// _BinaryOperation __reduce,
512// _UnaryOperation __transform) const noexcept;
513
514template <class _Backend, class _ExecutionPolicy>
515struct __transform_inclusive_scan_init;
516// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
517// class _BinaryOperation, class _UnaryOperation, class _Tp>
518// optional<_ForwardIterator2>
519// operator()(_Policy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
520// _ForwardIterator2 __result,
521// _BinaryOperation __reduce,
522// _UnaryOperation __transform,
523// _Tp __init) const noexcept;
524
525template <class _Backend, class _ExecutionPolicy>
526struct __transform_reduce;
527// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
528// optional<_Tp>
529// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
530// _Tp __init,
531// _BinaryOperation __reduce,
532// _UnaryOperation __transform) const noexcept;
533
534template <class _Backend, class _ExecutionPolicy>
535struct __transform_reduce_binary;
536// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
537// class _Tp, class _BinaryOperation1, class _BinaryOperation2>
538// optional<_Tp> operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
539// _ForwardIterator2 __first2,
540// _Tp __init,
541// _BinaryOperation1 __reduce,
542// _BinaryOperation2 __transform) const noexcept;
543
544template <class _Backend, class _ExecutionPolicy>
545struct __uninitialized_copy;
546// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2>
547// optional<_ForwardIterator2>
548// operator()(_Policy&& __policy, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) const
549// noexcept;
550
551template <class _Backend, class _ExecutionPolicy>
552struct __uninitialized_copy_n;
553// template <class _Policy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
554// optional<_ForwardIterator2>
555// operator()(_Policy&& __policy, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result) const
556// noexcept;
557
558template <class _Backend, class _ExecutionPolicy>
559struct __uninitialized_default_construct;
560// template <class _Policy, class _ForwardIterator>
561// optional<__empty>
562// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last) const noexcept;
563
564template <class _Backend, class _ExecutionPolicy>
565struct __uninitialized_default_construct_n;
566// template <class _Policy, class _ForwardIterator, class _Size>
567// optional<_ForwardIterator>
568// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
569
570template <class _Backend, class _ExecutionPolicy>
571struct __uninitialized_fill;
572// template <class _Policy, class _ForwardIterator, class _Tp>
573// optional<__empty>
574// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp &__value) const noexcept;
575
576template <class _Backend, class _ExecutionPolicy>
577struct __uninitialized_fill_n;
578// template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
579// optional<_ForwardIterator>
580// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, const _Tp &__value) const noexcept;
581
582template <class _Backend, class _ExecutionPolicy>
583struct __uninitialized_move;
584// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2>
585// optional<_ForwardIterator2>
586// operator()(_Policy&& __policy, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) const
587// noexcept;
588
589template <class _Backend, class _ExecutionPolicy>
590struct __uninitialized_move_n;
591// template <class _Policy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
592// optional<pair<_ForwardIterator1, _ForwardIterator2>>
593// operator()(_Policy&& __policy, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result) const
594// noexcept;
595
596template <class _Backend, class _ExecutionPolicy>
597struct __uninitialized_value_construct;
598// template <class _Policy, class _ForwardIterator>
599// optional<__empty>
600// operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last) const noexcept;
601
602template <class _Backend, class _ExecutionPolicy>
603struct __uninitialized_value_construct_n;
604// template <class _Policy, class _ForwardIterator, class _Size>
605// optional<_ForwardIterator>
606// operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n) const noexcept;
607
608} // namespace __pstl
609_LIBCPP_END_NAMESPACE_STD
610
611#endif // _LIBCPP_STD_VER >= 17
612
613_LIBCPP_POP_MACROS
614
615#endif // _LIBCPP___PSTL_BACKEND_FWD_H
616