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