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