51131edf83
Reviewed By: #libc, ldionne Spies: ldionne, libcxx-commits Differential Revision: https://reviews.llvm.org/D151841
973 lines
44 KiB
C++
973 lines
44 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _PSTL_GLUE_ALGORITHM_IMPL_H
|
|
#define _PSTL_GLUE_ALGORITHM_IMPL_H
|
|
|
|
#include <__config>
|
|
#include <functional>
|
|
|
|
#include "algorithm_fwd.h"
|
|
#include "execution_defs.h"
|
|
#include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */
|
|
#include "utils.h"
|
|
|
|
#include "execution_impl.h"
|
|
|
|
namespace std {
|
|
|
|
// [alg.find.end]
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
|
|
find_end(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __s_first,
|
|
_ForwardIterator2 __s_last,
|
|
_BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
|
|
|
|
return __pstl::__internal::__pattern_find_end(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
|
|
find_end(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __s_first,
|
|
_ForwardIterator2 __s_last) {
|
|
return std::find_end(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
|
|
}
|
|
|
|
// [alg.find_first_of]
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __s_first,
|
|
_ForwardIterator2 __s_last,
|
|
_BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
|
|
|
|
return __pstl::__internal::__pattern_find_first_of(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
|
|
find_first_of(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __s_first,
|
|
_ForwardIterator2 __s_last) {
|
|
return std::find_first_of(
|
|
std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
|
|
}
|
|
|
|
// [alg.adjacent_find]
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
|
|
return __pstl::__internal::__pattern_adjacent_find(
|
|
__dispatch_tag,
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
std::equal_to<_ValueType>(),
|
|
/*first_semantic*/ false);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_adjacent_find(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, /*first_semantic*/ false);
|
|
}
|
|
|
|
// [alg.count]
|
|
|
|
// Implementation note: count and count_if call the pattern directly instead of calling std::transform_reduce
|
|
// so that we do not have to include <numeric>.
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
|
|
typename iterator_traits<_ForwardIterator>::difference_type>
|
|
count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
|
|
return __pstl::__internal::__pattern_count(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value](const _ValueType& __x) {
|
|
return __value == __x;
|
|
});
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
|
|
typename iterator_traits<_ForwardIterator>::difference_type>
|
|
count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_count(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
|
|
}
|
|
|
|
// [alg.search]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
|
|
search(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __s_first,
|
|
_ForwardIterator2 __s_last,
|
|
_BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
|
|
|
|
return __pstl::__internal::__pattern_search(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
|
|
search(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __s_first,
|
|
_ForwardIterator2 __s_last) {
|
|
return std::search(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
search_n(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator __first,
|
|
_ForwardIterator __last,
|
|
_Size __count,
|
|
const _Tp& __value,
|
|
_BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_search_n(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(
|
|
_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
|
|
return std::search_n(
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__count,
|
|
__value,
|
|
std::equal_to<typename iterator_traits<_ForwardIterator>::value_type>());
|
|
}
|
|
|
|
// [alg.copy]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
|
|
copy_if(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __result,
|
|
_Predicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
|
|
|
|
return __pstl::__internal::__pattern_copy_if(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred);
|
|
}
|
|
|
|
// [alg.swap]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> swap_ranges(
|
|
_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
|
|
typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
|
|
typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
|
|
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
|
|
|
|
return __pstl::__internal::__pattern_walk2(
|
|
__dispatch_tag,
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first1,
|
|
__last1,
|
|
__first2,
|
|
[](_ReferenceType1 __x, _ReferenceType2 __y) {
|
|
using std::swap;
|
|
swap(__x, __y);
|
|
});
|
|
}
|
|
|
|
// [alg.generate]
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
__pstl::__internal::__pattern_generate(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __g);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, _Generator __g) {
|
|
if (__count <= 0)
|
|
return __first;
|
|
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_generate_n(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __count, __g);
|
|
}
|
|
|
|
// [alg.remove]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy_if(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __result,
|
|
_Predicate __pred) {
|
|
return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, std::not_fn(__pred));
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
|
|
remove_copy(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __result,
|
|
const _Tp& __value) {
|
|
return std::copy_if(
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__result,
|
|
__pstl::__internal::__not_equal_value<_Tp>(__value));
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_remove_if(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
|
|
return std::remove_if(
|
|
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__equal_value<_Tp>(__value));
|
|
}
|
|
|
|
// [alg.unique]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_unique(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
return std::unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
|
|
unique_copy(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __result,
|
|
_BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
|
|
|
|
return __pstl::__internal::__pattern_unique_copy(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(
|
|
_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) {
|
|
return std::unique_copy(__exec, __first, __last, __result, std::equal_to<>());
|
|
}
|
|
|
|
// [alg.reverse]
|
|
|
|
template <class _ExecutionPolicy, class _BidirectionalIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
__pstl::__internal::__pattern_reverse(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
reverse_copy(_ExecutionPolicy&& __exec,
|
|
_BidirectionalIterator __first,
|
|
_BidirectionalIterator __last,
|
|
_ForwardIterator __d_first) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
|
|
|
|
return __pstl::__internal::__pattern_reverse_copy(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first);
|
|
}
|
|
|
|
// [alg.rotate]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_rotate(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
|
|
rotate_copy(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first,
|
|
_ForwardIterator1 __middle,
|
|
_ForwardIterator1 __last,
|
|
_ForwardIterator2 __result) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
|
|
|
|
return __pstl::__internal::__pattern_rotate_copy(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result);
|
|
}
|
|
|
|
// [alg.partitions]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_is_partitioned(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_partition(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> stable_partition(
|
|
_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_stable_partition(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy,
|
|
class _ForwardIterator,
|
|
class _ForwardIterator1,
|
|
class _ForwardIterator2,
|
|
class _UnaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
|
|
partition_copy(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator __first,
|
|
_ForwardIterator __last,
|
|
_ForwardIterator1 __out_true,
|
|
_ForwardIterator2 __out_false,
|
|
_UnaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __out_true, __out_false);
|
|
|
|
return __pstl::__internal::__pattern_partition_copy(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred);
|
|
}
|
|
|
|
// [alg.sort]
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
return __pstl::__internal::__pattern_sort(
|
|
__dispatch_tag,
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__comp,
|
|
typename std::is_move_constructible<_InputType>::type());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
|
|
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
std::sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [stable.sort]
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_stable_sort(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
|
|
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
std::stable_sort(__exec, __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [mismatch]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
|
|
mismatch(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_BinaryPredicate __pred) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
|
|
|
|
return __pstl::__internal::__pattern_mismatch(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
|
|
mismatch(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_BinaryPredicate __pred) {
|
|
return std::mismatch(
|
|
__exec, __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1)), __pred);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
|
|
mismatch(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2) {
|
|
return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::equal_to<>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
|
|
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
|
|
// TODO: to get rid of "distance"
|
|
return std::mismatch(
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first1,
|
|
__last1,
|
|
__first2,
|
|
std::next(__first2, std::distance(__first1, __last1)));
|
|
}
|
|
|
|
// [alg.equal]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
equal(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_BinaryPredicate __p) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
|
|
|
|
return __pstl::__internal::__pattern_equal(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
|
|
return std::equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, std::equal_to<>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
equal(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_BinaryPredicate __p) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
|
|
|
|
return __pstl::__internal::__pattern_equal(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __p);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
equal(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2) {
|
|
return equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::equal_to<>());
|
|
}
|
|
|
|
// [alg.move]
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
|
|
move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
|
|
|
|
using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
|
|
|
|
return __pstl::__internal::__pattern_walk2_brick(
|
|
__dispatch_tag,
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__d_first,
|
|
[](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
|
|
return __pstl::__internal::__brick_move(__begin, __end, __res, __is_vector{});
|
|
});
|
|
}
|
|
|
|
// [partial.sort]
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
partial_sort(_ExecutionPolicy&& __exec,
|
|
_RandomAccessIterator __first,
|
|
_RandomAccessIterator __middle,
|
|
_RandomAccessIterator __last,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
__pstl::__internal::__pattern_partial_sort(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
partial_sort(_ExecutionPolicy&& __exec,
|
|
_RandomAccessIterator __first,
|
|
_RandomAccessIterator __middle,
|
|
_RandomAccessIterator __last) {
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
std::partial_sort(__exec, __first, __middle, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [partial.sort.copy]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator __first,
|
|
_ForwardIterator __last,
|
|
_RandomAccessIterator __d_first,
|
|
_RandomAccessIterator __d_last,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
|
|
|
|
return __pstl::__internal::__pattern_partial_sort_copy(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator __first,
|
|
_ForwardIterator __last,
|
|
_RandomAccessIterator __d_first,
|
|
_RandomAccessIterator __d_last) {
|
|
return std::partial_sort_copy(
|
|
std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, std::less<>());
|
|
}
|
|
|
|
// [is.sorted]
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
const _ForwardIterator __res = __pstl::__internal::__pattern_adjacent_find(
|
|
__dispatch_tag,
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__pstl::__internal::__reorder_pred<_Compare>(__comp),
|
|
/*first_semantic*/ false);
|
|
return __res == __last ? __last : std::next(__res);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
|
|
return is_sorted_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_adjacent_find(
|
|
__dispatch_tag,
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__pstl::__internal::__reorder_pred<_Compare>(__comp),
|
|
/*or_semantic*/ true) == __last;
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
|
|
return std::is_sorted(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [alg.merge]
|
|
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
inplace_merge(_ExecutionPolicy&& __exec,
|
|
_BidirectionalIterator __first,
|
|
_BidirectionalIterator __middle,
|
|
_BidirectionalIterator __last,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
__pstl::__internal::__pattern_inplace_merge(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _BidirectionalIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
inplace_merge(_ExecutionPolicy&& __exec,
|
|
_BidirectionalIterator __first,
|
|
_BidirectionalIterator __middle,
|
|
_BidirectionalIterator __last) {
|
|
typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _InputType;
|
|
std::inplace_merge(__exec, __first, __middle, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [includes]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
includes(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
|
|
|
|
return __pstl::__internal::__pattern_includes(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
includes(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2) {
|
|
return std::includes(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::less<>());
|
|
}
|
|
|
|
// [set.union]
|
|
|
|
template <class _ExecutionPolicy,
|
|
class _ForwardIterator1,
|
|
class _ForwardIterator2,
|
|
class _ForwardIterator,
|
|
class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
set_union(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
|
|
|
|
return __pstl::__internal::__pattern_set_union(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
set_union(_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result) {
|
|
return std::set_union(
|
|
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
|
|
}
|
|
|
|
// [set.intersection]
|
|
|
|
template <class _ExecutionPolicy,
|
|
class _ForwardIterator1,
|
|
class _ForwardIterator2,
|
|
class _ForwardIterator,
|
|
class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
|
|
|
|
return __pstl::__internal::__pattern_set_intersection(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result) {
|
|
return std::set_intersection(
|
|
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
|
|
}
|
|
|
|
// [set.difference]
|
|
|
|
template <class _ExecutionPolicy,
|
|
class _ForwardIterator1,
|
|
class _ForwardIterator2,
|
|
class _ForwardIterator,
|
|
class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
|
|
|
|
return __pstl::__internal::__pattern_set_difference(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result) {
|
|
return std::set_difference(
|
|
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
|
|
}
|
|
|
|
// [set.symmetric.difference]
|
|
|
|
template <class _ExecutionPolicy,
|
|
class _ForwardIterator1,
|
|
class _ForwardIterator2,
|
|
class _ForwardIterator,
|
|
class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
|
|
|
|
return __pstl::__internal::__pattern_set_symmetric_difference(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_ForwardIterator __result) {
|
|
return std::set_symmetric_difference(
|
|
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
|
|
}
|
|
|
|
// [is.heap]
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
|
|
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
return __pstl::__internal::__pattern_is_heap_until(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
|
|
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
|
|
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
|
|
return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp) == __last;
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
|
|
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
|
|
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
return std::is_heap(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [alg.min.max]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_min_element(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
|
|
return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
|
|
return min_element(
|
|
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred<_Compare>(__comp));
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
|
|
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
|
|
return std::min_element(
|
|
std::forward<_ExecutionPolicy>(__exec),
|
|
__first,
|
|
__last,
|
|
__pstl::__internal::__reorder_pred<std::less<_InputType>>(std::less<_InputType>()));
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
|
|
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
return __pstl::__internal::__pattern_minmax_element(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
|
|
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
|
|
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
|
|
return std::minmax_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_ValueType>());
|
|
}
|
|
|
|
// [alg.nth.element]
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
nth_element(_ExecutionPolicy&& __exec,
|
|
_RandomAccessIterator __first,
|
|
_RandomAccessIterator __nth,
|
|
_RandomAccessIterator __last,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
|
|
|
|
__pstl::__internal::__pattern_nth_element(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _RandomAccessIterator>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
|
|
nth_element(_ExecutionPolicy&& __exec,
|
|
_RandomAccessIterator __first,
|
|
_RandomAccessIterator __nth,
|
|
_RandomAccessIterator __last) {
|
|
typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
|
|
std::nth_element(std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, std::less<_InputType>());
|
|
}
|
|
|
|
// [alg.lex.comparison]
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2,
|
|
_Compare __comp) {
|
|
auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
|
|
|
|
return __pstl::__internal::__pattern_lexicographical_compare(
|
|
__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp);
|
|
}
|
|
|
|
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
|
|
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
|
|
_ExecutionPolicy&& __exec,
|
|
_ForwardIterator1 __first1,
|
|
_ForwardIterator1 __last1,
|
|
_ForwardIterator2 __first2,
|
|
_ForwardIterator2 __last2) {
|
|
return std::lexicographical_compare(
|
|
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::less<>());
|
|
}
|
|
|
|
} // namespace std
|
|
|
|
#endif /* _PSTL_GLUE_ALGORITHM_IMPL_H */
|