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