ViewVC Help
View File | Revision Log | View Changeset | Root Listing
root/Oni2/Daodan/MSYS2/mingw32/include/c++/11.2.0/pstl/algorithm_fwd.h
Revision: 1166
Committed: Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type: text/x-chdr
File size: 68340 byte(s)
Log Message: 
Daodan: Replace MinGW build env with an up-to-date MSYS2 env

File Contents

# Content
1 // -*- C++ -*-
2 //===-- algorithm_fwd.h --------------------------------------------------===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9
10 #ifndef _PSTL_ALGORITHM_FWD_H
11 #define _PSTL_ALGORITHM_FWD_H
12
13 #include <type_traits>
14 #include <utility>
15
16 namespace __pstl
17 {
18 namespace __internal
19 {
20
21 //------------------------------------------------------------------------
22 // any_of
23 //------------------------------------------------------------------------
24
25 template <class _ForwardIterator, class _Pred>
26 bool
27 __brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
28 /*__is_vector=*/std::false_type) noexcept;
29
30 template <class _ForwardIterator, class _Pred>
31 bool
32 __brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
33 /*__is_vector=*/std::true_type) noexcept;
34
35 template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
36 bool
37 __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
38 /*parallel=*/std::false_type) noexcept;
39
40 template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
41 bool
42 __pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
43 /*parallel=*/std::true_type);
44
45 //------------------------------------------------------------------------
46 // walk1 (pseudo)
47 //
48 // walk1 evaluates f(x) for each dereferenced value x drawn from [first,last)
49 //------------------------------------------------------------------------
50
51 template <class _ForwardIterator, class _Function>
52 void __brick_walk1(_ForwardIterator, _ForwardIterator, _Function,
53 /*vector=*/std::false_type) noexcept;
54
55 template <class _RandomAccessIterator, class _Function>
56 void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
57 /*vector=*/std::true_type) noexcept;
58
59 template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
60 void
61 __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
62 /*parallel=*/std::false_type) noexcept;
63
64 template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
65 void
66 __pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
67 /*parallel=*/std::true_type);
68
69 template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
70 void
71 __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
72 /*parallel=*/std::false_type) noexcept;
73
74 template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
75 void
76 __pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
77 /*parallel=*/std::true_type);
78
79 //------------------------------------------------------------------------
80 // walk1_n
81 //------------------------------------------------------------------------
82
83 template <class _ForwardIterator, class _Size, class _Function>
84 _ForwardIterator __brick_walk1_n(_ForwardIterator, _Size, _Function,
85 /*_IsVectorTag=*/std::false_type);
86
87 template <class _RandomAccessIterator, class _DifferenceType, class _Function>
88 _RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
89 /*vectorTag=*/std::true_type) noexcept;
90
91 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
92 _ForwardIterator
93 __pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector,
94 /*is_parallel=*/std::false_type) noexcept;
95
96 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
97 _RandomAccessIterator
98 __pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector,
99 /*is_parallel=*/std::true_type);
100
101 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
102 _ForwardIterator
103 __pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick,
104 /*is_parallel=*/std::false_type) noexcept;
105
106 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
107 _RandomAccessIterator
108 __pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick,
109 /*is_parallel=*/std::true_type);
110
111 //------------------------------------------------------------------------
112 // walk2 (pseudo)
113 //
114 // walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...)
115 //------------------------------------------------------------------------
116
117 template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
118 _ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
119 /*vector=*/std::false_type) noexcept;
120
121 template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
122 _ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
123 /*vector=*/std::true_type) noexcept;
124
125 template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
126 _ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
127 /*vector=*/std::false_type) noexcept;
128
129 template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
130 _ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
131 /*vector=*/std::true_type) noexcept;
132
133 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
134 _ForwardIterator2
135 __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
136 /*parallel=*/std::false_type) noexcept;
137
138 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
139 _ForwardIterator2
140 __pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
141 /*parallel=*/std::true_type);
142
143 template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
144 class _IsVector>
145 _ForwardIterator2
146 __pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
147 /*parallel=*/std::false_type) noexcept;
148
149 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2,
150 class _Function, class _IsVector>
151 _RandomAccessIterator2
152 __pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
153 /*parallel=*/std::true_type);
154
155 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
156 _ForwardIterator2
157 __pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
158 /*parallel=*/std::false_type) noexcept;
159
160 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
161 _RandomAccessIterator2
162 __pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
163 _Brick,
164 /*parallel=*/std::true_type);
165
166 template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
167 _ForwardIterator2
168 __pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick,
169 /*parallel=*/std::false_type) noexcept;
170
171 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
172 _RandomAccessIterator2
173 __pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick,
174 /*parallel=*/std::true_type);
175
176 //------------------------------------------------------------------------
177 // walk3 (pseudo)
178 //
179 // walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
180 //------------------------------------------------------------------------
181
182 template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
183 _ForwardIterator3 __brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
184 /*vector=*/std::false_type) noexcept;
185
186 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
187 _RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
188 _RandomAccessIterator3, _Function,
189 /*vector=*/std::true_type) noexcept;
190
191 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
192 class _Function, class _IsVector>
193 _ForwardIterator3
194 __pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3,
195 _Function, _IsVector,
196 /*parallel=*/std::false_type) noexcept;
197
198 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
199 class _RandomAccessIterator3, class _Function, class _IsVector>
200 _RandomAccessIterator3
201 __pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
202 _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
203
204 //------------------------------------------------------------------------
205 // equal
206 //------------------------------------------------------------------------
207
208 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
209 bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
210 /* is_vector = */ std::false_type) noexcept;
211
212 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
213 bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
214 /* is_vector = */ std::true_type) noexcept;
215
216 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
217 class _IsVector>
218 bool
219 __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
220 _IsVector, /* is_parallel = */ std::false_type) noexcept;
221
222 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
223 class _IsVector>
224 bool
225 __pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
226 _BinaryPredicate, _IsVector, /* is_parallel = */ std::true_type);
227
228 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
229 bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate,
230 /* is_vector = */ std::false_type) noexcept;
231
232 template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
233 bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
234 _BinaryPredicate, /* is_vector = */ std::true_type) noexcept;
235
236 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
237 class _IsVector>
238 bool
239 __pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
240 _BinaryPredicate, _IsVector, /* is_parallel = */ std::false_type) noexcept;
241
242 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
243 class _IsVector>
244 bool
245 __pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
246 _RandomAccessIterator2, _BinaryPredicate, _IsVector, /* is_parallel = */ std::true_type);
247
248 //------------------------------------------------------------------------
249 // find_if
250 //------------------------------------------------------------------------
251
252 template <class _ForwardIterator, class _Predicate>
253 _ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
254 /*is_vector=*/std::false_type) noexcept;
255
256 template <class _RandomAccessIterator, class _Predicate>
257 _RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
258 /*is_vector=*/std::true_type) noexcept;
259
260 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
261 _ForwardIterator
262 __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
263 /*is_parallel=*/std::false_type) noexcept;
264
265 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
266 _ForwardIterator
267 __pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
268 /*is_parallel=*/std::true_type);
269
270 //------------------------------------------------------------------------
271 // find_end
272 //------------------------------------------------------------------------
273
274 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
275 _ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
276 _BinaryPredicate,
277 /*__is_vector=*/std::false_type) noexcept;
278
279 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
280 _ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
281 _BinaryPredicate,
282 /*__is_vector=*/std::true_type) noexcept;
283
284 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
285 class _IsVector>
286 _ForwardIterator1
287 __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
288 _BinaryPredicate, _IsVector,
289 /*is_parallel=*/std::false_type) noexcept;
290
291 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
292 class _IsVector>
293 _ForwardIterator1
294 __pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
295 _BinaryPredicate, _IsVector,
296 /*is_parallel=*/std::true_type) noexcept;
297
298 //------------------------------------------------------------------------
299 // find_first_of
300 //------------------------------------------------------------------------
301
302 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
303 _ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
304 _BinaryPredicate,
305 /*__is_vector=*/std::false_type) noexcept;
306
307 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
308 _ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
309 _BinaryPredicate,
310 /*__is_vector=*/std::true_type) noexcept;
311
312 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
313 class _IsVector>
314 _ForwardIterator1
315 __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
316 _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
317
318 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
319 class _IsVector>
320 _ForwardIterator1
321 __pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
322 _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
323
324 //------------------------------------------------------------------------
325 // search
326 //------------------------------------------------------------------------
327
328 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
329 _ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
330 _BinaryPredicate,
331 /*vector=*/std::false_type) noexcept;
332
333 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
334 _ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
335 _BinaryPredicate,
336 /*vector=*/std::true_type) noexcept;
337
338 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
339 class _IsVector>
340 _ForwardIterator1
341 __pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
342 _BinaryPredicate, _IsVector,
343 /*is_parallel=*/std::false_type) noexcept;
344
345 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
346 class _IsVector>
347 _ForwardIterator1
348 __pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
349 _BinaryPredicate, _IsVector,
350 /*is_parallel=*/std::true_type) noexcept;
351
352 //------------------------------------------------------------------------
353 // search_n
354 //------------------------------------------------------------------------
355
356 template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
357 _ForwardIterator
358 __brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
359 /*vector=*/std::false_type) noexcept;
360
361 template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
362 _ForwardIterator
363 __brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
364 /*vector=*/std::true_type) noexcept;
365
366 template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate,
367 class IsVector>
368 _ForwardIterator
369 __pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
370 IsVector,
371 /*is_parallel=*/std::false_type) noexcept;
372
373 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate,
374 class IsVector>
375 _RandomAccessIterator
376 __pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&,
377 _BinaryPredicate, IsVector,
378 /*is_parallel=*/std::true_type) noexcept;
379
380 //------------------------------------------------------------------------
381 // copy_n
382 //------------------------------------------------------------------------
383
384 template <class _ForwardIterator, class _Size, class _OutputIterator>
385 _OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
386 /*vector=*/std::false_type) noexcept;
387
388 template <class _ForwardIterator, class _Size, class _OutputIterator>
389 _OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
390 /*vector=*/std::true_type) noexcept;
391
392 //------------------------------------------------------------------------
393 // copy
394 //------------------------------------------------------------------------
395
396 template <class _ForwardIterator, class _OutputIterator>
397 _OutputIterator __brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator,
398 /*vector=*/std::false_type) noexcept;
399
400 template <class _RandomAccessIterator, class _OutputIterator>
401 _OutputIterator __brick_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
402 /*vector=*/std::true_type) noexcept;
403
404 //------------------------------------------------------------------------
405 // move
406 //------------------------------------------------------------------------
407
408 template <class _ForwardIterator, class _OutputIterator>
409 _OutputIterator __brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator,
410 /*vector=*/std::false_type) noexcept;
411
412 template <class _RandomAccessIterator, class _OutputIterator>
413 _OutputIterator __brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
414 /*vector=*/std::true_type) noexcept;
415
416 //------------------------------------------------------------------------
417 // swap_ranges
418 //------------------------------------------------------------------------
419 template <class _ForwardIterator, class _OutputIterator>
420 _OutputIterator
421 __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
422 /*vector=*/std::false_type) noexcept;
423
424 template <class _ForwardIterator, class _OutputIterator>
425 _OutputIterator
426 __brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
427 /*vector=*/std::true_type) noexcept;
428
429 //------------------------------------------------------------------------
430 // copy_if
431 //------------------------------------------------------------------------
432
433 template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
434 _OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
435 /*vector=*/std::false_type) noexcept;
436
437 template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
438 _OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
439 /*vector=*/std::true_type) noexcept;
440
441 template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
442 std::pair<_DifferenceType, _DifferenceType>
443 __brick_calc_mask_1(_ForwardIterator, _ForwardIterator, bool* __restrict, _UnaryPredicate,
444 /*vector=*/std::false_type) noexcept;
445 template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
446 std::pair<_DifferenceType, _DifferenceType>
447 __brick_calc_mask_1(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _UnaryPredicate,
448 /*vector=*/std::true_type) noexcept;
449
450 template <class _ForwardIterator, class _OutputIterator>
451 void
452 __brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*,
453 /*vector=*/std::false_type) noexcept;
454
455 template <class _ForwardIterator, class _OutputIterator>
456 void
457 __brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict,
458 /*vector=*/std::true_type) noexcept;
459
460 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
461 void
462 __brick_partition_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, bool*,
463 /*vector=*/std::false_type) noexcept;
464
465 template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
466 void
467 __brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
468 /*vector=*/std::true_type) noexcept;
469
470 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
471 _OutputIterator
472 __pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
473 /*parallel=*/std::false_type) noexcept;
474
475 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate,
476 class _IsVector>
477 _OutputIterator
478 __pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
479 _IsVector, /*parallel=*/std::true_type);
480
481 //------------------------------------------------------------------------
482 // count
483 //------------------------------------------------------------------------
484
485 template <class _ForwardIterator, class _Predicate>
486 typename std::iterator_traits<_ForwardIterator>::difference_type
487 __brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
488 /* is_vector = */ std::true_type) noexcept;
489
490 template <class _ForwardIterator, class _Predicate>
491 typename std::iterator_traits<_ForwardIterator>::difference_type
492 __brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
493 /* is_vector = */ std::false_type) noexcept;
494
495 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
496 typename std::iterator_traits<_ForwardIterator>::difference_type
497 __pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
498 /* is_parallel */ std::false_type, _IsVector) noexcept;
499
500 template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
501 typename std::iterator_traits<_ForwardIterator>::difference_type
502 __pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
503 /* is_parallel */ std::true_type, _IsVector);
504
505 //------------------------------------------------------------------------
506 // unique
507 //------------------------------------------------------------------------
508
509 template <class _ForwardIterator, class _BinaryPredicate>
510 _ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
511 /*is_vector=*/std::false_type) noexcept;
512
513 template <class _ForwardIterator, class _BinaryPredicate>
514 _ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
515 /*is_vector=*/std::true_type) noexcept;
516
517 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
518 _ForwardIterator
519 __pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
520 /*is_parallel=*/std::false_type) noexcept;
521
522 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
523 _ForwardIterator
524 __pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
525 /*is_parallel=*/std::true_type) noexcept;
526
527 //------------------------------------------------------------------------
528 // unique_copy
529 //------------------------------------------------------------------------
530
531 template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
532 OutputIterator __brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate,
533 /*vector=*/std::false_type) noexcept;
534
535 template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate>
536 _OutputIterator __brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
537 /*vector=*/std::true_type) noexcept;
538
539 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate,
540 class _IsVector>
541 _OutputIterator
542 __pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryPredicate,
543 _IsVector, /*parallel=*/std::false_type) noexcept;
544
545 template <class _ExecutionPolicy, class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
546 _DifferenceType
547 __brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
548 /*vector=*/std::false_type) noexcept;
549
550 template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
551 _DifferenceType
552 __brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
553 /*vector=*/std::true_type) noexcept;
554
555 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
556 class _IsVector>
557 _OutputIterator
558 __pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
559 _BinaryPredicate, _IsVector, /*parallel=*/std::true_type);
560
561 //------------------------------------------------------------------------
562 // reverse
563 //------------------------------------------------------------------------
564
565 template <class _BidirectionalIterator>
566 void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
567 /*__is_vector=*/std::false_type) noexcept;
568
569 template <class _BidirectionalIterator>
570 void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
571 /*__is_vector=*/std::true_type) noexcept;
572
573 template <class _BidirectionalIterator>
574 void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
575 /*is_vector=*/std::false_type) noexcept;
576
577 template <class _BidirectionalIterator>
578 void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
579 /*is_vector=*/std::true_type) noexcept;
580
581 template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
582 void
583 __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
584 /*is_parallel=*/std::false_type) noexcept;
585
586 template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
587 void
588 __pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
589 /*is_parallel=*/std::true_type);
590
591 //------------------------------------------------------------------------
592 // reverse_copy
593 //------------------------------------------------------------------------
594
595 template <class _BidirectionalIterator, class _OutputIterator>
596 _OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
597 /*is_vector=*/std::false_type) noexcept;
598
599 template <class _BidirectionalIterator, class _OutputIterator>
600 _OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
601 /*is_vector=*/std::true_type) noexcept;
602
603 template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
604 _OutputIterator
605 __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
606 /*is_parallel=*/std::false_type) noexcept;
607
608 template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
609 _OutputIterator
610 __pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
611 /*is_parallel=*/std::true_type);
612
613 //------------------------------------------------------------------------
614 // rotate
615 //------------------------------------------------------------------------
616
617 template <class _ForwardIterator>
618 _ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
619 /*is_vector=*/std::false_type) noexcept;
620
621 template <class _ForwardIterator>
622 _ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
623 /*is_vector=*/std::true_type) noexcept;
624
625 template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
626 _ForwardIterator
627 __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
628 /*is_parallel=*/std::false_type) noexcept;
629
630 template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
631 _ForwardIterator
632 __pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
633 /*is_parallel=*/std::true_type);
634
635 //------------------------------------------------------------------------
636 // rotate_copy
637 //------------------------------------------------------------------------
638
639 template <class _ForwardIterator, class _OutputIterator>
640 _OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
641 /*__is_vector=*/std::false_type) noexcept;
642
643 template <class _ForwardIterator, class _OutputIterator>
644 _OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
645 /*__is_vector=*/std::true_type) noexcept;
646
647 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
648 _OutputIterator
649 __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
650 _IsVector,
651 /*is_parallel=*/std::false_type) noexcept;
652
653 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
654 _OutputIterator
655 __pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
656 _IsVector,
657 /*is_parallel=*/std::true_type);
658
659 //------------------------------------------------------------------------
660 // is_partitioned
661 //------------------------------------------------------------------------
662
663 template <class _ForwardIterator, class _UnaryPredicate>
664 bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
665 /*is_vector=*/std::false_type) noexcept;
666
667 template <class _ForwardIterator, class _UnaryPredicate>
668 bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
669 /*is_vector=*/std::true_type) noexcept;
670
671 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
672 bool
673 __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
674 /*is_parallel=*/std::false_type) noexcept;
675
676 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
677 bool
678 __pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
679 /*is_parallel=*/std::true_type);
680
681 //------------------------------------------------------------------------
682 // partition
683 //------------------------------------------------------------------------
684
685 template <class _ForwardIterator, class _UnaryPredicate>
686 _ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
687 /*is_vector=*/std::false_type) noexcept;
688
689 template <class _ForwardIterator, class _UnaryPredicate>
690 _ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
691 /*is_vector=*/std::true_type) noexcept;
692
693 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
694 _ForwardIterator
695 __pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
696 /*is_parallel=*/std::false_type) noexcept;
697
698 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
699 _ForwardIterator
700 __pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
701 /*is_parallel=*/std::true_type);
702
703 //------------------------------------------------------------------------
704 // stable_partition
705 //------------------------------------------------------------------------
706
707 template <class _BidirectionalIterator, class _UnaryPredicate>
708 _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
709 /*__is_vector=*/std::false_type) noexcept;
710
711 template <class _BidirectionalIterator, class _UnaryPredicate>
712 _BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
713 /*__is_vector=*/std::true_type) noexcept;
714
715 template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
716 _BidirectionalIterator
717 __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
718 _IsVector,
719 /*is_parallelization=*/std::false_type) noexcept;
720
721 template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
722 _BidirectionalIterator
723 __pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
724 _IsVector,
725 /*is_parallelization=*/std::true_type) noexcept;
726
727 //------------------------------------------------------------------------
728 // partition_copy
729 //------------------------------------------------------------------------
730
731 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
732 std::pair<_OutputIterator1, _OutputIterator2>
733 __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate,
734 /*is_vector=*/std::false_type) noexcept;
735
736 template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
737 std::pair<_OutputIterator1, _OutputIterator2>
738 __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate,
739 /*is_vector=*/std::true_type) noexcept;
740
741 template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
742 class _UnaryPredicate, class _IsVector>
743 std::pair<_OutputIterator1, _OutputIterator2>
744 __pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2,
745 _UnaryPredicate, _IsVector,
746 /*is_parallelization=*/std::false_type) noexcept;
747
748 template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2,
749 class _UnaryPredicate, class _IsVector>
750 std::pair<_OutputIterator1, _OutputIterator2>
751 __pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1,
752 _OutputIterator2, _UnaryPredicate, _IsVector,
753 /*is_parallelization=*/std::true_type);
754
755 //------------------------------------------------------------------------
756 // sort
757 //------------------------------------------------------------------------
758
759 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector,
760 class _IsMoveConstructible>
761 void
762 __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
763 /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
764
765 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
766 void
767 __pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
768 /*is_parallel=*/std::true_type,
769 /*is_move_constructible=*/std::true_type);
770
771 //------------------------------------------------------------------------
772 // stable_sort
773 //------------------------------------------------------------------------
774
775 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
776 void
777 __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
778 _IsVector /*is_vector*/,
779 /*is_parallel=*/std::false_type) noexcept;
780
781 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
782 void
783 __pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
784 _IsVector /*is_vector*/,
785 /*is_parallel=*/std::true_type);
786
787 //------------------------------------------------------------------------
788 // partial_sort
789 //------------------------------------------------------------------------
790
791 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
792 void
793 __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
794 _Compare, _IsVector,
795 /*is_parallel=*/std::false_type) noexcept;
796
797 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
798 void
799 __pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
800 _Compare, _IsVector,
801 /*is_parallel=*/std::true_type);
802
803 //------------------------------------------------------------------------
804 // partial_sort_copy
805 //------------------------------------------------------------------------
806
807 template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
808 _RandomAccessIterator
809 __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
810 _RandomAccessIterator, _Compare, _IsVector,
811 /*is_parallel=*/std::false_type) noexcept;
812
813 template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
814 _RandomAccessIterator
815 __pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
816 _RandomAccessIterator, _Compare, _IsVector,
817 /*is_parallel=*/std::true_type);
818
819 //------------------------------------------------------------------------
820 // adjacent_find
821 //------------------------------------------------------------------------
822
823 template <class _ForwardIterator, class _BinaryPredicate>
824 _ForwardIterator
825 __brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
826 /* IsVector = */ std::true_type, bool) noexcept;
827
828 template <class _ForwardIterator, class _BinaryPredicate>
829 _ForwardIterator
830 __brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
831 /* IsVector = */ std::false_type, bool) noexcept;
832
833 template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
834 _ForwardIterator
835 __pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate,
836 /* is_parallel */ std::false_type, _IsVector, bool) noexcept;
837
838 template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
839 _RandomAccessIterator
840 __pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
841 /* is_parallel */ std::true_type, _IsVector, bool);
842
843 //------------------------------------------------------------------------
844 // nth_element
845 //------------------------------------------------------------------------
846 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
847 void
848 __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
849 _IsVector,
850 /*is_parallel=*/std::false_type) noexcept;
851
852 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
853 void
854 __pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
855 _IsVector,
856 /*is_parallel=*/std::true_type) noexcept;
857
858 //------------------------------------------------------------------------
859 // fill, fill_n
860 //------------------------------------------------------------------------
861 template <class _ForwardIterator, class _Tp>
862 void
863 __brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
864 /* __is_vector = */ std::true_type) noexcept;
865
866 template <class _ForwardIterator, class _Tp>
867 void
868 __brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
869 /* __is_vector = */ std::false_type) noexcept;
870
871 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
872 void
873 __pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
874 /*is_parallel=*/std::false_type, _IsVector) noexcept;
875
876 template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
877 _ForwardIterator
878 __pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
879 /*is_parallel=*/std::true_type, _IsVector);
880
881 template <class _OutputIterator, class _Size, class _Tp>
882 _OutputIterator
883 __brick_fill_n(_OutputIterator, _Size, const _Tp&,
884 /* __is_vector = */ std::true_type) noexcept;
885
886 template <class _OutputIterator, class _Size, class _Tp>
887 _OutputIterator
888 __brick_fill_n(_OutputIterator, _Size, const _Tp&,
889 /* __is_vector = */ std::false_type) noexcept;
890
891 template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
892 _OutputIterator
893 __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
894 /*is_parallel=*/std::false_type, _IsVector) noexcept;
895
896 template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
897 _OutputIterator
898 __pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
899 /*is_parallel=*/std::true_type, _IsVector);
900
901 //------------------------------------------------------------------------
902 // generate, generate_n
903 //------------------------------------------------------------------------
904
905 template <class _RandomAccessIterator, class _Generator>
906 void __brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
907 /* is_vector = */ std::true_type) noexcept;
908
909 template <class _ForwardIterator, class _Generator>
910 void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
911 /* is_vector = */ std::false_type) noexcept;
912
913 template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
914 void
915 __pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
916 /*is_parallel=*/std::false_type, _IsVector) noexcept;
917
918 template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
919 _ForwardIterator
920 __pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
921 /*is_parallel=*/std::true_type, _IsVector);
922
923 template <class OutputIterator, class Size, class _Generator>
924 OutputIterator __brick_generate_n(OutputIterator, Size, _Generator,
925 /* is_vector = */ std::true_type) noexcept;
926
927 template <class OutputIterator, class Size, class _Generator>
928 OutputIterator __brick_generate_n(OutputIterator, Size, _Generator,
929 /* is_vector = */ std::false_type) noexcept;
930
931 template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
932 OutputIterator
933 __pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
934 /*is_parallel=*/std::false_type, _IsVector) noexcept;
935
936 template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
937 OutputIterator
938 __pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
939 /*is_parallel=*/std::true_type, _IsVector);
940
941 //------------------------------------------------------------------------
942 // remove
943 //------------------------------------------------------------------------
944 template <class _ForwardIterator, class _UnaryPredicate>
945 _ForwardIterator __brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
946 /* __is_vector = */ std::false_type) noexcept;
947
948 template <class _RandomAccessIterator, class _UnaryPredicate>
949 _RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
950 /* __is_vector = */ std::true_type) noexcept;
951
952 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
953 _ForwardIterator
954 __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
955 /*is_parallel*/ std::false_type) noexcept;
956
957 template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
958 _ForwardIterator
959 __pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
960 /*is_parallel*/ std::true_type) noexcept;
961
962 //------------------------------------------------------------------------
963 // merge
964 //------------------------------------------------------------------------
965
966 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
967 _OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
968 _OutputIterator, _Compare,
969 /* __is_vector = */ std::false_type) noexcept;
970
971 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
972 _OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
973 _OutputIterator, _Compare,
974 /* __is_vector = */ std::true_type) noexcept;
975
976 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
977 class _Compare, class _IsVector>
978 _OutputIterator
979 __pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
980 _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
981
982 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
983 class _Compare, class _IsVector>
984 _OutputIterator
985 __pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
986 _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
987 /* is_parallel = */ std::true_type);
988
989 //------------------------------------------------------------------------
990 // inplace_merge
991 //------------------------------------------------------------------------
992
993 template <class _BidirectionalIterator, class _Compare>
994 void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
995 /* __is_vector = */ std::false_type) noexcept;
996
997 template <class _BidirectionalIterator, class _Compare>
998 void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
999 /* __is_vector = */ std::true_type) noexcept;
1000
1001 template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
1002 void
1003 __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
1004 _Compare, _IsVector,
1005 /* is_parallel = */ std::false_type) noexcept;
1006
1007 template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
1008 void
1009 __pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
1010 _Compare, _IsVector,
1011 /*is_parallel=*/std::true_type);
1012
1013 //------------------------------------------------------------------------
1014 // includes
1015 //------------------------------------------------------------------------
1016
1017 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
1018 bool
1019 __pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1020 _Compare, _IsVector,
1021 /*is_parallel=*/std::false_type) noexcept;
1022
1023 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
1024 bool
1025 __pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1026 _Compare, _IsVector,
1027 /*is_parallel=*/std::true_type);
1028
1029 //------------------------------------------------------------------------
1030 // set_union
1031 //------------------------------------------------------------------------
1032
1033 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1034 _OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1035 _OutputIterator, _Compare,
1036 /*__is_vector=*/std::false_type) noexcept;
1037
1038 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1039 _OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1040 _OutputIterator, _Compare,
1041 /*__is_vector=*/std::true_type) noexcept;
1042
1043 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1044 class _Compare, class _IsVector>
1045 _OutputIterator
1046 __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1047 _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
1048
1049 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1050 class _Compare, class _IsVector>
1051 _OutputIterator
1052 __pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1053 _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
1054
1055 //------------------------------------------------------------------------
1056 // set_intersection
1057 //------------------------------------------------------------------------
1058
1059 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1060 _OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1061 _OutputIterator, _Compare,
1062 /*__is_vector=*/std::false_type) noexcept;
1063
1064 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1065 _OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1066 _OutputIterator, _Compare,
1067 /*__is_vector=*/std::true_type) noexcept;
1068
1069 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1070 class _Compare, class _IsVector>
1071 _OutputIterator
1072 __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1073 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
1074 /*is_parallel=*/std::false_type) noexcept;
1075
1076 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1077 class _Compare, class _IsVector>
1078 _OutputIterator
1079 __pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1080 _ForwardIterator2, _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
1081
1082 //------------------------------------------------------------------------
1083 // set_difference
1084 //------------------------------------------------------------------------
1085
1086 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1087 _OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1088 _OutputIterator, _Compare,
1089 /*__is_vector=*/std::false_type) noexcept;
1090
1091 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1092 _OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1093 _OutputIterator, _Compare,
1094 /*__is_vector=*/std::true_type) noexcept;
1095
1096 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1097 class _Compare, class _IsVector>
1098 _OutputIterator
1099 __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1100 _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
1101
1102 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1103 class _Compare, class _IsVector>
1104 _OutputIterator
1105 __pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1106 _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
1107
1108 //------------------------------------------------------------------------
1109 // set_symmetric_difference
1110 //------------------------------------------------------------------------
1111
1112 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1113 _OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1114 _ForwardIterator2, _OutputIterator, _Compare,
1115 /*__is_vector=*/std::false_type) noexcept;
1116
1117 template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
1118 _OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1119 _ForwardIterator2, _OutputIterator, _Compare,
1120 /*__is_vector=*/std::true_type) noexcept;
1121
1122 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1123 class _Compare, class _IsVector>
1124 _OutputIterator
1125 __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1126 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
1127 /*is_parallel=*/std::false_type) noexcept;
1128
1129 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
1130 class _Compare, class _IsVector>
1131 _OutputIterator
1132 __pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1133 _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
1134 /*is_parallel=*/std::true_type);
1135
1136 //------------------------------------------------------------------------
1137 // is_heap_until
1138 //------------------------------------------------------------------------
1139
1140 template <class _RandomAccessIterator, class _Compare>
1141 _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
1142 /* __is_vector = */ std::false_type) noexcept;
1143
1144 template <class _RandomAccessIterator, class _Compare>
1145 _RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
1146 /* __is_vector = */ std::true_type) noexcept;
1147
1148 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
1149 _RandomAccessIterator
1150 __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
1151 /* is_parallel = */ std::false_type) noexcept;
1152
1153 template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
1154 _RandomAccessIterator
1155 __pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
1156 /* is_parallel = */ std::true_type) noexcept;
1157
1158 //------------------------------------------------------------------------
1159 // min_element
1160 //------------------------------------------------------------------------
1161
1162 template <typename _ForwardIterator, typename _Compare>
1163 _ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
1164 /* __is_vector = */ std::false_type) noexcept;
1165
1166 template <typename _ForwardIterator, typename _Compare>
1167 _ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
1168 /* __is_vector = */ std::true_type) noexcept;
1169
1170 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
1171 _ForwardIterator
1172 __pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
1173 /* is_parallel = */ std::false_type) noexcept;
1174
1175 template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
1176 _RandomAccessIterator
1177 __pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
1178 /* is_parallel = */ std::true_type);
1179
1180 //------------------------------------------------------------------------
1181 // minmax_element
1182 //------------------------------------------------------------------------
1183
1184 template <typename _ForwardIterator, typename _Compare>
1185 std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
1186 /* __is_vector = */ std::false_type) noexcept;
1187
1188 template <typename _ForwardIterator, typename _Compare>
1189 std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
1190 /* __is_vector = */ std::true_type) noexcept;
1191
1192 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
1193 std::pair<_ForwardIterator, _ForwardIterator>
1194 __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
1195 /* is_parallel = */ std::false_type) noexcept;
1196
1197 template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
1198 std::pair<_ForwardIterator, _ForwardIterator>
1199 __pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
1200 /* is_parallel = */ std::true_type);
1201
1202 //------------------------------------------------------------------------
1203 // mismatch
1204 //------------------------------------------------------------------------
1205
1206 template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
1207 std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1,
1208 _ForwardIterator2, _ForwardIterator2, _Predicate,
1209 /* __is_vector = */ std::false_type) noexcept;
1210
1211 template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
1212 std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1,
1213 _ForwardIterator2, _ForwardIterator2, _Predicate,
1214 /* __is_vector = */ std::true_type) noexcept;
1215
1216 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
1217 std::pair<_ForwardIterator1, _ForwardIterator2>
1218 __pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1219 _Predicate, _IsVector,
1220 /* is_parallel = */ std::false_type) noexcept;
1221
1222 template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
1223 class _IsVector>
1224 std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
1225 __pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
1226 _RandomAccessIterator2, _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
1227
1228 //------------------------------------------------------------------------
1229 // lexicographical_compare
1230 //------------------------------------------------------------------------
1231
1232 template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
1233 bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1234 _Compare,
1235 /* __is_vector = */ std::false_type) noexcept;
1236
1237 template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
1238 bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
1239 _Compare,
1240 /* __is_vector = */ std::true_type) noexcept;
1241
1242 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
1243 bool
1244 __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1245 _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
1246
1247 template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
1248 bool
1249 __pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
1250 _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept;
1251
1252 } // namespace __internal
1253 } // namespace __pstl
1254 #endif /* _PSTL_ALGORITHM_FWD_H */