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