libstdc++
GNU C++ library
Loading...
Searching...
No Matches
glue_algorithm_impl.h
Go to the documentation of this file.
1// -*- C++ -*-
2//===-- glue_algorithm_impl.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_GLUE_ALGORITHM_IMPL_H
11#define _PSTL_GLUE_ALGORITHM_IMPL_H
12
13#include <functional>
14
15#include "execution_defs.h"
16#include "utils.h"
17#include "algorithm_fwd.h"
18#include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */
19
20namespace std
21{
22
23// [alg.any_of]
24
25template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
26__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
27any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
28{
29 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
30
31 return __pstl::__internal::__pattern_any_of(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
32 __pred);
33}
34
35// [alg.all_of]
36
37template <class _ExecutionPolicy, class _ForwardIterator, class _Pred>
38__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
39all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred)
40{
41 return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::not_fn(__pred));
42}
43
44// [alg.none_of]
45
46template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
47__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
48none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
49{
50 return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
51}
52
53// [alg.foreach]
54
55template <class _ExecutionPolicy, class _ForwardIterator, class _Function>
56__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
57for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f)
58{
59 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
60
61 __pstl::__internal::__pattern_walk1(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __f);
62}
63
64template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
65__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
66for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f)
67{
68 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
69
70 return __pstl::__internal::__pattern_walk1_n(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n,
71 __f);
72}
73
74// [alg.find]
75
76template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
77__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
78find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
79{
80 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
81
82 return __pstl::__internal::__pattern_find_if(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
83 __last, __pred);
84}
85
86template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
87__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
88find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
89{
90 return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::not_fn(__pred));
91}
92
93template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
94__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
95find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
96{
97 return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last,
98 __pstl::__internal::__equal_value<_Tp>(__value));
99}
100
101// [alg.find.end]
102template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
103__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
104find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
105 _ForwardIterator2 __s_last, _BinaryPredicate __pred)
106{
107 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
108
109 return __pstl::__internal::__pattern_find_end(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
110 __last, __s_first, __s_last, __pred);
111}
112
113template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
114__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
115find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
116 _ForwardIterator2 __s_last)
117{
118 return std::find_end(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last,
119 std::equal_to<>());
120}
121
122// [alg.find_first_of]
123template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
124__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
125find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
126 _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred)
127{
128 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
129
130 return __pstl::__internal::__pattern_find_first_of(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
131 __last, __s_first, __s_last, __pred);
132}
133
134template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
135__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
136find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
137 _ForwardIterator2 __s_first, _ForwardIterator2 __s_last)
138{
139 return std::find_first_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last,
140 std::equal_to<>());
141}
142
143// [alg.adjacent_find]
144template <class _ExecutionPolicy, class _ForwardIterator>
145__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
146adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
147{
148 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
149
150 typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
151 return __pstl::__internal::__pattern_adjacent_find(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
152 __last, std::equal_to<_ValueType>(), /*first_semantic*/ false);
153}
154
155template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
156__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
157adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
158{
159 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
160 return __pstl::__internal::__pattern_adjacent_find(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
161 __last, __pred, /*first_semantic*/ false);
162}
163
164// [alg.count]
165
166// Implementation note: count and count_if call the pattern directly instead of calling std::transform_reduce
167// so that we do not have to include <numeric>.
168
169template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
170__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
171 typename iterator_traits<_ForwardIterator>::difference_type>
172count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
173{
174 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
175
176 typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
177 return __pstl::__internal::__pattern_count(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
178 [&__value](const _ValueType& __x) { return __value == __x; });
179}
180
181template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
182__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
183 typename iterator_traits<_ForwardIterator>::difference_type>
184count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
185{
186 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
187 return __pstl::__internal::__pattern_count(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
188 __pred);
189}
190
191// [alg.search]
192
193template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
194__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
195search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
196 _ForwardIterator2 __s_last, _BinaryPredicate __pred)
197{
198 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
199
200 return __pstl::__internal::__pattern_search(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
201 __s_first, __s_last, __pred);
202}
203
204template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
205__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
206search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
207 _ForwardIterator2 __s_last)
208{
209 return std::search(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
210}
211
212template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
213__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
214search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
215 const _Tp& __value, _BinaryPredicate __pred)
216{
217 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
218
219 return __pstl::__internal::__pattern_search_n(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
220 __last, __count, __value, __pred);
221}
222
223template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
224__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
225search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
226 const _Tp& __value)
227{
228 return std::search_n(std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value,
229 std::equal_to<typename iterator_traits<_ForwardIterator>::value_type>());
230}
231
232// [alg.copy]
233
234template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
235__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
236copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result)
237{
238 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
239
240 using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
241
242 return __pstl::__internal::__pattern_walk2_brick(
243 __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
244 [](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res)
245 { return __pstl::__internal::__brick_copy(__begin, __end, __res, __is_vector{}); });
246}
247
248template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
249__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
250copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result)
251{
252 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
253
254 using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
255
256 return __pstl::__internal::__pattern_walk2_brick_n(
257 __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
258 [](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res)
259 { return __pstl::__internal::__brick_copy_n(__begin, __sz, __res, __is_vector{}); });
260}
261
262template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
263__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
264copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
265 _Predicate __pred)
266{
267 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
268
269 return __pstl::__internal::__pattern_copy_if(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
270 __last, __result, __pred);
271}
272
273// [alg.swap]
274
275template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
276__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
277swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
278 _ForwardIterator2 __first2)
279{
280 typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
281 typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
282
283 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
284
285 return __pstl::__internal::__pattern_walk2(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
286 __last1, __first2,
287 [](_ReferenceType1 __x, _ReferenceType2 __y)
288 {
289 using std::swap;
290 swap(__x, __y);
291 });
292}
293
294// [alg.transform]
295
296template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation>
297__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
298transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
299 _UnaryOperation __op)
300{
301 typedef typename iterator_traits<_ForwardIterator1>::reference _InputType;
302 typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType;
303
304 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
305
306 return __pstl::__internal::__pattern_walk2(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
307 __result,
308 [__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); });
309}
310
311template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
312 class _BinaryOperation>
313__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
314transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
315 _ForwardIterator __result, _BinaryOperation __op)
316{
317 typedef typename iterator_traits<_ForwardIterator1>::reference _Input1Type;
318 typedef typename iterator_traits<_ForwardIterator2>::reference _Input2Type;
319 typedef typename iterator_traits<_ForwardIterator>::reference _OutputType;
320
321 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
322
323 return __pstl::__internal::__pattern_walk3(
324 __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __result,
325 [__op](_Input1Type __x, _Input2Type __y, _OutputType __z) mutable { __z = __op(__x, __y); });
326}
327
328// [alg.replace]
329
330template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
331__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
332replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
333 const _Tp& __new_value)
334{
335 typedef typename iterator_traits<_ForwardIterator>::reference _ElementType;
336
337 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
338
339 __pstl::__internal::__pattern_walk1(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
340 [&__pred, &__new_value](_ElementType __elem)
341 {
342 if (__pred(__elem))
343 {
344 __elem = __new_value;
345 }
346 });
347}
348
349template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
350__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
351replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value,
352 const _Tp& __new_value)
353{
354 std::replace_if(std::forward<_ExecutionPolicy>(__exec), __first, __last,
355 __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value);
356}
357
358template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
359__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
360replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
361 _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value)
362{
363 typedef typename iterator_traits<_ForwardIterator1>::reference _InputType;
364 typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType;
365
366 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
367
368 return __pstl::__internal::__pattern_walk2(
369 __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
370 [__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; });
371}
372
373template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
374__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
375replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
376 const _Tp& __old_value, const _Tp& __new_value)
377{
378 return std::replace_copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
379 __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value);
380}
381
382// [alg.fill]
383
384template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
385__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
386fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
387{
388 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
389
390 __pstl::__internal::__pattern_fill(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
391 __value);
392}
393
394template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
395__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
396fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value)
397{
398 if (__count <= 0)
399 return __first;
400
401 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
402
403 return __pstl::__internal::__pattern_fill_n(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
404 __count, __value);
405}
406
407// [alg.generate]
408template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
409__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
410generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g)
411{
412 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
413
414 __pstl::__internal::__pattern_generate(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
415 __g);
416}
417
418template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
419__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
420generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, _Generator __g)
421{
422 if (__count <= 0)
423 return __first;
424
425 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
426
427 return __pstl::__internal::__pattern_generate_n(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
428 __count, __g);
429}
430
431// [alg.remove]
432
433template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
434__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
435remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
436 _ForwardIterator2 __result, _Predicate __pred)
437{
438 return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, std::not_fn(__pred));
439}
440
441template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
442__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
443remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
444 const _Tp& __value)
445{
446 return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
447 __pstl::__internal::__not_equal_value<_Tp>(__value));
448}
449
450template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
451__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
452remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
453{
454 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
455
456 return __pstl::__internal::__pattern_remove_if(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
457 __last, __pred);
458}
459
460template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
461__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
462remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
463{
464 return std::remove_if(std::forward<_ExecutionPolicy>(__exec), __first, __last,
465 __pstl::__internal::__equal_value<_Tp>(__value));
466}
467
468// [alg.unique]
469
470template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
471__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
472unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
473{
474 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
475
476 return __pstl::__internal::__pattern_unique(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
477 __pred);
478}
479
480template <class _ExecutionPolicy, class _ForwardIterator>
481__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
482unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
483{
484 return std::unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<>());
485}
486
487template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
488__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
489unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
490 _BinaryPredicate __pred)
491{
492 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
493
494 return __pstl::__internal::__pattern_unique_copy(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
495 __last, __result, __pred);
496}
497
498template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
499__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
500unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result)
501{
502 return std::unique_copy(__exec, __first, __last, __result, std::equal_to<>());
503}
504
505// [alg.reverse]
506
507template <class _ExecutionPolicy, class _BidirectionalIterator>
508__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
509reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last)
510{
511 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
512
513 __pstl::__internal::__pattern_reverse(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last);
514}
515
516template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
517__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
518reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
519 _ForwardIterator __d_first)
520{
521 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
522
523 return __pstl::__internal::__pattern_reverse_copy(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
524 __last, __d_first);
525}
526
527// [alg.rotate]
528
529template <class _ExecutionPolicy, class _ForwardIterator>
530__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
531rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
532{
533 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
534
535 return __pstl::__internal::__pattern_rotate(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
536 __middle, __last);
537}
538
539template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
540__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
541rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
542 _ForwardIterator2 __result)
543{
544 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
545
546 return __pstl::__internal::__pattern_rotate_copy(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
547 __middle, __last, __result);
548}
549
550// [alg.partitions]
551
552template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
553__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
554is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
555{
556 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
557 return __pstl::__internal::__pattern_is_partitioned(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
558 __last, __pred);
559}
560
561template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
562__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
563partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
564{
565 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
566
567 return __pstl::__internal::__pattern_partition(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
568 __last, __pred);
569}
570
571template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
572__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
573stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
574 _UnaryPredicate __pred)
575{
576 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
577 return __pstl::__internal::__pattern_stable_partition(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec),
578 __first, __last, __pred);
579}
580
581template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
582 class _UnaryPredicate>
583__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
584partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
585 _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred)
586{
587 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __out_true, __out_false);
588
589 return __pstl::__internal::__pattern_partition_copy(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
590 __last, __out_true, __out_false, __pred);
591}
592
593// [alg.sort]
594
595template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
596__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
597sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
598{
599 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
600
601 typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
602 return __pstl::__internal::__pattern_sort(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last,
603 __comp, typename std::is_move_constructible<_InputType>::type());
604}
605
606template <class _ExecutionPolicy, class _RandomAccessIterator>
607__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
608sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
609{
610 typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
611 std::sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
612}
613
614// [stable.sort]
615
616template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
617__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
618stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
619{
620 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
621
622 return __pstl::__internal::__pattern_stable_sort(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
623 __last, __comp);
624}
625
626template <class _ExecutionPolicy, class _RandomAccessIterator>
627__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
628stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
629{
630 typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
631 std::stable_sort(__exec, __first, __last, std::less<_InputType>());
632}
633
634// [mismatch]
635
636template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
637__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
638mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
639 _ForwardIterator2 __last2, _BinaryPredicate __pred)
640{
641 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
642
643 return __pstl::__internal::__pattern_mismatch(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
644 __last1, __first2, __last2, __pred);
645}
646
647template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
648__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
649mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
650 _BinaryPredicate __pred)
651{
652 return std::mismatch(__exec, __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1)),
653 __pred);
654}
655
656template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
657__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
658mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
659 _ForwardIterator2 __last2)
660{
661 return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2,
662 std::equal_to<>());
663}
664
665template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
666__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
667mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
668{
669 //TODO: to get rid of "distance"
670 return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2,
671 std::next(__first2, std::distance(__first1, __last1)));
672}
673
674// [alg.equal]
675
676template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
677__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
678equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
679 _BinaryPredicate __p)
680{
681 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
682
683 return __pstl::__internal::__pattern_equal(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
684 __last1, __first2, __p);
685}
686
687template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
688__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
689equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
690{
691 return std::equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, std::equal_to<>());
692}
693
694template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
695__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
696equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
697 _ForwardIterator2 __last2, _BinaryPredicate __p)
698{
699 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
700
701 return __pstl::__internal::__pattern_equal(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
702 __last1, __first2, __last2, __p);
703}
704
705template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
706__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
707equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
708 _ForwardIterator2 __last2)
709{
710 return equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::equal_to<>());
711}
712
713// [alg.move]
714template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
715__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
716move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first)
717{
718 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
719
720 using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
721
722 return __pstl::__internal::__pattern_walk2_brick(
723 __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first,
724 [](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res)
725 { return __pstl::__internal::__brick_move(__begin, __end, __res, __is_vector{}); });
726}
727
728// [partial.sort]
729
730template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
731__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
732partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
733 _RandomAccessIterator __last, _Compare __comp)
734{
735 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
736
737 __pstl::__internal::__pattern_partial_sort(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
738 __middle, __last, __comp);
739}
740
741template <class _ExecutionPolicy, class _RandomAccessIterator>
742__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
743partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
744 _RandomAccessIterator __last)
745{
746 typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
747 std::partial_sort(__exec, __first, __middle, __last, std::less<_InputType>());
748}
749
750// [partial.sort.copy]
751
752template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
753__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
754partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
755 _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp)
756{
757 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
758
759 return __pstl::__internal::__pattern_partial_sort_copy(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec),
760 __first, __last, __d_first, __d_last, __comp);
761}
762
763template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
764__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
765partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
766 _RandomAccessIterator __d_first, _RandomAccessIterator __d_last)
767{
768 return std::partial_sort_copy(std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last,
769 std::less<>());
770}
771
772// [is.sorted]
773template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
774__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
775is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
776{
777 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
778 const _ForwardIterator __res =
779 __pstl::__internal::__pattern_adjacent_find(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
780 __last, __pstl::__internal::__reorder_pred<_Compare>(__comp),
781 /*first_semantic*/ false);
782 return __res == __last ? __last : std::next(__res);
783}
784
785template <class _ExecutionPolicy, class _ForwardIterator>
786__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
787is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
788{
789 typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
790 return is_sorted_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
791}
792
793template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
794__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
795is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
796{
797 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
798 return __pstl::__internal::__pattern_adjacent_find(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
799 __last, __pstl::__internal::__reorder_pred<_Compare>(__comp),
800 /*or_semantic*/ true) == __last;
801}
802
803template <class _ExecutionPolicy, class _ForwardIterator>
804__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
805is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
806{
807 typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
808 return std::is_sorted(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
809}
810
811// [alg.merge]
812template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
813 class _Compare>
814__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
815merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
816 _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp)
817{
818 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __d_first);
819
820 return __pstl::__internal::__pattern_merge(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
821 __last1, __first2, __last2, __d_first, __comp);
822}
823
824template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
825__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
826merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
827 _ForwardIterator2 __last2, _ForwardIterator __d_first)
828{
829 return std::merge(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first,
830 std::less<>());
831}
832
833template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
834__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
835inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
836 _BidirectionalIterator __last, _Compare __comp)
837{
838 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
839
840 __pstl::__internal::__pattern_inplace_merge(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
841 __middle, __last, __comp);
842}
843
844template <class _ExecutionPolicy, class _BidirectionalIterator>
845__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
846inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
847 _BidirectionalIterator __last)
848{
849 typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _InputType;
850 std::inplace_merge(__exec, __first, __middle, __last, std::less<_InputType>());
851}
852
853// [includes]
854
855template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
856__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
857includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
858 _ForwardIterator2 __last2, _Compare __comp)
859{
860 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
861
862 return __pstl::__internal::__pattern_includes(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
863 __last1, __first2, __last2, __comp);
864}
865
866template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
867__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
868includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
869 _ForwardIterator2 __last2)
870{
871 return std::includes(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::less<>());
872}
873
874// [set.union]
875
876template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
877 class _Compare>
878__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
879set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
880 _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
881{
882 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
883
884 return __pstl::__internal::__pattern_set_union(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1,
885 __last1, __first2, __last2, __result, __comp);
886}
887
888template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
889__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
890set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
891 _ForwardIterator2 __last2, _ForwardIterator __result)
892{
893 return std::set_union(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
894 std::less<>());
895}
896
897// [set.intersection]
898
899template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
900 class _Compare>
901__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
902set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
903 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
904{
905 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
906
907 return __pstl::__internal::__pattern_set_intersection(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec),
908 __first1, __last1, __first2, __last2, __result, __comp);
909}
910
911template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
912__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
913set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
914 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result)
915{
916 return std::set_intersection(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
917 std::less<>());
918}
919
920// [set.difference]
921
922template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
923 class _Compare>
924__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
925set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
926 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
927{
928 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
929
930 return __pstl::__internal::__pattern_set_difference(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec),
931 __first1, __last1, __first2, __last2, __result, __comp);
932}
933
934template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
935__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
936set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
937 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result)
938{
939 return std::set_difference(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
940 std::less<>());
941}
942
943// [set.symmetric.difference]
944
945template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
946 class _Compare>
947__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
948set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
949 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result,
950 _Compare __comp)
951{
952 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
953
954 return __pstl::__internal::__pattern_set_symmetric_difference(
955 __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
956}
957
958template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
959__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
960set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
961 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result)
962{
963 return std::set_symmetric_difference(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2,
964 __result, std::less<>());
965}
966
967// [is.heap]
968template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
969__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
970is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
971{
972 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
973
974 return __pstl::__internal::__pattern_is_heap_until(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
975 __last, __comp);
976}
977
978template <class _ExecutionPolicy, class _RandomAccessIterator>
979__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
980is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
981{
982 typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
983 return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
984}
985
986template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
987__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
988is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
989{
990 return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp) == __last;
991}
992
993template <class _ExecutionPolicy, class _RandomAccessIterator>
994__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
995is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
996{
997 typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
998 return std::is_heap(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
999}
1000
1001// [alg.min.max]
1002
1003template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
1004__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
1005min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
1006{
1007 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
1008 return __pstl::__internal::__pattern_min_element(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
1009 __last, __comp);
1010}
1011
1012template <class _ExecutionPolicy, class _ForwardIterator>
1013__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
1014min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
1015{
1016 typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
1017 return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
1018}
1019
1020template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
1021__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
1022max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
1023{
1024 return min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last,
1025 __pstl::__internal::__reorder_pred<_Compare>(__comp));
1026}
1027
1028template <class _ExecutionPolicy, class _ForwardIterator>
1029__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
1030max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
1031{
1032 typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
1033 return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last,
1034 __pstl::__internal::__reorder_pred<std::less<_InputType>>(std::less<_InputType>()));
1035}
1036
1037template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
1038__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
1039minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
1040{
1041 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
1042 return __pstl::__internal::__pattern_minmax_element(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first,
1043 __last, __comp);
1044}
1045
1046template <class _ExecutionPolicy, class _ForwardIterator>
1047__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
1048minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
1049{
1050 typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
1051 return std::minmax_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_ValueType>());
1052}
1053
1054// [alg.nth.element]
1055
1056template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
1057__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
1058nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
1059 _RandomAccessIterator __last, _Compare __comp)
1060{
1061 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
1062
1063 __pstl::__internal::__pattern_nth_element(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __nth,
1064 __last, __comp);
1065}
1066
1067template <class _ExecutionPolicy, class _RandomAccessIterator>
1068__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
1069nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
1070 _RandomAccessIterator __last)
1071{
1072 typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
1073 std::nth_element(std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, std::less<_InputType>());
1074}
1075
1076// [alg.lex.comparison]
1077
1078template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
1079__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
1080lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
1081 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp)
1082{
1083 auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
1084
1085 return __pstl::__internal::__pattern_lexicographical_compare(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec),
1086 __first1, __last1, __first2, __last2, __comp);
1087}
1088
1089template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
1090__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
1091lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
1092 _ForwardIterator2 __first2, _ForwardIterator2 __last2)
1093{
1094 return std::lexicographical_compare(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2,
1095 std::less<>());
1096}
1097
1098} // namespace std
1099
1100#endif /* _PSTL_GLUE_ALGORITHM_IMPL_H */
remove
constexpr _FIter remove(_FIter, _FIter, const _Tp &)
none_of
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool none_of(const simd_mask< _Tp, _Abi > &__k) noexcept
Definition simd.h:5151
any_of
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool any_of(const simd_mask< _Tp, _Abi > &__k) noexcept
Definition simd.h:5136
all_of
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool all_of(const simd_mask< _Tp, _Abi > &__k) noexcept
Definition simd.h:5121
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
std::forward
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition move.h:72
std::for_each_n
constexpr _InputIterator for_each_n(_InputIterator __first, _Size __n, _Function __f)
Apply a function to every element of a sequence.
Definition stl_algo.h:3798
std::is_heap
constexpr bool is_heap(_RAIter, _RAIter)
std::inplace_merge
void inplace_merge(_BIter, _BIter, _BIter)
std::lexicographical_compare
constexpr bool lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2)
std::reverse_copy
constexpr _OIter reverse_copy(_BIter, _BIter, _OIter)
std::partial_sort
constexpr void partial_sort(_RAIter, _RAIter, _RAIter)
std::search_n
constexpr _FIter search_n(_FIter, _FIter, _Size, const _Tp &)
std::find_if
constexpr _IIter find_if(_IIter, _IIter, _Predicate)
std::for_each
constexpr _Funct for_each(_IIter, _IIter, _Funct)
std::transform
constexpr _OIter transform(_IIter, _IIter, _OIter, _UnaryOperation)
std::find_if_not
constexpr _IIter find_if_not(_IIter, _IIter, _Predicate)
std::generate
constexpr void generate(_FIter, _FIter, _Generator)
std::find
constexpr _IIter find(_IIter, _IIter, const _Tp &)
std::replace_copy
constexpr _OIter replace_copy(_IIter, _IIter, _OIter, const _Tp &, const _Tp &)
std::count_if
constexpr iterator_traits< _IIter >::difference_type count_if(_IIter, _IIter, _Predicate)
std::remove_if
constexpr _FIter remove_if(_FIter, _FIter, _Predicate)
std::sort
constexpr void sort(_RAIter, _RAIter)
std::is_partitioned
constexpr bool is_partitioned(_IIter, _IIter, _Predicate)
std::distance
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
Definition stl_iterator_base_funcs.h:172
std::min_element
constexpr _FIter min_element(_FIter, _FIter)
std::copy
constexpr _OIter copy(_IIter, _IIter, _OIter)
std::search
constexpr _FIter1 search(_FIter1, _FIter1, _FIter2, _FIter2)
std::set_union
constexpr _OIter set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter)
std::find_end
constexpr _FIter1 find_end(_FIter1, _FIter1, _FIter2, _FIter2)
std::partition_copy
constexpr pair< _OIter1, _OIter2 > partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate)
std::unique_copy
constexpr _OIter unique_copy(_IIter, _IIter, _OIter)
std::nth_element
constexpr void nth_element(_RAIter, _RAIter, _RAIter)
std::equal
constexpr bool equal(_IIter1, _IIter1, _IIter2)
std::rotate_copy
constexpr _OIter rotate_copy(_FIter, _FIter, _FIter, _OIter)
std::is_sorted_until
constexpr _FIter is_sorted_until(_FIter, _FIter)
std::minmax_element
constexpr pair< _FIter, _FIter > minmax_element(_FIter, _FIter)
std::any_of
constexpr bool any_of(_IIter, _IIter, _Predicate)
std::swap
constexpr __enable_if_t< __array_traits< _Tp, _Nm >::_Is_swappable::value > swap(array< _Tp, _Nm > &__one, array< _Tp, _Nm > &__two) noexcept(noexcept(__one.swap(__two)))
Definition array:379
std::fill
constexpr void fill(_FIter, _FIter, const _Tp &)
std::next
constexpr _InputIterator next(_InputIterator __x, typename iterator_traits< _InputIterator >::difference_type __n=1)
Definition stl_iterator_base_funcs.h:296
std::copy_if
constexpr _OIter copy_if(_IIter, _IIter, _OIter, _Predicate)
std::set_difference
constexpr _OIter set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter)
std::remove_copy_if
constexpr _OIter remove_copy_if(_IIter, _IIter, _OIter, _Predicate)
std::stable_partition
_BIter stable_partition(_BIter, _BIter, _Predicate)
std::is_sorted
constexpr bool is_sorted(_FIter, _FIter)
std::find_first_of
constexpr _FIter1 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2)
std::replace
constexpr void replace(_FIter, _FIter, const _Tp &, const _Tp &)
std::generate_n
constexpr _OIter generate_n(_OIter, _Size, _Generator)
std::copy_n
constexpr _OIter copy_n(_IIter, _Size, _OIter)
std::swap_ranges
constexpr _FIter2 swap_ranges(_FIter1, _FIter1, _FIter2)
std::fill_n
constexpr _OIter fill_n(_OIter, _Size, const _Tp &)
std::mismatch
constexpr pair< _IIter1, _IIter2 > mismatch(_IIter1, _IIter1, _IIter2)
std::reverse
constexpr void reverse(_BIter, _BIter)
std::max_element
constexpr _FIter max_element(_FIter, _FIter)
std::replace_if
constexpr void replace_if(_FIter, _FIter, _Predicate, const _Tp &)
std::count
constexpr iterator_traits< _IIter >::difference_type count(_IIter, _IIter, const _Tp &)
std::adjacent_find
constexpr _FIter adjacent_find(_FIter, _FIter)
std::partition
constexpr _BIter partition(_BIter, _BIter, _Predicate)
std::stable_sort
void stable_sort(_RAIter, _RAIter)
std::includes
constexpr bool includes(_IIter1, _IIter1, _IIter2, _IIter2)
std::merge
constexpr _OIter merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter)
std::is_heap_until
constexpr _RAIter is_heap_until(_RAIter, _RAIter)
std::replace_copy_if
constexpr _OIter replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp &)
std::remove_copy
constexpr _OIter remove_copy(_IIter, _IIter, _OIter, const _Tp &)
std::set_symmetric_difference
constexpr _OIter set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter)
std::set_intersection
constexpr _OIter set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter)
std::partial_sort_copy
constexpr _RAIter partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter)
std::unique
constexpr _FIter unique(_FIter, _FIter)
std
ISO C++ entities toplevel namespace is std.
std::_V2::rotate
constexpr _FIter rotate(_FIter, _FIter, _FIter)
__pstl::__internal::__pattern_lexicographical_compare
bool __pattern_lexicographical_compare(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare) noexcept
Definition algorithm_impl.h:3759
__pstl::__internal::__pattern_stable_partition
_BidirectionalIterator __pattern_stable_partition(_Tag, _ExecutionPolicy &&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate) noexcept
Definition algorithm_impl.h:2037
__pstl::__internal::__pattern_equal
bool __pattern_equal(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate) noexcept
Definition algorithm_impl.h:489
__pstl::__internal::__pattern_fill
void __pattern_fill(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, const _Tp &) noexcept
Definition algorithm_impl.h:2515
__pstl::__internal::__pattern_unique
_ForwardIterator __pattern_unique(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _BinaryPredicate) noexcept
Definition algorithm_impl.h:1225
__pstl::__internal::__pattern_search_n
_ForwardIterator __pattern_search_n(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Size, const _Tp &, _BinaryPredicate) noexcept
Definition algorithm_impl.h:842
__pstl::__internal::__brick_copy_n
_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator, std::false_type) noexcept
Definition algorithm_impl.h:884
__pstl::__internal::__pattern_count
std::iterator_traits< _ForwardIterator >::difference_type __pattern_count(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept
Definition algorithm_impl.h:1178
__pstl::__internal::__pattern_partial_sort
void __pattern_partial_sort(_Tag, _ExecutionPolicy &&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept
Definition algorithm_impl.h:2240
__pstl::__internal::__pattern_inplace_merge
void __pattern_inplace_merge(_Tag, _ExecutionPolicy &&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare) noexcept
Definition algorithm_impl.h:2772
__pstl::__internal::__pattern_any_of
bool __pattern_any_of(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Pred) noexcept
Definition algorithm_impl.h:54
__pstl::__internal::__pattern_is_partitioned
bool __pattern_is_partitioned(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept
Definition algorithm_impl.h:1807
__pstl::__internal::__pattern_fill_n
_OutputIterator __pattern_fill_n(_Tag, _ExecutionPolicy &&, _OutputIterator, _Size, const _Tp &) noexcept
Definition algorithm_impl.h:2554
__pstl::__internal::__pattern_set_union
_OutputIterator __pattern_set_union(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare) noexcept
Definition algorithm_impl.h:3151
__pstl::__internal::__enable_if_execution_policy
typename std::enable_if< __pstl::execution::is_execution_policy< std::__remove_cvref_t< _ExecPolicy > >::value, _Tp >::type __enable_if_execution_policy
Definition execution_defs.h:82
__pstl::__internal::__pattern_find_end
_ForwardIterator1 __pattern_find_end(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate) noexcept
Definition algorithm_impl.h:676
__pstl::__internal::__pattern_walk2_brick
_ForwardIterator2 __pattern_walk2_brick(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick) noexcept
Definition algorithm_impl.h:304
__pstl::__internal::__pattern_partition
_ForwardIterator __pattern_partition(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept
Definition algorithm_impl.h:1937
__pstl::__internal::__pattern_walk1_n
_ForwardIterator __pattern_walk1_n(_Tag, _ExecutionPolicy &&, _ForwardIterator, _Size, _Function) noexcept
Definition algorithm_impl.h:175
__pstl::__internal::__pattern_reverse_copy
_OutputIterator __pattern_reverse_copy(_Tag, _ExecutionPolicy &&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator) noexcept
Definition algorithm_impl.h:1554
__pstl::__internal::__pattern_reverse
void __pattern_reverse(_Tag, _ExecutionPolicy &&, _BidirectionalIterator, _BidirectionalIterator) noexcept
Definition algorithm_impl.h:1510
__pstl::__internal::__pattern_nth_element
void __pattern_nth_element(_Tag, _ExecutionPolicy &&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept
Definition algorithm_impl.h:2444
__pstl::__internal::__brick_move
_OutputIterator __brick_move(_ForwardIterator, _ForwardIterator, _OutputIterator, std::false_type) noexcept
Definition algorithm_impl.h:925
__pstl::__internal::__pattern_generate_n
_OutputIterator __pattern_generate_n(_Tag, _ExecutionPolicy &&, _OutputIterator, _Size, _Generator) noexcept
Definition algorithm_impl.h:2628
__pstl::__internal::__pattern_partition_copy
std::pair< _OutputIterator1, _OutputIterator2 > __pattern_partition_copy(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate) noexcept
Definition algorithm_impl.h:2127
__pstl::__internal::__pattern_set_symmetric_difference
_OutputIterator __pattern_set_symmetric_difference(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare) noexcept
Definition algorithm_impl.h:3400
__pstl::__internal::__pattern_min_element
_ForwardIterator __pattern_min_element(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Compare) noexcept
Definition algorithm_impl.h:3543
__pstl::__internal::__pattern_rotate_copy
_OutputIterator __pattern_rotate_copy(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator) noexcept
Definition algorithm_impl.h:1728
__pstl::__internal::__pattern_generate
void __pattern_generate(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Generator) noexcept
Definition algorithm_impl.h:2589
__pstl::__internal::__pattern_set_difference
_OutputIterator __pattern_set_difference(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare) noexcept
Definition algorithm_impl.h:3308
__pstl::__internal::__pattern_walk1
void __pattern_walk1(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Function) noexcept
Definition algorithm_impl.h:109
__pstl::__internal::__pattern_merge
_OutputIterator __pattern_merge(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare) noexcept
Definition algorithm_impl.h:2724
__pstl::__internal::__pattern_adjacent_find
_ForwardIterator __pattern_adjacent_find(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, bool) noexcept
Definition algorithm_impl.h:2383
__pstl::__internal::__pattern_walk2
_ForwardIterator2 __pattern_walk2(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function) noexcept
Definition algorithm_impl.h:258
__pstl::__internal::__pattern_unique_copy
_OutputIterator __pattern_unique_copy(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryPredicate) noexcept
Definition algorithm_impl.h:1374
__pstl::__internal::__pattern_walk2_brick_n
_ForwardIterator2 __pattern_walk2_brick_n(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick) noexcept
Definition algorithm_impl.h:332
__pstl::__internal::__pattern_rotate
_ForwardIterator __pattern_rotate(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _ForwardIterator) noexcept
Definition algorithm_impl.h:1637
__pstl::__internal::__select_backend
__serial_tag< std::false_type > __select_backend(__pstl::execution::sequenced_policy, _IteratorTypes &&...)
Definition execution_impl.h:81
__pstl::__internal::__pattern_walk3
_ForwardIterator3 __pattern_walk3(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function) noexcept
Definition algorithm_impl.h:383
__pstl::__internal::__pattern_includes
bool __pattern_includes(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare) noexcept
Definition algorithm_impl.h:2830
__pstl::__internal::__pattern_find_if
_ForwardIterator __pattern_find_if(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept
Definition algorithm_impl.h:537
__pstl::__internal::__pattern_sort
void __pattern_sort(_Tag, _ExecutionPolicy &&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsMoveConstructible) noexcept
Definition algorithm_impl.h:2182
__pstl::__internal::__pattern_stable_sort
void __pattern_stable_sort(_Tag, _ExecutionPolicy &&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept
Definition algorithm_impl.h:2211
__pstl::__internal::__pattern_find_first_of
_ForwardIterator1 __pattern_find_first_of(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate) noexcept
Definition algorithm_impl.h:735
__pstl::__internal::__pattern_minmax_element
std::pair< _ForwardIterator, _ForwardIterator > __pattern_minmax_element(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _Compare) noexcept
Definition algorithm_impl.h:3602
__pstl::__internal::__pattern_is_heap_until
_RandomAccessIterator __pattern_is_heap_until(_Tag, _ExecutionPolicy &&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept
Definition algorithm_impl.h:3462
__pstl::__internal::__pattern_copy_if
_OutputIterator __pattern_copy_if(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate) noexcept
Definition algorithm_impl.h:1112
__pstl::__internal::__pattern_search
_ForwardIterator1 __pattern_search(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _BinaryPredicate) noexcept
Definition algorithm_impl.h:783
__pstl::__internal::__pattern_remove_if
_ForwardIterator __pattern_remove_if(_Tag, _ExecutionPolicy &&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept
Definition algorithm_impl.h:2670
__pstl::__internal::__pattern_partial_sort_copy
_RandomAccessIterator2 __pattern_partial_sort_copy(_Tag, _ExecutionPolicy &&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2, _Compare) noexcept
__pstl::__internal::__pattern_set_intersection
_OutputIterator __pattern_set_intersection(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator, _Compare) noexcept
Definition algorithm_impl.h:3212
__pstl::__internal::__pattern_mismatch
std::pair< _ForwardIterator1, _ForwardIterator2 > __pattern_mismatch(_Tag, _ExecutionPolicy &&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate) noexcept
Definition algorithm_impl.h:3677
__pstl::__internal::__brick_copy
_OutputIterator __brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator, std::false_type) noexcept
Definition algorithm_impl.h:904
std::is_move_constructible
is_move_constructible
Definition type_traits:1301
std::iterator_traits
Traits class for iterators.
Definition stl_iterator_base_types.h:180
std::equal_to
One of the comparison functors.
Definition stl_function.h:374
std::less
One of the comparison functors.
Definition stl_function.h:404
__pstl::__internal::__equal_value
Like a polymorphic lambda for ==value.
Definition utils.h:125
__pstl::__internal::__not_equal_value
Logical negation of ==value.
Definition utils.h:142