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 */
1255