libcxx/include/__cxx03/__algorithm/pstl.h

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