File indexing completed on 2026-05-03 08:13:09
0001
0002
0003
0004
0005
0006
0007
0008
0009 #ifndef _LIBCPP___ALGORITHM_PSTL_H
0010 #define _LIBCPP___ALGORITHM_PSTL_H
0011
0012 #include <__config>
0013
0014 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0015 # pragma GCC system_header
0016 #endif
0017
0018 _LIBCPP_PUSH_MACROS
0019 #include <__undef_macros>
0020
0021 #if _LIBCPP_HAS_EXPERIMENTAL_PSTL && _LIBCPP_STD_VER >= 17
0022
0023 # include <__functional/operations.h>
0024 # include <__iterator/cpp17_iterator_concepts.h>
0025 # include <__iterator/iterator_traits.h>
0026 # include <__pstl/backend.h>
0027 # include <__pstl/dispatch.h>
0028 # include <__pstl/handle_exception.h>
0029 # include <__type_traits/enable_if.h>
0030 # include <__type_traits/is_execution_policy.h>
0031 # include <__type_traits/remove_cvref.h>
0032 # include <__utility/forward.h>
0033 # include <__utility/move.h>
0034
0035 _LIBCPP_BEGIN_NAMESPACE_STD
0036
0037 template <class _ExecutionPolicy,
0038 class _ForwardIterator,
0039 class _Predicate,
0040 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0041 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0042 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
0043 any_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
0044 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "any_of requires a ForwardIterator");
0045 using _Implementation = __pstl::__dispatch<__pstl::__any_of, __pstl::__current_configuration, _RawPolicy>;
0046 return __pstl::__handle_exception<_Implementation>(
0047 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0048 }
0049
0050 template <class _ExecutionPolicy,
0051 class _ForwardIterator,
0052 class _Pred,
0053 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0054 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0055 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
0056 all_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
0057 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "all_of requires a ForwardIterator");
0058 using _Implementation = __pstl::__dispatch<__pstl::__all_of, __pstl::__current_configuration, _RawPolicy>;
0059 return __pstl::__handle_exception<_Implementation>(
0060 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0061 }
0062
0063 template <class _ExecutionPolicy,
0064 class _ForwardIterator,
0065 class _Pred,
0066 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0067 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0068 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
0069 none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
0070 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "none_of requires a ForwardIterator");
0071 using _Implementation = __pstl::__dispatch<__pstl::__none_of, __pstl::__current_configuration, _RawPolicy>;
0072 return __pstl::__handle_exception<_Implementation>(
0073 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0074 }
0075
0076 template <class _ExecutionPolicy,
0077 class _ForwardIterator,
0078 class _ForwardOutIterator,
0079 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0080 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0081 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
0082 copy(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
0083 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
0084 _ForwardIterator, "copy(first, last, result) requires [first, last) to be ForwardIterators");
0085 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
0086 _ForwardOutIterator, "copy(first, last, result) requires result to be a ForwardIterator");
0087 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0088 _ForwardOutIterator, decltype(*__first), "copy(first, last, result) requires result to be an OutputIterator");
0089 using _Implementation = __pstl::__dispatch<__pstl::__copy, __pstl::__current_configuration, _RawPolicy>;
0090 return __pstl::__handle_exception<_Implementation>(
0091 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
0092 }
0093
0094 template <class _ExecutionPolicy,
0095 class _ForwardIterator,
0096 class _ForwardOutIterator,
0097 class _Size,
0098 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0099 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0100 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
0101 copy_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __result) {
0102 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
0103 _ForwardIterator, "copy_n(first, n, result) requires first to be a ForwardIterator");
0104 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
0105 _ForwardOutIterator, "copy_n(first, n, result) requires result to be a ForwardIterator");
0106 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0107 _ForwardOutIterator, decltype(*__first), "copy_n(first, n, result) requires result to be an OutputIterator");
0108 using _Implementation = __pstl::__dispatch<__pstl::__copy_n, __pstl::__current_configuration, _RawPolicy>;
0109 return __pstl::__handle_exception<_Implementation>(
0110 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__result));
0111 }
0112
0113 template <class _ExecutionPolicy,
0114 class _ForwardIterator,
0115 class _Predicate,
0116 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0117 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0118 _LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator>
0119 count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
0120 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
0121 _ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");
0122 using _Implementation = __pstl::__dispatch<__pstl::__count_if, __pstl::__current_configuration, _RawPolicy>;
0123 return __pstl::__handle_exception<_Implementation>(
0124 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0125 }
0126
0127 template <class _ExecutionPolicy,
0128 class _ForwardIterator,
0129 class _Tp,
0130 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0131 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0132 _LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator>
0133 count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
0134 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
0135 _ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");
0136 using _Implementation = __pstl::__dispatch<__pstl::__count, __pstl::__current_configuration, _RawPolicy>;
0137 return __pstl::__handle_exception<_Implementation>(
0138 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
0139 }
0140
0141 template <class _ExecutionPolicy,
0142 class _ForwardIterator1,
0143 class _ForwardIterator2,
0144 class _Pred,
0145 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0146 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0147 _LIBCPP_HIDE_FROM_ABI bool
0148 equal(_ExecutionPolicy&& __policy,
0149 _ForwardIterator1 __first1,
0150 _ForwardIterator1 __last1,
0151 _ForwardIterator2 __first2,
0152 _Pred __pred) {
0153 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
0154 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
0155 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
0156 return __pstl::__handle_exception<_Implementation>(
0157 std::forward<_ExecutionPolicy>(__policy),
0158 std::move(__first1),
0159 std::move(__last1),
0160 std::move(__first2),
0161 std::move(__pred));
0162 }
0163
0164 template <class _ExecutionPolicy,
0165 class _ForwardIterator1,
0166 class _ForwardIterator2,
0167 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0168 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0169 _LIBCPP_HIDE_FROM_ABI bool
0170 equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
0171 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
0172 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
0173 using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
0174 return __pstl::__handle_exception<_Implementation>(
0175 std::forward<_ExecutionPolicy>(__policy),
0176 std::move(__first1),
0177 std::move(__last1),
0178 std::move(__first2),
0179 equal_to{});
0180 }
0181
0182 template <class _ExecutionPolicy,
0183 class _ForwardIterator1,
0184 class _ForwardIterator2,
0185 class _Pred,
0186 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0187 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0188 _LIBCPP_HIDE_FROM_ABI bool
0189 equal(_ExecutionPolicy&& __policy,
0190 _ForwardIterator1 __first1,
0191 _ForwardIterator1 __last1,
0192 _ForwardIterator2 __first2,
0193 _ForwardIterator2 __last2,
0194 _Pred __pred) {
0195 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
0196 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
0197 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
0198 return __pstl::__handle_exception<_Implementation>(
0199 std::forward<_ExecutionPolicy>(__policy),
0200 std::move(__first1),
0201 std::move(__last1),
0202 std::move(__first2),
0203 std::move(__last2),
0204 std::move(__pred));
0205 }
0206
0207 template <class _ExecutionPolicy,
0208 class _ForwardIterator1,
0209 class _ForwardIterator2,
0210 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0211 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0212 _LIBCPP_HIDE_FROM_ABI bool
0213 equal(_ExecutionPolicy&& __policy,
0214 _ForwardIterator1 __first1,
0215 _ForwardIterator1 __last1,
0216 _ForwardIterator2 __first2,
0217 _ForwardIterator2 __last2) {
0218 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
0219 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
0220 using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
0221 return __pstl::__handle_exception<_Implementation>(
0222 std::forward<_ExecutionPolicy>(__policy),
0223 std::move(__first1),
0224 std::move(__last1),
0225 std::move(__first2),
0226 std::move(__last2),
0227 equal_to{});
0228 }
0229
0230 template <class _ExecutionPolicy,
0231 class _ForwardIterator,
0232 class _Tp,
0233 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0234 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0235 _LIBCPP_HIDE_FROM_ABI void
0236 fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
0237 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators");
0238 using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>;
0239 __pstl::__handle_exception<_Implementation>(
0240 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
0241 }
0242
0243 template <class _ExecutionPolicy,
0244 class _ForwardIterator,
0245 class _Size,
0246 class _Tp,
0247 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0248 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0249 _LIBCPP_HIDE_FROM_ABI void
0250 fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) {
0251 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator");
0252 using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>;
0253 __pstl::__handle_exception<_Implementation>(
0254 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value);
0255 }
0256
0257 template <class _ExecutionPolicy,
0258 class _ForwardIterator,
0259 class _Predicate,
0260 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0261 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0262 _LIBCPP_HIDE_FROM_ABI _ForwardIterator
0263 find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
0264 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
0265 using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
0266 return __pstl::__handle_exception<_Implementation>(
0267 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0268 }
0269
0270 template <class _ExecutionPolicy,
0271 class _ForwardIterator,
0272 class _Predicate,
0273 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0274 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0275 _LIBCPP_HIDE_FROM_ABI _ForwardIterator
0276 find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
0277 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
0278 using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
0279 return __pstl::__handle_exception<_Implementation>(
0280 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0281 }
0282
0283 template <class _ExecutionPolicy,
0284 class _ForwardIterator,
0285 class _Tp,
0286 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0287 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0288 _LIBCPP_HIDE_FROM_ABI _ForwardIterator
0289 find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
0290 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
0291 using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;
0292 return __pstl::__handle_exception<_Implementation>(
0293 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
0294 }
0295
0296 template <class _ExecutionPolicy,
0297 class _ForwardIterator,
0298 class _Function,
0299 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0300 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0301 _LIBCPP_HIDE_FROM_ABI void
0302 for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
0303 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators");
0304 using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>;
0305 __pstl::__handle_exception<_Implementation>(
0306 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func));
0307 }
0308
0309 template <class _ExecutionPolicy,
0310 class _ForwardIterator,
0311 class _Size,
0312 class _Function,
0313 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0314 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0315 _LIBCPP_HIDE_FROM_ABI void
0316 for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
0317 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator");
0318 using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>;
0319 __pstl::__handle_exception<_Implementation>(
0320 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func));
0321 }
0322
0323 template <class _ExecutionPolicy,
0324 class _ForwardIterator,
0325 class _Generator,
0326 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0327 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0328 _LIBCPP_HIDE_FROM_ABI void
0329 generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
0330 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators");
0331 using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>;
0332 __pstl::__handle_exception<_Implementation>(
0333 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen));
0334 }
0335
0336 template <class _ExecutionPolicy,
0337 class _ForwardIterator,
0338 class _Size,
0339 class _Generator,
0340 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0341 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0342 _LIBCPP_HIDE_FROM_ABI void
0343 generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) {
0344 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator");
0345 using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>;
0346 __pstl::__handle_exception<_Implementation>(
0347 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen));
0348 }
0349
0350 template <class _ExecutionPolicy,
0351 class _ForwardIterator,
0352 class _Predicate,
0353 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0354 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0355 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
0356 is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
0357 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators");
0358 using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>;
0359 return __pstl::__handle_exception<_Implementation>(
0360 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
0361 }
0362
0363 template <class _ExecutionPolicy,
0364 class _ForwardIterator1,
0365 class _ForwardIterator2,
0366 class _ForwardOutIterator,
0367 class _Comp,
0368 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0369 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0370 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
0371 merge(_ExecutionPolicy&& __policy,
0372 _ForwardIterator1 __first1,
0373 _ForwardIterator1 __last1,
0374 _ForwardIterator2 __first2,
0375 _ForwardIterator2 __last2,
0376 _ForwardOutIterator __result,
0377 _Comp __comp) {
0378 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
0379 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
0380 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
0381 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
0382 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
0383 return __pstl::__handle_exception<_Implementation>(
0384 std::forward<_ExecutionPolicy>(__policy),
0385 std::move(__first1),
0386 std::move(__last1),
0387 std::move(__first2),
0388 std::move(__last2),
0389 std::move(__result),
0390 std::move(__comp));
0391 }
0392
0393 template <class _ExecutionPolicy,
0394 class _ForwardIterator1,
0395 class _ForwardIterator2,
0396 class _ForwardOutIterator,
0397 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0398 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0399 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
0400 merge(_ExecutionPolicy&& __policy,
0401 _ForwardIterator1 __first1,
0402 _ForwardIterator1 __last1,
0403 _ForwardIterator2 __first2,
0404 _ForwardIterator2 __last2,
0405 _ForwardOutIterator __result) {
0406 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
0407 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
0408 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
0409 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
0410 using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
0411 return __pstl::__handle_exception<_Implementation>(
0412 std::forward<_ExecutionPolicy>(__policy),
0413 std::move(__first1),
0414 std::move(__last1),
0415 std::move(__first2),
0416 std::move(__last2),
0417 std::move(__result),
0418 less{});
0419 }
0420
0421 template <class _ExecutionPolicy,
0422 class _ForwardIterator,
0423 class _ForwardOutIterator,
0424 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0425 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0426 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
0427 move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
0428 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators");
0429 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator");
0430 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0431 _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator");
0432 using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>;
0433 return __pstl::__handle_exception<_Implementation>(
0434 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
0435 }
0436
0437 template <class _ExecutionPolicy,
0438 class _ForwardIterator,
0439 class _Pred,
0440 class _Tp,
0441 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0442 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0443 _LIBCPP_HIDE_FROM_ABI void
0444 replace_if(_ExecutionPolicy&& __policy,
0445 _ForwardIterator __first,
0446 _ForwardIterator __last,
0447 _Pred __pred,
0448 const _Tp& __new_value) {
0449 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators");
0450 using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>;
0451 __pstl::__handle_exception<_Implementation>(
0452 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value);
0453 }
0454
0455 template <class _ExecutionPolicy,
0456 class _ForwardIterator,
0457 class _Tp,
0458 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0459 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0460 _LIBCPP_HIDE_FROM_ABI void
0461 replace(_ExecutionPolicy&& __policy,
0462 _ForwardIterator __first,
0463 _ForwardIterator __last,
0464 const _Tp& __old_value,
0465 const _Tp& __new_value) {
0466 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators");
0467 using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>;
0468 __pstl::__handle_exception<_Implementation>(
0469 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value);
0470 }
0471
0472 template <class _ExecutionPolicy,
0473 class _ForwardIterator,
0474 class _ForwardOutIterator,
0475 class _Pred,
0476 class _Tp,
0477 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0478 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0479 _LIBCPP_HIDE_FROM_ABI void replace_copy_if(
0480 _ExecutionPolicy&& __policy,
0481 _ForwardIterator __first,
0482 _ForwardIterator __last,
0483 _ForwardOutIterator __result,
0484 _Pred __pred,
0485 const _Tp& __new_value) {
0486 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators");
0487 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators");
0488 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0489 _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator");
0490 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
0491 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>;
0492 __pstl::__handle_exception<_Implementation>(
0493 std::forward<_ExecutionPolicy>(__policy),
0494 std::move(__first),
0495 std::move(__last),
0496 std::move(__result),
0497 std::move(__pred),
0498 __new_value);
0499 }
0500
0501 template <class _ExecutionPolicy,
0502 class _ForwardIterator,
0503 class _ForwardOutIterator,
0504 class _Tp,
0505 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0506 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0507 _LIBCPP_HIDE_FROM_ABI void replace_copy(
0508 _ExecutionPolicy&& __policy,
0509 _ForwardIterator __first,
0510 _ForwardIterator __last,
0511 _ForwardOutIterator __result,
0512 const _Tp& __old_value,
0513 const _Tp& __new_value) {
0514 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators");
0515 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators");
0516 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0517 _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator");
0518 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
0519 using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>;
0520 __pstl::__handle_exception<_Implementation>(
0521 std::forward<_ExecutionPolicy>(__policy),
0522 std::move(__first),
0523 std::move(__last),
0524 std::move(__result),
0525 __old_value,
0526 __new_value);
0527 }
0528
0529 template <class _ExecutionPolicy,
0530 class _ForwardIterator,
0531 class _ForwardOutIterator,
0532 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0533 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0534 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator rotate_copy(
0535 _ExecutionPolicy&& __policy,
0536 _ForwardIterator __first,
0537 _ForwardIterator __middle,
0538 _ForwardIterator __last,
0539 _ForwardOutIterator __result) {
0540 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators");
0541 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators");
0542 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0543 _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator");
0544 using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>;
0545 return __pstl::__handle_exception<_Implementation>(
0546 std::forward<_ExecutionPolicy>(__policy),
0547 std::move(__first),
0548 std::move(__middle),
0549 std::move(__last),
0550 std::move(__result));
0551 }
0552
0553 template <class _ExecutionPolicy,
0554 class _RandomAccessIterator,
0555 class _Comp,
0556 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0557 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0558 _LIBCPP_HIDE_FROM_ABI void
0559 sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
0560 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
0561 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
0562 __pstl::__handle_exception<_Implementation>(
0563 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
0564 }
0565
0566 template <class _ExecutionPolicy,
0567 class _RandomAccessIterator,
0568 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0569 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0570 _LIBCPP_HIDE_FROM_ABI void
0571 sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
0572 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
0573 using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
0574 __pstl::__handle_exception<_Implementation>(
0575 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
0576 }
0577
0578 template <class _ExecutionPolicy,
0579 class _RandomAccessIterator,
0580 class _Comp,
0581 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0582 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0583 _LIBCPP_HIDE_FROM_ABI void
0584 stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
0585 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
0586 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
0587 __pstl::__handle_exception<_Implementation>(
0588 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
0589 }
0590
0591 template <class _ExecutionPolicy,
0592 class _RandomAccessIterator,
0593 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0594 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0595 _LIBCPP_HIDE_FROM_ABI void
0596 stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
0597 _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
0598 using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
0599 __pstl::__handle_exception<_Implementation>(
0600 std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
0601 }
0602
0603 template <class _ExecutionPolicy,
0604 class _ForwardIterator,
0605 class _ForwardOutIterator,
0606 class _UnaryOperation,
0607 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0608 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0609 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
0610 _ExecutionPolicy&& __policy,
0611 _ForwardIterator __first,
0612 _ForwardIterator __last,
0613 _ForwardOutIterator __result,
0614 _UnaryOperation __op) {
0615 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators");
0616 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
0617 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0618 _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator");
0619 using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>;
0620 return __pstl::__handle_exception<_Implementation>(
0621 std::forward<_ExecutionPolicy>(__policy),
0622 std::move(__first),
0623 std::move(__last),
0624 std::move(__result),
0625 std::move(__op));
0626 }
0627
0628 template <class _ExecutionPolicy,
0629 class _ForwardIterator1,
0630 class _ForwardIterator2,
0631 class _ForwardOutIterator,
0632 class _BinaryOperation,
0633 class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
0634 enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
0635 _LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
0636 _ExecutionPolicy&& __policy,
0637 _ForwardIterator1 __first1,
0638 _ForwardIterator1 __last1,
0639 _ForwardIterator2 __first2,
0640 _ForwardOutIterator __result,
0641 _BinaryOperation __op) {
0642 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators");
0643 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators");
0644 _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
0645 _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
0646 _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator");
0647 using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>;
0648 return __pstl::__handle_exception<_Implementation>(
0649 std::forward<_ExecutionPolicy>(__policy),
0650 std::move(__first1),
0651 std::move(__last1),
0652 std::move(__first2),
0653 std::move(__result),
0654 std::move(__op));
0655 }
0656
0657 _LIBCPP_END_NAMESPACE_STD
0658
0659 #endif
0660
0661 _LIBCPP_POP_MACROS
0662
0663 #endif
