1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef _LIBCPP___ALGORITHM_PSTL_H 10 #define _LIBCPP___ALGORITHM_PSTL_H 11 12 #include <__config> 13 #include <__functional/operations.h> 14 #include <__iterator/cpp17_iterator_concepts.h> 15 #include <__iterator/iterator_traits.h> 16 #include <__pstl/backend.h> 17 #include <__pstl/dispatch.h> 18 #include <__pstl/handle_exception.h> 19 #include <__type_traits/enable_if.h> 20 #include <__type_traits/is_execution_policy.h> 21 #include <__type_traits/remove_cvref.h> 22 #include <__utility/forward.h> 23 #include <__utility/move.h> 24 25 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 26 # pragma GCC system_header 27 #endif 28 29 _LIBCPP_PUSH_MACROS 30 #include <__undef_macros> 31 32 #if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17 33 34 _LIBCPP_BEGIN_NAMESPACE_STD 35 36 template <class _ExecutionPolicy, 37 class _ForwardIterator, 38 class _Predicate, 39 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 40 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 41 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool 42 any_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { 43 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "any_of requires a ForwardIterator"); 44 using _Implementation = __pstl::__dispatch<__pstl::__any_of, __pstl::__current_configuration, _RawPolicy>; 45 return __pstl::__handle_exception<_Implementation>( 46 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 47 } 48 49 template <class _ExecutionPolicy, 50 class _ForwardIterator, 51 class _Pred, 52 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 53 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 54 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool 55 all_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) { 56 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "all_of requires a ForwardIterator"); 57 using _Implementation = __pstl::__dispatch<__pstl::__all_of, __pstl::__current_configuration, _RawPolicy>; 58 return __pstl::__handle_exception<_Implementation>( 59 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 60 } 61 62 template <class _ExecutionPolicy, 63 class _ForwardIterator, 64 class _Pred, 65 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 66 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 67 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool 68 none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) { 69 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "none_of requires a ForwardIterator"); 70 using _Implementation = __pstl::__dispatch<__pstl::__none_of, __pstl::__current_configuration, _RawPolicy>; 71 return __pstl::__handle_exception<_Implementation>( 72 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 73 } 74 75 template <class _ExecutionPolicy, 76 class _ForwardIterator, 77 class _ForwardOutIterator, 78 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 79 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 80 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator 81 copy(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) { 82 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR( 83 _ForwardIterator, "copy(first, last, result) requires [first, last) to be ForwardIterators"); 84 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR( 85 _ForwardOutIterator, "copy(first, last, result) requires result to be a ForwardIterator"); 86 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 87 _ForwardOutIterator, decltype(*__first), "copy(first, last, result) requires result to be an OutputIterator"); 88 using _Implementation = __pstl::__dispatch<__pstl::__copy, __pstl::__current_configuration, _RawPolicy>; 89 return __pstl::__handle_exception<_Implementation>( 90 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result)); 91 } 92 93 template <class _ExecutionPolicy, 94 class _ForwardIterator, 95 class _ForwardOutIterator, 96 class _Size, 97 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 98 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 99 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator 100 copy_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __result) { 101 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR( 102 _ForwardIterator, "copy_n(first, n, result) requires first to be a ForwardIterator"); 103 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR( 104 _ForwardOutIterator, "copy_n(first, n, result) requires result to be a ForwardIterator"); 105 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 106 _ForwardOutIterator, decltype(*__first), "copy_n(first, n, result) requires result to be an OutputIterator"); 107 using _Implementation = __pstl::__dispatch<__pstl::__copy_n, __pstl::__current_configuration, _RawPolicy>; 108 return __pstl::__handle_exception<_Implementation>( 109 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__result)); 110 } 111 112 template <class _ExecutionPolicy, 113 class _ForwardIterator, 114 class _Predicate, 115 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 116 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 117 _LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator> 118 count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { 119 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR( 120 _ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators"); 121 using _Implementation = __pstl::__dispatch<__pstl::__count_if, __pstl::__current_configuration, _RawPolicy>; 122 return __pstl::__handle_exception<_Implementation>( 123 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 124 } 125 126 template <class _ExecutionPolicy, 127 class _ForwardIterator, 128 class _Tp, 129 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 130 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 131 _LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator> 132 count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { 133 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR( 134 _ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators"); 135 using _Implementation = __pstl::__dispatch<__pstl::__count, __pstl::__current_configuration, _RawPolicy>; 136 return __pstl::__handle_exception<_Implementation>( 137 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value); 138 } 139 140 template <class _ExecutionPolicy, 141 class _ForwardIterator1, 142 class _ForwardIterator2, 143 class _Pred, 144 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 145 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 146 _LIBCPP_HIDE_FROM_ABI bool 147 equal(_ExecutionPolicy&& __policy, 148 _ForwardIterator1 __first1, 149 _ForwardIterator1 __last1, 150 _ForwardIterator2 __first2, 151 _Pred __pred) { 152 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators"); 153 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators"); 154 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>; 155 return __pstl::__handle_exception<_Implementation>( 156 std::forward<_ExecutionPolicy>(__policy), 157 std::move(__first1), 158 std::move(__last1), 159 std::move(__first2), 160 std::move(__pred)); 161 } 162 163 template <class _ExecutionPolicy, 164 class _ForwardIterator1, 165 class _ForwardIterator2, 166 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 167 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 168 _LIBCPP_HIDE_FROM_ABI bool 169 equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) { 170 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators"); 171 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators"); 172 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>; 173 return __pstl::__handle_exception<_Implementation>( 174 std::forward<_ExecutionPolicy>(__policy), 175 std::move(__first1), 176 std::move(__last1), 177 std::move(__first2), 178 equal_to{}); 179 } 180 181 template <class _ExecutionPolicy, 182 class _ForwardIterator1, 183 class _ForwardIterator2, 184 class _Pred, 185 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 186 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 187 _LIBCPP_HIDE_FROM_ABI bool 188 equal(_ExecutionPolicy&& __policy, 189 _ForwardIterator1 __first1, 190 _ForwardIterator1 __last1, 191 _ForwardIterator2 __first2, 192 _ForwardIterator2 __last2, 193 _Pred __pred) { 194 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators"); 195 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators"); 196 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>; 197 return __pstl::__handle_exception<_Implementation>( 198 std::forward<_ExecutionPolicy>(__policy), 199 std::move(__first1), 200 std::move(__last1), 201 std::move(__first2), 202 std::move(__last2), 203 std::move(__pred)); 204 } 205 206 template <class _ExecutionPolicy, 207 class _ForwardIterator1, 208 class _ForwardIterator2, 209 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 210 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 211 _LIBCPP_HIDE_FROM_ABI bool 212 equal(_ExecutionPolicy&& __policy, 213 _ForwardIterator1 __first1, 214 _ForwardIterator1 __last1, 215 _ForwardIterator2 __first2, 216 _ForwardIterator2 __last2) { 217 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators"); 218 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators"); 219 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>; 220 return __pstl::__handle_exception<_Implementation>( 221 std::forward<_ExecutionPolicy>(__policy), 222 std::move(__first1), 223 std::move(__last1), 224 std::move(__first2), 225 std::move(__last2), 226 equal_to{}); 227 } 228 229 template <class _ExecutionPolicy, 230 class _ForwardIterator, 231 class _Tp, 232 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 233 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 234 _LIBCPP_HIDE_FROM_ABI void 235 fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { 236 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators"); 237 using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>; 238 __pstl::__handle_exception<_Implementation>( 239 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value); 240 } 241 242 template <class _ExecutionPolicy, 243 class _ForwardIterator, 244 class _Size, 245 class _Tp, 246 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 247 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 248 _LIBCPP_HIDE_FROM_ABI void 249 fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) { 250 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator"); 251 using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>; 252 __pstl::__handle_exception<_Implementation>( 253 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value); 254 } 255 256 template <class _ExecutionPolicy, 257 class _ForwardIterator, 258 class _Predicate, 259 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 260 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 261 _LIBCPP_HIDE_FROM_ABI _ForwardIterator 262 find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { 263 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators"); 264 using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>; 265 return __pstl::__handle_exception<_Implementation>( 266 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 267 } 268 269 template <class _ExecutionPolicy, 270 class _ForwardIterator, 271 class _Predicate, 272 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 273 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 274 _LIBCPP_HIDE_FROM_ABI _ForwardIterator 275 find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { 276 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators"); 277 using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>; 278 return __pstl::__handle_exception<_Implementation>( 279 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 280 } 281 282 template <class _ExecutionPolicy, 283 class _ForwardIterator, 284 class _Tp, 285 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 286 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 287 _LIBCPP_HIDE_FROM_ABI _ForwardIterator 288 find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { 289 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators"); 290 using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>; 291 return __pstl::__handle_exception<_Implementation>( 292 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value); 293 } 294 295 template <class _ExecutionPolicy, 296 class _ForwardIterator, 297 class _Function, 298 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 299 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 300 _LIBCPP_HIDE_FROM_ABI void 301 for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) { 302 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators"); 303 using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>; 304 __pstl::__handle_exception<_Implementation>( 305 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func)); 306 } 307 308 template <class _ExecutionPolicy, 309 class _ForwardIterator, 310 class _Size, 311 class _Function, 312 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 313 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 314 _LIBCPP_HIDE_FROM_ABI void 315 for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) { 316 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator"); 317 using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>; 318 __pstl::__handle_exception<_Implementation>( 319 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func)); 320 } 321 322 template <class _ExecutionPolicy, 323 class _ForwardIterator, 324 class _Generator, 325 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 326 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 327 _LIBCPP_HIDE_FROM_ABI void 328 generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) { 329 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators"); 330 using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>; 331 __pstl::__handle_exception<_Implementation>( 332 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen)); 333 } 334 335 template <class _ExecutionPolicy, 336 class _ForwardIterator, 337 class _Size, 338 class _Generator, 339 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 340 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 341 _LIBCPP_HIDE_FROM_ABI void 342 generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) { 343 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator"); 344 using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>; 345 __pstl::__handle_exception<_Implementation>( 346 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen)); 347 } 348 349 template <class _ExecutionPolicy, 350 class _ForwardIterator, 351 class _Predicate, 352 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 353 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 354 _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool 355 is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) { 356 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators"); 357 using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>; 358 return __pstl::__handle_exception<_Implementation>( 359 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred)); 360 } 361 362 template <class _ExecutionPolicy, 363 class _ForwardIterator1, 364 class _ForwardIterator2, 365 class _ForwardOutIterator, 366 class _Comp, 367 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 368 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 369 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator 370 merge(_ExecutionPolicy&& __policy, 371 _ForwardIterator1 __first1, 372 _ForwardIterator1 __last1, 373 _ForwardIterator2 __first2, 374 _ForwardIterator2 __last2, 375 _ForwardOutIterator __result, 376 _Comp __comp) { 377 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators"); 378 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators"); 379 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator"); 380 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator"); 381 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>; 382 return __pstl::__handle_exception<_Implementation>( 383 std::forward<_ExecutionPolicy>(__policy), 384 std::move(__first1), 385 std::move(__last1), 386 std::move(__first2), 387 std::move(__last2), 388 std::move(__result), 389 std::move(__comp)); 390 } 391 392 template <class _ExecutionPolicy, 393 class _ForwardIterator1, 394 class _ForwardIterator2, 395 class _ForwardOutIterator, 396 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 397 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 398 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator 399 merge(_ExecutionPolicy&& __policy, 400 _ForwardIterator1 __first1, 401 _ForwardIterator1 __last1, 402 _ForwardIterator2 __first2, 403 _ForwardIterator2 __last2, 404 _ForwardOutIterator __result) { 405 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators"); 406 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators"); 407 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator"); 408 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator"); 409 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>; 410 return __pstl::__handle_exception<_Implementation>( 411 std::forward<_ExecutionPolicy>(__policy), 412 std::move(__first1), 413 std::move(__last1), 414 std::move(__first2), 415 std::move(__last2), 416 std::move(__result), 417 less{}); 418 } 419 420 template <class _ExecutionPolicy, 421 class _ForwardIterator, 422 class _ForwardOutIterator, 423 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 424 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 425 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator 426 move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) { 427 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators"); 428 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator"); 429 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 430 _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator"); 431 using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>; 432 return __pstl::__handle_exception<_Implementation>( 433 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result)); 434 } 435 436 template <class _ExecutionPolicy, 437 class _ForwardIterator, 438 class _Pred, 439 class _Tp, 440 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 441 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 442 _LIBCPP_HIDE_FROM_ABI void 443 replace_if(_ExecutionPolicy&& __policy, 444 _ForwardIterator __first, 445 _ForwardIterator __last, 446 _Pred __pred, 447 const _Tp& __new_value) { 448 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators"); 449 using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>; 450 __pstl::__handle_exception<_Implementation>( 451 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value); 452 } 453 454 template <class _ExecutionPolicy, 455 class _ForwardIterator, 456 class _Tp, 457 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 458 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 459 _LIBCPP_HIDE_FROM_ABI void 460 replace(_ExecutionPolicy&& __policy, 461 _ForwardIterator __first, 462 _ForwardIterator __last, 463 const _Tp& __old_value, 464 const _Tp& __new_value) { 465 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators"); 466 using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>; 467 __pstl::__handle_exception<_Implementation>( 468 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value); 469 } 470 471 template <class _ExecutionPolicy, 472 class _ForwardIterator, 473 class _ForwardOutIterator, 474 class _Pred, 475 class _Tp, 476 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 477 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 478 _LIBCPP_HIDE_FROM_ABI void replace_copy_if( 479 _ExecutionPolicy&& __policy, 480 _ForwardIterator __first, 481 _ForwardIterator __last, 482 _ForwardOutIterator __result, 483 _Pred __pred, 484 const _Tp& __new_value) { 485 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators"); 486 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators"); 487 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 488 _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator"); 489 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator"); 490 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>; 491 __pstl::__handle_exception<_Implementation>( 492 std::forward<_ExecutionPolicy>(__policy), 493 std::move(__first), 494 std::move(__last), 495 std::move(__result), 496 std::move(__pred), 497 __new_value); 498 } 499 500 template <class _ExecutionPolicy, 501 class _ForwardIterator, 502 class _ForwardOutIterator, 503 class _Tp, 504 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 505 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 506 _LIBCPP_HIDE_FROM_ABI void replace_copy( 507 _ExecutionPolicy&& __policy, 508 _ForwardIterator __first, 509 _ForwardIterator __last, 510 _ForwardOutIterator __result, 511 const _Tp& __old_value, 512 const _Tp& __new_value) { 513 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators"); 514 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators"); 515 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 516 _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator"); 517 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator"); 518 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>; 519 __pstl::__handle_exception<_Implementation>( 520 std::forward<_ExecutionPolicy>(__policy), 521 std::move(__first), 522 std::move(__last), 523 std::move(__result), 524 __old_value, 525 __new_value); 526 } 527 528 template <class _ExecutionPolicy, 529 class _ForwardIterator, 530 class _ForwardOutIterator, 531 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 532 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 533 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator rotate_copy( 534 _ExecutionPolicy&& __policy, 535 _ForwardIterator __first, 536 _ForwardIterator __middle, 537 _ForwardIterator __last, 538 _ForwardOutIterator __result) { 539 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators"); 540 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators"); 541 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 542 _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator"); 543 using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>; 544 return __pstl::__handle_exception<_Implementation>( 545 std::forward<_ExecutionPolicy>(__policy), 546 std::move(__first), 547 std::move(__middle), 548 std::move(__last), 549 std::move(__result)); 550 } 551 552 template <class _ExecutionPolicy, 553 class _RandomAccessIterator, 554 class _Comp, 555 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 556 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 557 _LIBCPP_HIDE_FROM_ABI void 558 sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) { 559 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators"); 560 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>; 561 __pstl::__handle_exception<_Implementation>( 562 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp)); 563 } 564 565 template <class _ExecutionPolicy, 566 class _RandomAccessIterator, 567 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 568 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 569 _LIBCPP_HIDE_FROM_ABI void 570 sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) { 571 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators"); 572 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>; 573 __pstl::__handle_exception<_Implementation>( 574 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{}); 575 } 576 577 template <class _ExecutionPolicy, 578 class _RandomAccessIterator, 579 class _Comp, 580 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 581 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 582 _LIBCPP_HIDE_FROM_ABI void 583 stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) { 584 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators"); 585 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>; 586 __pstl::__handle_exception<_Implementation>( 587 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp)); 588 } 589 590 template <class _ExecutionPolicy, 591 class _RandomAccessIterator, 592 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 593 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 594 _LIBCPP_HIDE_FROM_ABI void 595 stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) { 596 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators"); 597 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>; 598 __pstl::__handle_exception<_Implementation>( 599 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{}); 600 } 601 602 template <class _ExecutionPolicy, 603 class _ForwardIterator, 604 class _ForwardOutIterator, 605 class _UnaryOperation, 606 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 607 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 608 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform( 609 _ExecutionPolicy&& __policy, 610 _ForwardIterator __first, 611 _ForwardIterator __last, 612 _ForwardOutIterator __result, 613 _UnaryOperation __op) { 614 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators"); 615 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator"); 616 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 617 _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator"); 618 using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>; 619 return __pstl::__handle_exception<_Implementation>( 620 std::forward<_ExecutionPolicy>(__policy), 621 std::move(__first), 622 std::move(__last), 623 std::move(__result), 624 std::move(__op)); 625 } 626 627 template <class _ExecutionPolicy, 628 class _ForwardIterator1, 629 class _ForwardIterator2, 630 class _ForwardOutIterator, 631 class _BinaryOperation, 632 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>, 633 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0> 634 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform( 635 _ExecutionPolicy&& __policy, 636 _ForwardIterator1 __first1, 637 _ForwardIterator1 __last1, 638 _ForwardIterator2 __first2, 639 _ForwardOutIterator __result, 640 _BinaryOperation __op) { 641 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators"); 642 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators"); 643 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator"); 644 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR( 645 _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator"); 646 using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>; 647 return __pstl::__handle_exception<_Implementation>( 648 std::forward<_ExecutionPolicy>(__policy), 649 std::move(__first1), 650 std::move(__last1), 651 std::move(__first2), 652 std::move(__result), 653 std::move(__op)); 654 } 655 656 _LIBCPP_END_NAMESPACE_STD 657 658 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17 659 660 _LIBCPP_POP_MACROS 661 662 #endif // _LIBCPP___ALGORITHM_PSTL_H 663