| // -*- 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_ALGORITHM_FWD_H |
| #define _PSTL_ALGORITHM_FWD_H |
| |
| #include <__config> |
| #include <iterator> |
| #include <type_traits> |
| #include <utility> |
| |
| namespace __pstl { |
| namespace __internal { |
| |
| //------------------------------------------------------------------------ |
| // walk1 (pseudo) |
| // |
| // walk1 evaluates f(x) for each dereferenced value x drawn from [first,last) |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _Function> |
| void __brick_walk1(_ForwardIterator, |
| _ForwardIterator, |
| _Function, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _Function> |
| void __brick_walk1(_RandomAccessIterator, |
| _RandomAccessIterator, |
| _Function, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Function> |
| void __pattern_walk1(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Function> |
| void __pattern_walk1( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Function); |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Brick> |
| void __pattern_walk_brick(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Brick> |
| void __pattern_walk_brick( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Brick); |
| |
| //------------------------------------------------------------------------ |
| // walk1_n |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _Size, class _Function> |
| _ForwardIterator __brick_walk1_n( |
| _ForwardIterator, |
| _Size, |
| _Function, |
| /*_IsVectorTag=*/std::false_type); |
| |
| template <class _RandomAccessIterator, class _DifferenceType, class _Function> |
| _RandomAccessIterator __brick_walk1_n( |
| _RandomAccessIterator, |
| _DifferenceType, |
| _Function, |
| /*vectorTag=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function> |
| _ForwardIterator __pattern_walk1_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Function) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function> |
| _RandomAccessIterator |
| __pattern_walk1_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function); |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick> |
| _ForwardIterator __pattern_walk_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Brick) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick> |
| _RandomAccessIterator |
| __pattern_walk_brick_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick); |
| |
| //------------------------------------------------------------------------ |
| // walk2 (pseudo) |
| // |
| // walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...) |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _Function> |
| _ForwardIterator2 __brick_walk2( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _Function, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Function> |
| _RandomAccessIterator2 __brick_walk2( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _Function, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function> |
| _ForwardIterator2 __brick_walk2_n( |
| _ForwardIterator1, |
| _Size, |
| _ForwardIterator2, |
| _Function, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function> |
| _RandomAccessIterator2 __brick_walk2_n( |
| _RandomAccessIterator1, |
| _Size, |
| _RandomAccessIterator2, |
| _Function, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function> |
| _ForwardIterator2 |
| __pattern_walk2(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Function> |
| _RandomAccessIterator2 __pattern_walk2( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _Function); |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _Size, |
| class _ForwardIterator2, |
| class _Function> |
| _ForwardIterator2 |
| __pattern_walk2_n(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _Size, |
| class _RandomAccessIterator2, |
| class _Function> |
| _RandomAccessIterator2 __pattern_walk2_n( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function); |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick> |
| _ForwardIterator2 __pattern_walk2_brick( |
| _Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Brick> |
| _RandomAccessIterator2 __pattern_walk2_brick( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _Brick); |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _Size, |
| class _ForwardIterator2, |
| class _Brick> |
| _ForwardIterator2 |
| __pattern_walk2_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _Size, |
| class _RandomAccessIterator2, |
| class _Brick> |
| _RandomAccessIterator2 __pattern_walk2_brick_n( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick); |
| |
| //------------------------------------------------------------------------ |
| // walk3 (pseudo) |
| // |
| // walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...) |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function> |
| _ForwardIterator3 __brick_walk3( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator3, |
| _Function, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function> |
| _RandomAccessIterator3 __brick_walk3( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator3, |
| _Function, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _ForwardIterator2, |
| class _ForwardIterator3, |
| class _Function> |
| _ForwardIterator3 __pattern_walk3( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator3, |
| _Function) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _RandomAccessIterator3, |
| class _Function> |
| _RandomAccessIterator3 __pattern_walk3( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator3, |
| _Function); |
| |
| //------------------------------------------------------------------------ |
| // equal |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| bool __brick_equal(_ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _BinaryPredicate, |
| /* is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate> |
| bool __brick_equal(_RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _BinaryPredicate, |
| /* is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| bool __pattern_equal( |
| _Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _BinaryPredicate> |
| bool __pattern_equal( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _BinaryPredicate); |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| bool __brick_equal(_ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate, |
| /* is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate> |
| bool __brick_equal(_RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate, |
| /* is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| bool __pattern_equal( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _BinaryPredicate> |
| bool __pattern_equal( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate); |
| |
| //------------------------------------------------------------------------ |
| // find_end |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| _ForwardIterator1 __brick_find_end( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate> |
| _RandomAccessIterator1 __brick_find_end( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| _ForwardIterator1 __pattern_find_end( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _BinaryPredicate> |
| _RandomAccessIterator1 __pattern_find_end( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // find_first_of |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| _ForwardIterator1 __brick_find_first_of( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate> |
| _RandomAccessIterator1 __brick_find_first_of( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| _ForwardIterator1 __pattern_find_first_of( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _BinaryPredicate> |
| _RandomAccessIterator1 __pattern_find_first_of( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // search |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| _ForwardIterator1 __brick_search( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate> |
| _RandomAccessIterator1 __brick_search( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate> |
| _ForwardIterator1 __pattern_search( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _BinaryPredicate> |
| _RandomAccessIterator1 __pattern_search( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _BinaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // search_n |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> |
| _ForwardIterator __brick_search_n( |
| _ForwardIterator, |
| _ForwardIterator, |
| _Size, |
| const _Tp&, |
| _BinaryPredicate, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate> |
| _RandomAccessIterator __brick_search_n( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Size, |
| const _Tp&, |
| _BinaryPredicate, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate> |
| _ForwardIterator __pattern_search_n( |
| _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator, |
| class _Size, |
| class _Tp, |
| class _BinaryPredicate> |
| _RandomAccessIterator __pattern_search_n( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Size, |
| const _Tp&, |
| _BinaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // copy_n |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _Size, class _OutputIterator> |
| _OutputIterator __brick_copy_n(_ForwardIterator, |
| _Size, |
| _OutputIterator, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _Size, class _OutputIterator> |
| _OutputIterator __brick_copy_n(_RandomAccessIterator, |
| _Size, |
| _OutputIterator, |
| /*vector=*/std::true_type) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // copy |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _OutputIterator> |
| _OutputIterator __brick_copy(_ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __brick_copy(_RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| /*vector=*/std::true_type) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // move |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _OutputIterator> |
| _OutputIterator __brick_move(_ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __brick_move(_RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| /*vector=*/std::true_type) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // swap_ranges |
| //------------------------------------------------------------------------ |
| template <class _ForwardIterator, class _OutputIterator> |
| _OutputIterator __brick_swap_ranges( |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __brick_swap_ranges( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| /*vector=*/std::true_type) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // copy_if |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate> |
| _OutputIterator __brick_copy_if( |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator, |
| _UnaryPredicate, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate> |
| _OutputIterator __brick_copy_if( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| _UnaryPredicate, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate> |
| std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1( |
| _ForwardIterator, |
| _ForwardIterator, |
| bool* __restrict, |
| _UnaryPredicate, |
| /*vector=*/std::false_type) noexcept; |
| template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate> |
| std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| bool* __restrict, |
| _UnaryPredicate, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _ForwardIterator, class _OutputIterator> |
| void __brick_copy_by_mask( |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator, |
| bool*, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator> |
| void __brick_copy_by_mask( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| bool* __restrict, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2> |
| void __brick_partition_by_mask( |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator1, |
| _OutputIterator2, |
| bool*, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2> |
| void __brick_partition_by_mask( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator1, |
| _OutputIterator2, |
| bool*, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate> |
| _OutputIterator __pattern_copy_if( |
| _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator, |
| class _OutputIterator, |
| class _UnaryPredicate> |
| _OutputIterator __pattern_copy_if( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| _UnaryPredicate); |
| |
| //------------------------------------------------------------------------ |
| // count |
| //------------------------------------------------------------------------ |
| |
| template <class _RandomAccessIterator, class _Predicate> |
| typename std::iterator_traits<_RandomAccessIterator>::difference_type __brick_count( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Predicate, |
| /* is_vector = */ std::true_type) noexcept; |
| |
| template <class _ForwardIterator, class _Predicate> |
| typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count( |
| _ForwardIterator, |
| _ForwardIterator, |
| _Predicate, |
| /* is_vector = */ std::false_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Predicate> |
| typename std::iterator_traits<_ForwardIterator>::difference_type |
| __pattern_count(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Predicate> |
| typename std::iterator_traits<_RandomAccessIterator>::difference_type __pattern_count( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Predicate); |
| |
| //------------------------------------------------------------------------ |
| // unique |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _BinaryPredicate> |
| _ForwardIterator __brick_unique( |
| _ForwardIterator, |
| _ForwardIterator, |
| _BinaryPredicate, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _BinaryPredicate> |
| _RandomAccessIterator __brick_unique( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _BinaryPredicate, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate> |
| _ForwardIterator |
| __pattern_unique(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate> |
| _RandomAccessIterator __pattern_unique( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _BinaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // unique_copy |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate> |
| OutputIterator __brick_unique_copy( |
| _ForwardIterator, |
| _ForwardIterator, |
| OutputIterator, |
| _BinaryPredicate, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate> |
| _OutputIterator __brick_unique_copy( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| _BinaryPredicate, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate> |
| _OutputIterator __pattern_unique_copy( |
| _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryPredicate) noexcept; |
| |
| template <class _ExecutionPolicy, class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate> |
| _DifferenceType __brick_calc_mask_2( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| bool* __restrict, |
| _BinaryPredicate, |
| /*vector=*/std::false_type) noexcept; |
| |
| template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate> |
| _DifferenceType __brick_calc_mask_2( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| bool* __restrict, |
| _BinaryPredicate, |
| /*vector=*/std::true_type) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator, |
| class _OutputIterator, |
| class _BinaryPredicate> |
| _OutputIterator __pattern_unique_copy( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| _BinaryPredicate); |
| |
| //------------------------------------------------------------------------ |
| // reverse |
| //------------------------------------------------------------------------ |
| |
| template <class _BidirectionalIterator> |
| void __brick_reverse(_BidirectionalIterator, |
| _BidirectionalIterator, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator> |
| void __brick_reverse(_RandomAccessIterator, |
| _RandomAccessIterator, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _BidirectionalIterator> |
| void __brick_reverse(_BidirectionalIterator, |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator> |
| void __brick_reverse(_RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator> |
| void __pattern_reverse(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator> |
| void __pattern_reverse(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator); |
| |
| //------------------------------------------------------------------------ |
| // reverse_copy |
| //------------------------------------------------------------------------ |
| |
| template <class _BidirectionalIterator, class _OutputIterator> |
| _OutputIterator __brick_reverse_copy( |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| _OutputIterator, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __brick_reverse_copy( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator> |
| _OutputIterator __pattern_reverse_copy( |
| _Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __pattern_reverse_copy( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator); |
| |
| //------------------------------------------------------------------------ |
| // rotate |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator> |
| _ForwardIterator __brick_rotate( |
| _ForwardIterator, |
| _ForwardIterator, |
| _ForwardIterator, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator> |
| _RandomAccessIterator __brick_rotate( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator> |
| _ForwardIterator |
| __pattern_rotate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator> |
| _RandomAccessIterator __pattern_rotate( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator); |
| |
| //------------------------------------------------------------------------ |
| // rotate_copy |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _OutputIterator> |
| _OutputIterator __brick_rotate_copy( |
| _ForwardIterator, |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __brick_rotate_copy( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator> |
| _OutputIterator __pattern_rotate_copy( |
| _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator> |
| _OutputIterator __pattern_rotate_copy( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator); |
| |
| //------------------------------------------------------------------------ |
| // is_partitioned |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _UnaryPredicate> |
| bool __brick_is_partitioned(_ForwardIterator, |
| _ForwardIterator, |
| _UnaryPredicate, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _UnaryPredicate> |
| bool __brick_is_partitioned(_RandomAccessIterator, |
| _RandomAccessIterator, |
| _UnaryPredicate, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate> |
| bool __pattern_is_partitioned(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate> |
| bool __pattern_is_partitioned( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate); |
| |
| //------------------------------------------------------------------------ |
| // partition |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _UnaryPredicate> |
| _ForwardIterator __brick_partition( |
| _ForwardIterator, |
| _ForwardIterator, |
| _UnaryPredicate, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _UnaryPredicate> |
| _RandomAccessIterator __brick_partition( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _UnaryPredicate, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate> |
| _ForwardIterator |
| __pattern_partition(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate> |
| _RandomAccessIterator __pattern_partition( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate); |
| |
| //------------------------------------------------------------------------ |
| // stable_partition |
| //------------------------------------------------------------------------ |
| |
| template <class _BidirectionalIterator, class _UnaryPredicate> |
| _BidirectionalIterator __brick_stable_partition( |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| _UnaryPredicate, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _UnaryPredicate> |
| _RandomAccessIterator __brick_stable_partition( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _UnaryPredicate, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate> |
| _BidirectionalIterator __pattern_stable_partition( |
| _Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate> |
| _RandomAccessIterator __pattern_stable_partition( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _UnaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // partition_copy |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate> |
| std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy( |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator1, |
| _OutputIterator2, |
| _UnaryPredicate, |
| /*is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate> |
| std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator1, |
| _OutputIterator2, |
| _UnaryPredicate, |
| /*is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator, |
| class _OutputIterator1, |
| class _OutputIterator2, |
| class _UnaryPredicate> |
| std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator, |
| _ForwardIterator, |
| _OutputIterator1, |
| _OutputIterator2, |
| _UnaryPredicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator, |
| class _OutputIterator1, |
| class _OutputIterator2, |
| class _UnaryPredicate> |
| std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _OutputIterator1, |
| _OutputIterator2, |
| _UnaryPredicate); |
| |
| //------------------------------------------------------------------------ |
| // sort |
| //------------------------------------------------------------------------ |
| |
| template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsMoveConstructible> |
| void __pattern_sort( |
| _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsMoveConstructible) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_sort(__parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare, |
| /*is_move_constructible=*/std::true_type); |
| |
| //------------------------------------------------------------------------ |
| // stable_sort |
| //------------------------------------------------------------------------ |
| |
| template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_stable_sort(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_stable_sort( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare); |
| |
| //------------------------------------------------------------------------ |
| // partial_sort |
| //------------------------------------------------------------------------ |
| |
| template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_partial_sort( |
| _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_partial_sort( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // partial_sort_copy |
| //------------------------------------------------------------------------ |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Compare> |
| _RandomAccessIterator2 __pattern_partial_sort_copy( |
| _Tag, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Compare> |
| _RandomAccessIterator2 __pattern_partial_sort_copy( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // adjacent_find |
| //------------------------------------------------------------------------ |
| |
| template <class _RandomAccessIterator, class _BinaryPredicate> |
| _RandomAccessIterator __brick_adjacent_find( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _BinaryPredicate, |
| /* IsVector = */ std::true_type, |
| bool) noexcept; |
| |
| template <class _ForwardIterator, class _BinaryPredicate> |
| _ForwardIterator __brick_adjacent_find( |
| _ForwardIterator, |
| _ForwardIterator, |
| _BinaryPredicate, |
| /* IsVector = */ std::false_type, |
| bool) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate> |
| _ForwardIterator |
| __pattern_adjacent_find(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, bool) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate> |
| _RandomAccessIterator __pattern_adjacent_find( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _BinaryPredicate, |
| bool); |
| |
| //------------------------------------------------------------------------ |
| // nth_element |
| //------------------------------------------------------------------------ |
| template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_nth_element( |
| _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_nth_element( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // fill, fill_n |
| //------------------------------------------------------------------------ |
| template <class _RandomAccessIterator, class _Tp> |
| void __brick_fill(_RandomAccessIterator, |
| _RandomAccessIterator, |
| const _Tp&, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _ForwardIterator, class _Tp> |
| void __brick_fill(_ForwardIterator, |
| _ForwardIterator, |
| const _Tp&, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Tp> |
| void __pattern_fill(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Tp> |
| _RandomAccessIterator |
| __pattern_fill(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, const _Tp&); |
| |
| template <class _RandomAccessIterator, class _Size, class _Tp> |
| _RandomAccessIterator |
| __brick_fill_n(_RandomAccessIterator, |
| _Size, |
| const _Tp&, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _OutputIterator, class _Size, class _Tp> |
| _OutputIterator |
| __brick_fill_n(_OutputIterator, |
| _Size, |
| const _Tp&, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp> |
| _OutputIterator __pattern_fill_n(_Tag, _ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp> |
| _RandomAccessIterator |
| __pattern_fill_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, const _Tp&); |
| |
| //------------------------------------------------------------------------ |
| // generate, generate_n |
| //------------------------------------------------------------------------ |
| |
| template <class _RandomAccessIterator, class _Generator> |
| void __brick_generate(_RandomAccessIterator, |
| _RandomAccessIterator, |
| _Generator, |
| /* is_vector = */ std::true_type) noexcept; |
| |
| template <class _ForwardIterator, class _Generator> |
| void __brick_generate(_ForwardIterator, |
| _ForwardIterator, |
| _Generator, |
| /* is_vector = */ std::false_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Generator> |
| void __pattern_generate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Generator> |
| _RandomAccessIterator __pattern_generate( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Generator); |
| |
| template <class _RandomAccessIterator, class Size, class _Generator> |
| _RandomAccessIterator __brick_generate_n( |
| _RandomAccessIterator, |
| Size, |
| _Generator, |
| /* is_vector = */ std::true_type) noexcept; |
| |
| template <class OutputIterator, class Size, class _Generator> |
| OutputIterator __brick_generate_n( |
| OutputIterator, |
| Size, |
| _Generator, |
| /* is_vector = */ std::false_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class OutputIterator, class Size, class _Generator> |
| OutputIterator __pattern_generate_n(_Tag, _ExecutionPolicy&&, OutputIterator, Size, _Generator) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class Size, class _Generator> |
| _RandomAccessIterator |
| __pattern_generate_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, Size, _Generator); |
| |
| //------------------------------------------------------------------------ |
| // remove |
| //------------------------------------------------------------------------ |
| template <class _ForwardIterator, class _UnaryPredicate> |
| _ForwardIterator __brick_remove_if( |
| _ForwardIterator, |
| _ForwardIterator, |
| _UnaryPredicate, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _UnaryPredicate> |
| _RandomAccessIterator __brick_remove_if( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _UnaryPredicate, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate> |
| _ForwardIterator |
| __pattern_remove_if(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate> |
| _RandomAccessIterator __pattern_remove_if( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _UnaryPredicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // merge |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_merge( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_merge( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _ForwardIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_merge( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_merge( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // inplace_merge |
| //------------------------------------------------------------------------ |
| |
| template <class _BidirectionalIterator, class _Compare> |
| void __brick_inplace_merge( |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| _Compare, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _Compare> |
| void __brick_inplace_merge( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _Compare> |
| void __pattern_inplace_merge( |
| _Tag, |
| _ExecutionPolicy&&, |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| _BidirectionalIterator, |
| _Compare) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| void __pattern_inplace_merge( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // includes |
| //------------------------------------------------------------------------ |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare> |
| bool __pattern_includes( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Compare> |
| bool __pattern_includes( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // set_union |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_union( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_union( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _ForwardIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_union( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_union( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // set_intersection |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_intersection( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_intersection( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _ForwardIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_intersection( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_intersection( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // set_difference |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_difference( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_difference( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _ForwardIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_difference( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_difference( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // set_symmetric_difference |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_symmetric_difference( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare> |
| _OutputIterator __brick_set_symmetric_difference( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare, |
| /*__is_vector=*/std::true_type) noexcept; |
| |
| template <class _Tag, |
| class _ExecutionPolicy, |
| class _ForwardIterator1, |
| class _ForwardIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_symmetric_difference( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _OutputIterator, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _OutputIterator, |
| class _Compare> |
| _OutputIterator __pattern_set_symmetric_difference( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _OutputIterator, |
| _Compare); |
| |
| //------------------------------------------------------------------------ |
| // is_heap_until |
| //------------------------------------------------------------------------ |
| |
| template <class _RandomAccessIterator, class _Compare> |
| _RandomAccessIterator __brick_is_heap_until( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator, class _Compare> |
| _RandomAccessIterator __brick_is_heap_until( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| _RandomAccessIterator |
| __pattern_is_heap_until(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept; |
| |
| template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare> |
| _RandomAccessIterator __pattern_is_heap_until( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // min_element |
| //------------------------------------------------------------------------ |
| |
| template <typename _ForwardIterator, typename _Compare> |
| _ForwardIterator __brick_min_element( |
| _ForwardIterator, |
| _ForwardIterator, |
| _Compare, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <typename _RandomAccessIterator, typename _Compare> |
| _RandomAccessIterator __brick_min_element( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <typename _Tag, typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare> |
| _ForwardIterator __pattern_min_element(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare) noexcept; |
| |
| template <typename _IsVector, typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare> |
| _RandomAccessIterator __pattern_min_element( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare); |
| |
| //------------------------------------------------------------------------ |
| // minmax_element |
| //------------------------------------------------------------------------ |
| |
| template <typename _ForwardIterator, typename _Compare> |
| std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element( |
| _ForwardIterator, |
| _ForwardIterator, |
| _Compare, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <typename _RandomAccessIterator, typename _Compare> |
| std::pair<_RandomAccessIterator, _RandomAccessIterator> __brick_minmax_element( |
| _RandomAccessIterator, |
| _RandomAccessIterator, |
| _Compare, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <typename _Tag, typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare> |
| std::pair<_ForwardIterator, _ForwardIterator> |
| __pattern_minmax_element(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare) noexcept; |
| |
| template <typename _IsVector, typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare> |
| std::pair<_RandomAccessIterator, _RandomAccessIterator> __pattern_minmax_element( |
| __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare); |
| |
| //------------------------------------------------------------------------ |
| // mismatch |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate> |
| std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _Predicate, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate> |
| std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __brick_mismatch( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Predicate, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate> |
| std::pair<_ForwardIterator1, _ForwardIterator2> __pattern_mismatch( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _Predicate) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Predicate> |
| std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __pattern_mismatch( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Predicate) noexcept; |
| |
| //------------------------------------------------------------------------ |
| // lexicographical_compare |
| //------------------------------------------------------------------------ |
| |
| template <class _ForwardIterator1, class _ForwardIterator2, class _Compare> |
| bool __brick_lexicographical_compare( |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _Compare, |
| /* __is_vector = */ std::false_type) noexcept; |
| |
| template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Compare> |
| bool __brick_lexicographical_compare( |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Compare, |
| /* __is_vector = */ std::true_type) noexcept; |
| |
| template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare> |
| bool __pattern_lexicographical_compare( |
| _Tag, |
| _ExecutionPolicy&&, |
| _ForwardIterator1, |
| _ForwardIterator1, |
| _ForwardIterator2, |
| _ForwardIterator2, |
| _Compare) noexcept; |
| |
| template <class _IsVector, |
| class _ExecutionPolicy, |
| class _RandomAccessIterator1, |
| class _RandomAccessIterator2, |
| class _Compare> |
| bool __pattern_lexicographical_compare( |
| __parallel_tag<_IsVector>, |
| _ExecutionPolicy&&, |
| _RandomAccessIterator1, |
| _RandomAccessIterator1, |
| _RandomAccessIterator2, |
| _RandomAccessIterator2, |
| _Compare) noexcept; |
| |
| } // namespace __internal |
| } // namespace __pstl |
| |
| #endif /* _PSTL_ALGORITHM_FWD_H */ |
