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