[pstl] Uglify internal names of the library
llvm-svn: 357203
GitOrigin-RevId: 0408a7892ea5c7272b4b7fe0612f5c3265e52543
diff --git a/include/pstl/internal/algorithm_fwd.h b/include/pstl/internal/algorithm_fwd.h
index a1c7755..209c680 100644
--- a/include/pstl/internal/algorithm_fwd.h
+++ b/include/pstl/internal/algorithm_fwd.h
@@ -15,7 +15,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
//------------------------------------------------------------------------
@@ -24,29 +24,24 @@
template <class _ForwardIterator, class _Pred>
bool
-brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
- /*__is_vector=*/std::false_type) noexcept;
+__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _Pred>
bool
-brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
- /*__is_vector=*/std::true_type) noexcept;
+__brick_any_of(const _ForwardIterator, const _ForwardIterator, _Pred,
+ /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
-bool pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
- /*parallel=*/std::false_type) noexcept;
+bool
+__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
-bool pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
- /*parallel=*/std::true_type);
-#endif
-
-
-#if 0
- // TODO does this even need forwarding?
-template <class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator for_each_n_it_serial(_ForwardIterator, _Size, _Function);
+bool
+__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Pred, _IsVector,
+ /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -56,31 +51,35 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Function>
-void brick_walk1(_ForwardIterator, _ForwardIterator, _Function,
- /*vector=*/std::false_type) noexcept;
+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;
+void __brick_walk1(_RandomAccessIterator, _RandomAccessIterator, _Function,
+ /*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
-void pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
- /*parallel=*/std::false_type) noexcept;
+void
+__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
-void pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
- /*parallel=*/std::true_type);
+void
+__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function, _IsVector,
+ /*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
-void pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
- /*parallel=*/std::false_type) noexcept;
+void
+__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
-void pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
- /*parallel=*/std::true_type);
+void
+__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick,
+ /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -88,31 +87,35 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator brick_walk1_n(_ForwardIterator, _Size, _Function,
- /*_IsVectorTag=*/std::false_type);
+_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;
+_RandomAccessIterator __brick_walk1_n(_RandomAccessIterator, _DifferenceType, _Function,
+ /*vectorTag=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
-_ForwardIterator pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_ForwardIterator
+__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Function, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy,class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
-_RandomAccessIterator pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector,
- /*is_parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
+_RandomAccessIterator
+__pattern_walk1_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
-_ForwardIterator pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick,
- /*is_parallel=*/std::false_type) noexcept;
+_ForwardIterator
+__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator, _Size, _Brick,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
-_RandomAccessIterator pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick,
- /*is_parallel=*/std::true_type);
+_RandomAccessIterator
+__pattern_walk_brick_n(_ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -122,60 +125,70 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
- /*vector=*/std::false_type) noexcept;
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2 brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
- /*vector=*/std::true_type) noexcept;
-
-template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
-_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function,
/*vector=*/std::false_type) noexcept;
-template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
-_ForwardIterator2 brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
+_ForwardIterator2 __brick_walk2(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _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 _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
+_ForwardIterator2 __brick_walk2_n(_ForwardIterator1, _Size, _ForwardIterator2, _Function,
+ /*vector=*/std::true_type) noexcept;
+
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
-_ForwardIterator2 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
- /*parallel=*/std::false_type) noexcept;
+_ForwardIterator2
+__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
-_ForwardIterator2 pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
- /*parallel=*/std::true_type);
+_ForwardIterator2
+__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function, _IsVector,
+ /*parallel=*/std::true_type);
#endif
-template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function, class _IsVector>
-_ForwardIterator2 pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
- /*parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
+ class _IsVector>
+_ForwardIterator2
+__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function, _IsVector,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function, class _IsVector>
-_RandomAccessIterator2 pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
- /*parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2,
+ class _Function, class _IsVector>
+_RandomAccessIterator2
+__pattern_walk2_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function, _IsVector,
+ /*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
-_ForwardIterator2 pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
- /*parallel=*/std::false_type) noexcept;
+_ForwardIterator2
+__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
-_RandomAccessIterator2 pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
- _Brick,
- /*parallel=*/std::true_type);
+_RandomAccessIterator2
+__pattern_walk2_brick(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _Brick,
+ /*parallel=*/std::true_type);
#endif
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
-_ForwardIterator2 pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick,
- /*parallel=*/std::false_type) noexcept;
+_ForwardIterator2
+__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
-_RandomAccessIterator2 pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick,
- /*parallel=*/std::true_type);
+_RandomAccessIterator2
+__pattern_walk2_brick_n(_ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick,
+ /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -185,24 +198,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
-_ForwardIterator3 brick_walk3(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
- /*vector=*/std::false_type) noexcept;
+_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;
+_RandomAccessIterator3 __brick_walk3(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _RandomAccessIterator3, _Function,
+ /*vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function, class _IsVector>
-_ForwardIterator3 pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3, _Function,
- _IsVector,
- /*parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
+ class _Function, class _IsVector>
+_ForwardIterator3
+__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator3,
+ _Function, _IsVector,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function,
- class _IsVector>
-_RandomAccessIterator3 pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
- _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
+ class _RandomAccessIterator3, class _Function, class _IsVector>
+_RandomAccessIterator3
+__pattern_walk3(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _RandomAccessIterator3, _Function, _IsVector, /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -210,21 +226,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
- /* IsVector = */ std::false_type) noexcept;
+bool __brick_equal(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
+ /* IsVector = */ std::false_type) noexcept;
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
- /* is_vector = */ std::true_type) noexcept;
+bool __brick_equal(_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate,
+ /* is_vector = */ std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-bool pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate, _IsVector,
- /* is_parallel = */ std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+bool
+__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate,
+ _IsVector,
+ /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, class _IsVector>
-bool pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
+ class _IsVector>
+bool
+__pattern_equal(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -232,21 +254,23 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Predicate>
-_ForwardIterator brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
- /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_find_if(_ForwardIterator, _ForwardIterator, _Predicate,
+ /*is_vector=*/std::false_type) noexcept;
template <class _RandomAccessIterator, class _Predicate>
-_RandomAccessIterator brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
- /*is_vector=*/std::true_type) noexcept;
+_RandomAccessIterator __brick_find_if(_RandomAccessIterator, _RandomAccessIterator, _Predicate,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
-_ForwardIterator pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_ForwardIterator
+__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
-_ForwardIterator pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
- /*is_parallel=*/std::true_type);
+_ForwardIterator
+__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -254,25 +278,29 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate,
- /*__is_vector=*/std::false_type) noexcept;
+_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate,
- /*__is_vector=*/std::true_type) noexcept;
+_ForwardIterator1 __brick_find_end(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate,
+ /*__is_vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-_ForwardIterator1 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+_ForwardIterator1
+__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-_ForwardIterator1 pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::true_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+_ForwardIterator1
+__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -280,23 +308,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate,
- /*__is_vector=*/std::false_type) noexcept;
+_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate,
- /*__is_vector=*/std::true_type) noexcept;
+_ForwardIterator1 __brick_find_first_of(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate,
+ /*__is_vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-_ForwardIterator1 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+_ForwardIterator1
+__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-_ForwardIterator1 pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+_ForwardIterator1
+__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate, _IsVector, /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -304,25 +336,29 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate,
- /*vector=*/std::false_type) noexcept;
+_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate,
+ /*vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate,
- /*vector=*/std::true_type) noexcept;
+_ForwardIterator1 __brick_search(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate,
+ /*vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-_ForwardIterator1 pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+_ForwardIterator1
+__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate, class _IsVector>
-_ForwardIterator1 pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::true_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
+ class _IsVector>
+_ForwardIterator1
+__pattern_search(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -331,24 +367,28 @@
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_ForwardIterator
-brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
- /*vector=*/std::false_type) noexcept;
+__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+ /*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_ForwardIterator
-brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
- /*vector=*/std::true_type) noexcept;
+__brick_search_n(_ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+ /*vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
+template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate,
+ class IsVector>
_ForwardIterator
-pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate,
+ IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, class IsVector>
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate,
+ class IsVector>
_RandomAccessIterator
-pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&, _BinaryPredicate, IsVector,
- /*is_parallel=*/std::true_type) noexcept;
+__pattern_search_n(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Size, const _Tp&,
+ _BinaryPredicate, IsVector,
+ /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -356,97 +396,102 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _OutputIterator>
-_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
- /*vector=*/std::false_type) noexcept;
+_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+ /*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _Size, class _OutputIterator>
-_OutputIterator brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
- /*vector=*/std::true_type) noexcept;
+_OutputIterator __brick_copy_n(_ForwardIterator, _Size, _OutputIterator,
+ /*vector=*/std::true_type) noexcept;
//------------------------------------------------------------------------
// copy
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator brick_copy(_ForwardIterator, _ForwardIterator, _OutputIterator,
- /*vector=*/std::false_type) noexcept;
+_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;
+_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;
+_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;
+_OutputIterator __brick_move(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+ /*vector=*/std::true_type) noexcept;
//------------------------------------------------------------------------
// swap_ranges
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::false_type) noexcept;
+_OutputIterator
+__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::true_type) noexcept;
+_OutputIterator
+__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*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;
+_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
+ /*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator brick_copy_if(_ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate,
- /*vector=*/std::true_type) noexcept;
+_OutputIterator __brick_copy_if(_ForwardIterator, _ForwardIterator, _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;
+__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;
+__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;
+__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool*,
+ /*vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
void
-brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _OutputIterator, bool* __restrict,
- /*vector=*/std::true_type) noexcept;
+__brick_copy_by_mask(_ForwardIterator, _ForwardIterator, _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;
+__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;
+__brick_partition_by_mask(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator1, _OutputIterator2, bool*,
+ /*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
-_OutputIterator pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
- /*parallel=*/std::false_type) noexcept;
+_OutputIterator
+__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate, _IsVector,
+ /*parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
-_OutputIterator pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
- _IsVector, /*parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate,
+ class _IsVector>
+_OutputIterator
+__pattern_copy_if(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _UnaryPredicate,
+ _IsVector, /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -455,24 +500,24 @@
template <class _ForwardIterator, class _Predicate>
typename std::iterator_traits<_ForwardIterator>::difference_type
-brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
- /* is_vector = */ std::true_type) noexcept;
+ __brick_count(_ForwardIterator, _ForwardIterator, _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;
+ __brick_count(_ForwardIterator, _ForwardIterator, _Predicate,
+ /* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type
-pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
- /* is_parallel */ std::false_type, _IsVector) noexcept;
+__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
+ /* is_parallel */ std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type
-pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
- /* is_parallel */ std::true_type, _IsVector);
+__pattern_count(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate,
+ /* is_parallel */ std::true_type, _IsVector);
#endif
//------------------------------------------------------------------------
@@ -480,21 +525,23 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
- /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+ /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
- /*is_vector=*/std::true_type) noexcept;
+_ForwardIterator __brick_unique(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
-_ForwardIterator pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_ForwardIterator
+__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
-_ForwardIterator pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
- /*is_parallel=*/std::true_type) noexcept;
+_ForwardIterator
+__pattern_unique(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, _IsVector,
+ /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -502,31 +549,33 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
-OutputIterator brick_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate,
- /*vector=*/std::false_type) noexcept;
+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;
+_OutputIterator __brick_unique_copy(_RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
+ /*vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class OutputIterator, class _BinaryPredicate, class _IsVector>
-OutputIterator pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector,
- /*parallel=*/std::false_type) noexcept;
+OutputIterator __pattern_unique_copy(_ForwardIterator, _ForwardIterator, OutputIterator, _BinaryPredicate, _IsVector,
+ /*parallel=*/std::false_type) 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;
+__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;
+__brick_calc_mask_2(_RandomAccessIterator, _RandomAccessIterator, bool* __restrict, _BinaryPredicate,
+ /*vector=*/std::true_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate, class _IsVector>
-_OutputIterator pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator, _BinaryPredicate,
- _IsVector, /*parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
+ class _IsVector>
+_OutputIterator
+__pattern_unique_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+ _BinaryPredicate, _IsVector, /*parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -534,29 +583,31 @@
//------------------------------------------------------------------------
template <class _BidirectionalIterator>
-void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
- /*__is_vector=*/std::false_type) noexcept;
+void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator>
-void brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
- /*__is_vector=*/std::true_type) noexcept;
+void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator,
+ /*__is_vector=*/std::true_type) noexcept;
template <class _BidirectionalIterator>
-void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
- /*is_vector=*/std::false_type) noexcept;
+void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
+ /*is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator>
-void brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
- /*is_vector=*/std::true_type) noexcept;
+void __brick_reverse(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
-void pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+void
+__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
-void pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
- /*is_parallel=*/std::true_type);
+void
+__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -564,21 +615,23 @@
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
- /*is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
+ /*is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
- /*is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_reverse_copy(_BidirectionalIterator, _BidirectionalIterator, _OutputIterator,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
-_OutputIterator pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_OutputIterator
+__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
-_OutputIterator pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
- /*is_parallel=*/std::true_type);
+_OutputIterator
+__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -586,21 +639,23 @@
//------------------------------------------------------------------------
template <class _ForwardIterator>
-_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
- /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
+ /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator>
-_ForwardIterator brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
- /*is_vector=*/std::true_type) noexcept;
+_ForwardIterator __brick_rotate(_ForwardIterator, _ForwardIterator, _ForwardIterator,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
-_ForwardIterator pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_ForwardIterator
+__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
-_ForwardIterator pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
- /*is_parallel=*/std::true_type);
+_ForwardIterator
+__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -608,21 +663,25 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
- /*__is_vector=*/std::false_type) noexcept;
+_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
- /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_rotate_copy(_ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+ /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
-_OutputIterator pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_OutputIterator
+__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+ _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
-_OutputIterator pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator, _IsVector,
- /*is_parallel=*/std::true_type);
+_OutputIterator
+__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator,
+ _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -630,21 +689,23 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate>
-bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
- /*is_vector=*/std::false_type) noexcept;
+bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+ /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _UnaryPredicate>
-bool brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
- /*is_vector=*/std::true_type) noexcept;
+bool __brick_is_partitioned(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
-bool pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+bool
+__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
-bool pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
- /*is_parallel=*/std::true_type);
+bool
+__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -652,21 +713,23 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
- /*is_vector=*/std::false_type) noexcept;
+_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+ /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
- /*is_vector=*/std::true_type) noexcept;
+_ForwardIterator __brick_partition(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
-_ForwardIterator pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_ForwardIterator
+__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
-_ForwardIterator pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
- /*is_parallel=*/std::true_type);
+_ForwardIterator
+__pattern_partition(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -674,23 +737,25 @@
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
- /*__is_vector=*/std::false_type) noexcept;
+_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
- /*__is_vector=*/std::true_type) noexcept;
+_BidirectionalIterator __brick_stable_partition(_BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+ /*__is_vector=*/std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
-_BidirectionalIterator pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
- _IsVector,
- /*is_parallelization=*/std::false_type) noexcept;
+_BidirectionalIterator
+__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+ _IsVector,
+ /*is_parallelization=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
-_BidirectionalIterator pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
- _IsVector,
- /*is_parallelization=*/std::true_type) noexcept;
+_BidirectionalIterator
+__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate,
+ _IsVector,
+ /*is_parallelization=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -698,46 +763,47 @@
//------------------------------------------------------------------------
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;
+std::pair<_OutputIterator1, _OutputIterator2>
+ __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate,
+ /*is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1,
- _OutputIterator2, _UnaryPredicate,
- /*is_vector=*/std::true_type) noexcept;
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
- class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2>
-pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator,
- _OutputIterator1, _OutputIterator2,
- _UnaryPredicate, _IsVector,
- /*is_parallelization=*/std::false_type) noexcept;
+ __brick_partition_copy(_ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2, _UnaryPredicate,
+ /*is_vector=*/std::true_type) noexcept;
+
+template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
+ class _UnaryPredicate, class _IsVector>
+std::pair<_OutputIterator1, _OutputIterator2>
+__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator1, _OutputIterator2,
+ _UnaryPredicate, _IsVector,
+ /*is_parallelization=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate,
- class _IsVector>
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2,
+ class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2>
-pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
- _OutputIterator1, _OutputIterator2,
- _UnaryPredicate, _IsVector,
- /*is_parallelization=*/std::true_type);
+__pattern_partition_copy(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator1,
+ _OutputIterator2, _UnaryPredicate, _IsVector,
+ /*is_parallelization=*/std::true_type);
#endif
//------------------------------------------------------------------------
// sort
//------------------------------------------------------------------------
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector, class _IsMoveConstructible>
-void pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
- /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
+template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector,
+ class _IsMoveConstructible>
+void
+__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+ /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
- /*is_parallel=*/std::true_type,
- /*is_move_constructible=*/std::true_type);
+void
+__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
+ /*is_parallel=*/std::true_type,
+ /*is_move_constructible=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -745,13 +811,17 @@
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
- /*is_parallel=*/std::false_type) noexcept;
+void
+__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+ _IsVector /*is_vector*/,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector /*is_vector*/,
- /*is_parallel=*/std::true_type);
+void
+__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+ _IsVector /*is_vector*/,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -759,13 +829,17 @@
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+void
+__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
+ _Compare, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /*is_parallel=*/std::true_type);
+void
+__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator,
+ _Compare, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -773,15 +847,17 @@
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
-_RandomAccessIterator pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
- _RandomAccessIterator, _Compare, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+_RandomAccessIterator
+__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+ _RandomAccessIterator, _Compare, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
-_RandomAccessIterator pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
- _RandomAccessIterator, _Compare, _IsVector,
- /*is_parallel=*/std::true_type);
+_RandomAccessIterator
+__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _RandomAccessIterator,
+ _RandomAccessIterator, _Compare, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -790,37 +866,41 @@
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
-brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
- /* IsVector = */ std::true_type, bool) noexcept;
+__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _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;
+__brick_adjacent_find(_ForwardIterator, _ForwardIterator, _BinaryPredicate,
+ /* IsVector = */ std::false_type, bool) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator
-pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate,
- /* is_parallel */ std::false_type, _IsVector, bool) noexcept;
+__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate,
+ /* is_parallel */ std::false_type, _IsVector, bool) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator
-pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
- /* is_parallel */ std::true_type, _IsVector, bool);
+__pattern_adjacent_find(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _BinaryPredicate,
+ /* is_parallel */ std::true_type, _IsVector, bool);
#endif
//------------------------------------------------------------------------
// nth_element
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+void
+__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+ _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-void pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /*is_parallel=*/std::true_type) noexcept;
+void
+__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare,
+ _IsVector,
+ /*is_parallel=*/std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -828,46 +908,46 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Tp>
void
-brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
- /* __is_vector = */ std::true_type) noexcept;
+__brick_fill(_ForwardIterator, _ForwardIterator, 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;
+__brick_fill(_ForwardIterator, _ForwardIterator, const _Tp&,
+ /* __is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
void
-pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
- /*is_parallel=*/std::false_type, _IsVector) noexcept;
+__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
+ /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
_ForwardIterator
-pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
- /*is_parallel=*/std::true_type, _IsVector);
+__pattern_fill(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&,
+ /*is_parallel=*/std::true_type, _IsVector);
#endif
template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator
-brick_fill_n(_OutputIterator, _Size, const _Tp&,
- /* __is_vector = */ std::true_type) noexcept;
+__brick_fill_n(_OutputIterator, _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;
+__brick_fill_n(_OutputIterator, _Size, const _Tp&,
+ /* __is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator
-pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
- /*is_parallel=*/std::false_type, _IsVector) noexcept;
+__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
+ /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator
-pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
- /*is_parallel=*/std::true_type, _IsVector);
+__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&,
+ /*is_parallel=*/std::true_type, _IsVector);
#endif
//------------------------------------------------------------------------
@@ -875,60 +955,66 @@
//------------------------------------------------------------------------
template <class _RandomAccessIterator, class _Generator>
-void brick_generate(_RandomAccessIterator, _RandomAccessIterator, _Generator,
- /* is_vector = */ std::true_type) noexcept;
+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;
+void __brick_generate(_ForwardIterator, _ForwardIterator, _Generator,
+ /* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
-void pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
- /*is_parallel=*/std::false_type, _IsVector) noexcept;
+void
+__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
+ /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
-_ForwardIterator pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
- /*is_parallel=*/std::true_type, _IsVector);
+_ForwardIterator
+__pattern_generate(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator,
+ /*is_parallel=*/std::true_type, _IsVector);
#endif
template <class OutputIterator, class Size, class _Generator>
-OutputIterator brick_generate_n(OutputIterator, Size, _Generator,
- /* is_vector = */ std::true_type) noexcept;
+OutputIterator __brick_generate_n(OutputIterator, 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;
+OutputIterator __brick_generate_n(OutputIterator, Size, _Generator,
+ /* is_vector = */ std::false_type) noexcept;
template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
-OutputIterator pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
- /*is_parallel=*/std::false_type, _IsVector) noexcept;
+OutputIterator
+__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
+ /*is_parallel=*/std::false_type, _IsVector) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class OutputIterator, class Size, class _Generator, class _IsVector>
-OutputIterator pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
- /*is_parallel=*/std::true_type, _IsVector);
+OutputIterator
+__pattern_generate_n(_ExecutionPolicy&&, OutputIterator, Size, _Generator,
+ /*is_parallel=*/std::true_type, _IsVector);
#endif
//------------------------------------------------------------------------
// remove
//------------------------------------------------------------------------
template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator brick_remove_if(_ForwardIterator, _ForwardIterator, _UnaryPredicate,
- /* __is_vector = */ std::false_type) noexcept;
+_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;
+_RandomAccessIterator __brick_remove_if(_RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate,
+ /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
-_ForwardIterator pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
- /*is_parallel*/ std::false_type) noexcept;
+_ForwardIterator
+__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+ /*is_parallel*/ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
-_ForwardIterator pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
- /*is_parallel*/ std::true_type) noexcept;
+_ForwardIterator
+__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate, _IsVector,
+ /*is_parallel*/ std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -936,25 +1022,28 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
- _Compare,
- /* __is_vector = */ std::false_type) noexcept;
+_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /* __is_vector = */ std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _OutputIterator,
- _Compare,
- /* __is_vector = */ std::true_type) noexcept;
+_OutputIterator __brick_merge(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /* __is_vector = */ std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare,
- class _IsVector>
-_OutputIterator pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
- _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
- /* is_parallel = */ std::true_type);
+template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_merge(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _RandomAccessIterator2, _OutputIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::true_type);
#endif
//------------------------------------------------------------------------
@@ -962,21 +1051,25 @@
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _Compare>
-void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
- /* __is_vector = */ std::false_type) noexcept;
+void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
+ /* __is_vector = */ std::false_type) noexcept;
template <class _BidirectionalIterator, class _Compare>
-void brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
- /* __is_vector = */ std::true_type) noexcept;
+void __brick_inplace_merge(_BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare,
+ /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
-void pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
- /* is_parallel = */ std::false_type) noexcept;
+void
+__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
+ _Compare, _IsVector,
+ /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
-void pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator, _Compare, _IsVector,
- /*is_parallel=*/std::true_type);
+void
+__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _BidirectionalIterator,
+ _Compare, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -984,13 +1077,17 @@
//------------------------------------------------------------------------
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
-bool pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+bool
+__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _Compare, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
-bool pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare, _IsVector,
- /*is_parallel=*/std::true_type);
+bool
+__pattern_includes(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _Compare, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -998,23 +1095,27 @@
//------------------------------------------------------------------------
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;
+_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare,
- /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_union(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /*__is_vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -1022,24 +1123,28 @@
//------------------------------------------------------------------------
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;
+_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare,
- /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_intersection(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /*__is_vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -1047,23 +1152,27 @@
//------------------------------------------------------------------------
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;
+_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare,
- /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare,
+ /*__is_vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _OutputIterator, _Compare, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -1071,25 +1180,29 @@
//------------------------------------------------------------------------
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;
+_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _OutputIterator, _Compare,
+ /*__is_vector=*/std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator2, _OutputIterator, _Compare,
- /*__is_vector=*/std::true_type) noexcept;
+_OutputIterator __brick_set_symmetric_difference(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _OutputIterator, _Compare,
+ /*__is_vector=*/std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare, class _IsVector>
-_OutputIterator pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
- /*is_parallel=*/std::true_type);
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
+ class _Compare, class _IsVector>
+_OutputIterator
+__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _OutputIterator, _Compare, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -1097,21 +1210,23 @@
//------------------------------------------------------------------------
template <class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
- /* __is_vector = */ std::false_type) noexcept;
+_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;
+_RandomAccessIterator __brick_is_heap_until(_RandomAccessIterator, _RandomAccessIterator, _Compare,
+ /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-_RandomAccessIterator pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /* is_parallel = */ std::false_type) noexcept;
+_RandomAccessIterator
+__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
-_RandomAccessIterator pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /* is_parallel = */ std::true_type) noexcept;
+_RandomAccessIterator
+__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -1119,21 +1234,23 @@
//------------------------------------------------------------------------
template <typename _ForwardIterator, typename _Compare>
-_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
- /* __is_vector = */ std::false_type) noexcept;
+_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
+ /* __is_vector = */ std::false_type) noexcept;
template <typename _ForwardIterator, typename _Compare>
-_ForwardIterator brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
- /* __is_vector = */ std::true_type) noexcept;
+_ForwardIterator __brick_min_element(_ForwardIterator, _ForwardIterator, _Compare,
+ /* __is_vector = */ std::true_type) noexcept;
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
-_ForwardIterator pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
- /* is_parallel = */ std::false_type) noexcept;
+_ForwardIterator
+__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
-_RandomAccessIterator pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
- /* is_parallel = */ std::true_type);
+_RandomAccessIterator
+__pattern_min_element(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::true_type);
#endif
//------------------------------------------------------------------------
@@ -1141,27 +1258,23 @@
//------------------------------------------------------------------------
template <typename _ForwardIterator, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator>
-brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
- /* __is_vector = */ std::false_type) noexcept;
+std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+ /* __is_vector = */ std::false_type) noexcept;
template <typename _ForwardIterator, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator>
-brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
- /* __is_vector = */ std::true_type) noexcept;
+std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(_ForwardIterator, _ForwardIterator, _Compare,
+ /* __is_vector = */ std::true_type) noexcept;
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator>
-pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare,
- _IsVector,
- /* is_parallel = */ std::false_type) noexcept;
+__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator>
-pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare,
- _IsVector,
- /* is_parallel = */ std::true_type);
+__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare, _IsVector,
+ /* is_parallel = */ std::true_type);
#endif
//------------------------------------------------------------------------
@@ -1169,27 +1282,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-std::pair<_ForwardIterator1, _ForwardIterator2>
-brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator2, _Predicate,
- /* __is_vector = */ std::false_type) noexcept;
+std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1,
+ _ForwardIterator2, _ForwardIterator2, _Predicate,
+ /* __is_vector = */ std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-std::pair<_ForwardIterator1, _ForwardIterator2>
-brick_mismatch(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator2, _Predicate,
- /* __is_vector = */ std::true_type) noexcept;
+std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(_ForwardIterator1, _ForwardIterator1,
+ _ForwardIterator2, _ForwardIterator2, _Predicate,
+ /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
std::pair<_ForwardIterator1, _ForwardIterator2>
-pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Predicate, _IsVector,
- /* is_parallel = */ std::false_type) noexcept;
+__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _Predicate, _IsVector,
+ /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate, class _IsVector>
+template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
+ class _IsVector>
std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
-pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator2,
- _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
+__pattern_mismatch(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _RandomAccessIterator2, _Predicate, _IsVector, /* is_parallel = */ std::true_type) noexcept;
#endif
//------------------------------------------------------------------------
@@ -1197,23 +1310,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
- /* __is_vector = */ std::false_type) noexcept;
+bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _Compare,
+ /* __is_vector = */ std::false_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2, _Compare,
- /* __is_vector = */ std::true_type) noexcept;
+bool __brick_lexicographical_compare(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
+ _Compare,
+ /* __is_vector = */ std::true_type) noexcept;
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
-bool pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
+bool
+__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
-bool pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _ForwardIterator2,
- _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept;
+bool
+__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator2, _Compare, _IsVector, /* is_parallel = */ std::true_type) noexcept;
#endif
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_algorithm_fwd_H */
diff --git a/include/pstl/internal/algorithm_impl.h b/include/pstl/internal/algorithm_impl.h
index 99fc8c0..a2c25a3 100644
--- a/include/pstl/internal/algorithm_impl.h
+++ b/include/pstl/internal/algorithm_impl.h
@@ -28,7 +28,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
//------------------------------------------------------------------------
@@ -37,39 +37,39 @@
template <class _ForwardIterator, class _Pred>
bool
-brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred,
- /*__is_vector=*/std::false_type) noexcept
+__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred,
+ /*__is_vector=*/std::false_type) noexcept
{
return std::any_of(__first, __last, __pred);
};
template <class _ForwardIterator, class _Pred>
bool
-brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred,
- /*__is_vector=*/std::true_type) noexcept
+__brick_any_of(const _ForwardIterator __first, const _ForwardIterator __last, _Pred __pred,
+ /*__is_vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_or(__first, __last - __first, __pred);
+ return __unseq_backend::__simd_or(__first, __last - __first, __pred);
};
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool
-pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
- _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
+__pattern_any_of(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
+ _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{
- return internal::brick_any_of(__first, __last, __pred, __is_vector);
+ return __brick_any_of(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred, class _IsVector>
bool
-pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
- _IsVector __is_vector, /*parallel=*/std::true_type)
+__pattern_any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred,
+ _IsVector __is_vector, /*parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- return internal::parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
- return internal::brick_any_of(__i, __j, __pred, __is_vector);
- });
+ return __except_handler([&]() {
+ return __parallel_or(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
+ return __brick_any_of(__i, __j, __pred, __is_vector);
+ });
});
}
#endif
@@ -79,7 +79,7 @@
template <class _ForwardIterator, class _Size, class _Function>
_ForwardIterator
-for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f)
+__for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f)
{
for (; __n > 0; ++__first, --__n)
__f(__first);
@@ -93,48 +93,48 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Function>
void
-brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept
+__brick_walk1(_ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept
{
std::for_each(__first, __last, __f);
}
template <class _RandomAccessIterator, class _Function>
void
-brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f,
- /*vector=*/std::true_type) noexcept
+__brick_walk1(_RandomAccessIterator __first, _RandomAccessIterator __last, _Function __f,
+ /*vector=*/std::true_type) noexcept
{
- unseq_backend::simd_walk_1(__first, __last - __first, __f);
+ __unseq_backend::__simd_walk_1(__first, __last - __first, __f);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void
-pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
- _IsVector __is_vector,
- /*parallel=*/std::false_type) noexcept
+__pattern_walk1(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
+ _IsVector __is_vector,
+ /*parallel=*/std::false_type) noexcept
{
- internal::brick_walk1(__first, __last, __f, __is_vector);
+ __brick_walk1(__first, __last, __f, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Function, class _IsVector>
void
-pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
- _IsVector __is_vector,
- /*parallel=*/std::true_type)
+__pattern_walk1(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f,
+ _IsVector __is_vector,
+ /*parallel=*/std::true_type)
{
- internal::except_handler([&]() {
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
- internal::brick_walk1(__i, __j, __f, __is_vector);
- });
+ __except_handler([&]() {
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__f, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
+ __brick_walk1(__i, __j, __f, __is_vector);
+ });
});
}
#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void
-pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
- /*parallel=*/std::false_type) noexcept
+__pattern_walk_brick(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
+ /*parallel=*/std::false_type) noexcept
{
__brick(__first, __last);
}
@@ -142,12 +142,12 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Brick>
void
-pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
- /*parallel=*/std::true_type)
+__pattern_walk_brick(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick,
+ /*parallel=*/std::true_type)
{
- internal::except_handler([&]() {
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); });
+ __except_handler([&]() {
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__brick](_ForwardIterator __i, _ForwardIterator __j) { __brick(__i, __j); });
});
}
#endif
@@ -157,44 +157,44 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _Function>
_ForwardIterator
-brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type)
+__brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type)
{
- return for_each_n_it_serial(__first, __n, [&__f](_ForwardIterator __it) { __f(*__it); }); // calling serial version
+ return __for_each_n_it_serial(__first, __n,
+ [&__f](_ForwardIterator __it) { __f(*__it); }); // calling serial version
}
template <class _RandomAccessIterator, class _DifferenceType, class _Function>
_RandomAccessIterator
-brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f,
- /*vectorTag=*/std::true_type) noexcept
+__brick_walk1_n(_RandomAccessIterator __first, _DifferenceType __n, _Function __f,
+ /*vectorTag=*/std::true_type) noexcept
{
- return unseq_backend::simd_walk_1(__first, __n, __f);
+ return __unseq_backend::__simd_walk_1(__first, __n, __f);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function, class _IsVector>
_ForwardIterator
-pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_walk1_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f, _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_walk1_n(__first, __n, __f, __is_vector);
+ return __brick_walk1_n(__first, __n, __f, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function, class _IsVector>
_RandomAccessIterator
-pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f,
- _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_walk1_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Function __f,
+ _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
- internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector,
- std::true_type());
+ __pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f, __is_vector, std::true_type());
return __first + __n;
}
#endif
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
_ForwardIterator
-pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_walk_brick_n(_ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick,
+ /*is_parallel=*/std::false_type) noexcept
{
return __brick(__first, __n);
}
@@ -202,11 +202,11 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
_RandomAccessIterator
-pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick,
- /*is_parallel=*/std::true_type)
+__pattern_walk_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _Size __n, _Brick __brick,
+ /*is_parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- par_backend::parallel_for(
+ return __except_handler([&]() {
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first, __first + __n,
[__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j - __i); });
return __first + __n;
@@ -221,8 +221,8 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
_ForwardIterator2
-brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f,
- /*vector=*/std::false_type) noexcept
+__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f,
+ /*vector=*/std::false_type) noexcept
{
for (; __first1 != __last1; ++__first1, ++__first2)
__f(*__first1, *__first2);
@@ -231,16 +231,16 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
_ForwardIterator2
-brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f,
- /*vector=*/std::true_type) noexcept
+__brick_walk2(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Function __f,
+ /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_walk_2(__first1, __last1 - __first1, __first2, __f);
+ return __unseq_backend::__simd_walk_2(__first1, __last1 - __first1, __first2, __f);
}
template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
_ForwardIterator2
-brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f,
- /*vector=*/std::false_type) noexcept
+__brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f,
+ /*vector=*/std::false_type) noexcept
{
for (; __n > 0; --__n, ++__first1, ++__first2)
__f(*__first1, *__first2);
@@ -249,31 +249,32 @@
template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
_ForwardIterator2
-brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f,
- /*vector=*/std::true_type) noexcept
+__brick_walk2_n(_ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2, _Function __f,
+ /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_walk_2(__first1, __n, __first2, __f);
+ return __unseq_backend::__simd_walk_2(__first1, __n, __first2, __f);
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2
-pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
+__pattern_walk2(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{
- return internal::brick_walk2(__first1, __last1, __first2, __f, __is_vector);
+ return __brick_walk2(__first1, __last1, __first2, __f, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function, class _IsVector>
_ForwardIterator2
-pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type)
+__pattern_walk2(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _Function __f, _IsVector __is_vector, /*parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
- [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
- internal::brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector);
- });
+ return __except_handler([&]() {
+ __par_backend::__parallel_for(
+ std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
+ [__f, __first1, __first2, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
+ __brick_walk2(__i, __j, __first2 + (__i - __first1), __f, __is_vector);
+ });
return __first2 + (__last1 - __first1);
});
}
@@ -282,26 +283,26 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function,
class _IsVector>
_ForwardIterator2
-pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size n, _ForwardIterator2 __first2, _Function f,
- _IsVector is_vector, /*parallel=*/std::false_type) noexcept
+__pattern_walk2_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size n, _ForwardIterator2 __first2, _Function f,
+ _IsVector is_vector, /*parallel=*/std::false_type) noexcept
{
- return internal::brick_walk2_n(__first1, n, __first2, f, is_vector);
+ return __brick_walk2_n(__first1, n, __first2, f, is_vector);
}
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2,
class _Function, class _IsVector>
_RandomAccessIterator2
-pattern_walk2_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size n, _RandomAccessIterator2 __first2,
- _Function f, _IsVector is_vector, /*parallel=*/std::true_type)
+__pattern_walk2_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size n, _RandomAccessIterator2 __first2,
+ _Function f, _IsVector is_vector, /*parallel=*/std::true_type)
{
- return internal::pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + n, __first2, f,
- is_vector, std::true_type());
+ return __pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + n, __first2, f, is_vector,
+ std::true_type());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
_ForwardIterator2
-pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept
+__pattern_walk2_brick(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _Brick __brick, /*parallel=*/std::false_type) noexcept
{
return __brick(__first1, __last1, __first2);
}
@@ -309,11 +310,11 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2
-pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
- _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
+__pattern_walk2_brick(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
{
- return except_handler([&]() {
- par_backend::parallel_for(
+ return __except_handler([&]() {
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
[__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
__brick(__i, __j, __first2 + (__i - __first1));
@@ -326,11 +327,11 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Brick>
_RandomAccessIterator2
-pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n,
- _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
+__pattern_walk2_brick_n(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _Size __n,
+ _RandomAccessIterator2 __first2, _Brick __brick, /*parallel=*/std::true_type)
{
- return except_handler([&]() {
- par_backend::parallel_for(
+ return __except_handler([&]() {
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
[__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
__brick(__i, __j - __i, __first2 + (__i - __first1));
@@ -342,8 +343,8 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Brick>
_ForwardIterator2
-pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2,
- _Brick __brick, /*parallel=*/std::false_type) noexcept
+__pattern_walk2_brick_n(_ExecutionPolicy&&, _ForwardIterator1 __first1, _Size __n, _ForwardIterator2 __first2,
+ _Brick __brick, /*parallel=*/std::false_type) noexcept
{
return __brick(__first1, __n, __first2);
}
@@ -355,8 +356,8 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
_ForwardIterator3
-brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator3 __first3, _Function __f, /*vector=*/std::false_type) noexcept
+__brick_walk3(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator3 __first3, _Function __f, /*vector=*/std::false_type) noexcept
{
for (; __first1 != __last1; ++__first1, ++__first2, ++__first3)
__f(*__first1, *__first2, *__first3);
@@ -365,35 +366,34 @@
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
_RandomAccessIterator3
-brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
- _RandomAccessIterator3 __first3, _Function __f, /*vector=*/std::true_type) noexcept
+__brick_walk3(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
+ _RandomAccessIterator3 __first3, _Function __f, /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f);
+ return __unseq_backend::__simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f);
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3,
class _Function, class _IsVector>
_ForwardIterator3
-pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
+__pattern_walk3(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator3 __first3, _Function __f, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{
- return internal::brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector);
+ return __brick_walk3(__first1, __last1, __first2, __first3, __f, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2,
class _RandomAccessIterator3, class _Function, class _IsVector>
_RandomAccessIterator3
-pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
- _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector,
- /*parallel=*/std::true_type)
+__pattern_walk3(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2, _RandomAccessIterator3 __first3, _Function __f, _IsVector __is_vector,
+ /*parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- par_backend::parallel_for(
+ return __except_handler([&]() {
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
[__f, __first1, __first2, __first3, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
- internal::brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f,
- __is_vector);
+ __brick_walk3(__i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f, __is_vector);
});
return __first3 + (__last1 - __first1);
});
@@ -406,43 +406,43 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
bool
-brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p,
- /* IsVector = */ std::false_type) noexcept
+__brick_equal(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __p,
+ /* IsVector = */ std::false_type) noexcept
{
return std::equal(__first1, __last1, __first2, __p);
}
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
bool
-brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
- _BinaryPredicate __p, /* is_vector = */ std::true_type) noexcept
+__brick_equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
+ _BinaryPredicate __p, /* is_vector = */ std::true_type) noexcept
{
- return unseq_backend::simd_first(__first1, __last1 - __first1, __first2, not_pred<_BinaryPredicate>(__p)).first ==
- __last1;
+ return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, __not_pred<_BinaryPredicate>(__p))
+ .first == __last1;
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
bool
-pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
+__pattern_equal(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _BinaryPredicate __p, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_equal(__first1, __last1, __first2, __p, __is_vector);
+ return __brick_equal(__first1, __last1, __first2, __p, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate,
class _IsVector>
bool
-pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
- _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_equal(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2, _BinaryPredicate __p, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- return !internal::parallel_or(
+ return __except_handler([&]() {
+ return !__parallel_or(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
[__first1, __first2, __p, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
- return !brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector);
+ return !__brick_equal(__i, __j, __first2 + (__i - __first1), __p, __is_vector);
});
});
}
@@ -453,46 +453,47 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Predicate>
_ForwardIterator
-brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- /*is_vector=*/std::false_type) noexcept
+__brick_find_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ /*is_vector=*/std::false_type) noexcept
{
return std::find_if(__first, __last, __pred);
}
template <class _RandomAccessIterator, class _Predicate>
_RandomAccessIterator
-brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred,
- /*is_vector=*/std::true_type) noexcept
+__brick_find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _Predicate __pred,
+ /*is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
- return unseq_backend::simd_first(
+ return __unseq_backend::__simd_first(
__first, _SizeType(0), __last - __first,
[&__pred](_RandomAccessIterator __it, _SizeType __i) { return __pred(__it[__i]); });
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator
-pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_find_if(__first, __last, __pred, __is_vector);
+ return __brick_find_if(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
_ForwardIterator
-pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- return internal::parallel_find(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
- return internal::brick_find_if(__i, __j, __pred, __is_vector);
- },
- std::less<typename std::iterator_traits<_ForwardIterator>::difference_type>(),
- /*is_first=*/true);
+ return __except_handler([&]() {
+ return __parallel_find(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__pred, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
+ return __brick_find_if(__i, __j, __pred, __is_vector);
+ },
+ std::less<typename std::iterator_traits<_ForwardIterator>::difference_type>(),
+ /*is_first=*/true);
});
}
#endif
@@ -506,9 +507,9 @@
// b_first determines what occurrence we want to find (first or last)
template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator1
-find_subrange(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator1 __global_last,
- _RandomAccessIterator2 __s_first, _RandomAccessIterator2 __s_last, _BinaryPredicate __pred,
- bool __b_first, _IsVector __is_vector) noexcept
+__find_subrange(_RandomAccessIterator1 __first, _RandomAccessIterator1 __last, _RandomAccessIterator1 __global_last,
+ _RandomAccessIterator2 __s_first, _RandomAccessIterator2 __s_last, _BinaryPredicate __pred,
+ bool __b_first, _IsVector __is_vector) noexcept
{
typedef typename std::iterator_traits<_RandomAccessIterator2>::value_type _ValueType;
auto __n2 = __s_last - __s_first;
@@ -527,15 +528,14 @@
while (__first != __last && (__global_last - __first >= __n2))
{
// find position of *s_first in [first, last) (it can be start of subsequence)
- __first = internal::brick_find_if(
- __first, __last, internal::equal_value_by_pred<_ValueType, _BinaryPredicate>(*__s_first, __pred),
- __is_vector);
+ __first = __brick_find_if(__first, __last,
+ __equal_value_by_pred<_ValueType, _BinaryPredicate>(*__s_first, __pred), __is_vector);
// if position that was found previously is the start of subsequence
// then we can exit the loop (b_first == true) or keep the position
// (b_first == false)
if (__first != __last && (__global_last - __first >= __n2) &&
- internal::brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector))
+ __brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector))
{
if (__b_first)
{
@@ -563,8 +563,8 @@
template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator
-find_subrange(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __global_last,
- _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector) noexcept
+__find_subrange(_RandomAccessIterator __first, _RandomAccessIterator __last, _RandomAccessIterator __global_last,
+ _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector) noexcept
{
if (__global_last - __first < __count || __count < 1)
{
@@ -572,15 +572,15 @@
}
auto __n = __global_last - __first;
- auto __unary_pred = internal::equal_value_by_pred<_Tp, _BinaryPredicate>(__value, __pred);
+ auto __unary_pred = __equal_value_by_pred<_Tp, _BinaryPredicate>(__value, __pred);
while (__first != __last && (__global_last - __first >= __count))
{
- __first = brick_find_if(__first, __last, __unary_pred, __is_vector);
+ __first = __brick_find_if(__first, __last, __unary_pred, __is_vector);
// check that all of elements in [first+1, first+count) equal to value
if (__first != __last && (__global_last - __first >= __count) &&
- !internal::brick_any_of(__first + 1, __first + __count,
- internal::not_pred<decltype(__unary_pred)>(__unary_pred), __is_vector))
+ !__brick_any_of(__first + 1, __first + __count, __not_pred<decltype(__unary_pred)>(__unary_pred),
+ __is_vector))
{
return __first;
}
@@ -598,52 +598,51 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept
+__brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept
{
return std::find_end(__first, __last, __s_first, __s_last, __pred);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept
+__brick_find_end(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept
{
- return internal::find_subrange(__first, __last, __last, __s_first, __s_last, __pred, false, std::true_type());
+ return __find_subrange(__first, __last, __last, __s_first, __s_last, __pred, false, std::true_type());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
_ForwardIterator1
-pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_find_end(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector);
+ return __brick_find_end(__first, __last, __s_first, __s_last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
_ForwardIterator1
-pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
- _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
+__pattern_find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+ _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
{
if (__last - __first == __s_last - __s_first)
{
- const bool __res = internal::pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first,
- __pred, __is_vector, std::true_type());
+ const bool __res = __pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred,
+ __is_vector, std::true_type());
return __res ? __first : __last;
}
else
{
- return except_handler([&]() {
- return internal::parallel_find(
+ return __except_handler([&]() {
+ return __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i,
- _ForwardIterator1 __j) {
- return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector);
+ [__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
+ return __find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, __is_vector);
},
std::greater<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/false);
});
@@ -656,43 +655,43 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept
+__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::false_type) noexcept
{
return std::find_first_of(__first, __last, __s_first, __s_last, __pred);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept
+__brick_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*__is_vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_find_first_of(__first, __last, __s_first, __s_last, __pred);
+ return __unseq_backend::__simd_find_first_of(__first, __last, __s_first, __s_last, __pred);
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
_ForwardIterator1
-pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
- _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_find_first_of(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last,
+ _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector);
+ return __brick_find_first_of(__first, __last, __s_first, __s_last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
_ForwardIterator1
-pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
- _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
+__pattern_find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+ _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
{
- return except_handler([&]() {
- return internal::parallel_find(
+ return __except_handler([&]() {
+ return __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
- return internal::brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector);
+ return __brick_find_first_of(__i, __j, __s_first, __s_last, __pred, __is_vector);
},
std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
});
@@ -704,51 +703,52 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept
+__brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept
{
return std::search(__first, __last, __s_first, __s_last, __pred);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
+__brick_search(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
{
- return internal::find_subrange(__first, __last, __last, __s_first, __s_last, __pred, true, std::true_type());
+ return __find_subrange(__first, __last, __last, __s_first, __s_last, __pred, true, std::true_type());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
_ForwardIterator1
-pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_search(_ExecutionPolicy&&, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector);
+ return __brick_search(__first, __last, __s_first, __s_last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate,
class _IsVector>
_ForwardIterator1
-pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
- _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred, _IsVector __is_vector,
- /*is_parallel=*/std::true_type) noexcept
+__pattern_search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+ _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred,
+ _IsVector __is_vector,
+ /*is_parallel=*/std::true_type) noexcept
{
if (__last - __first == __s_last - __s_first)
{
- const bool __res = internal::pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first,
- __pred, __is_vector, std::true_type());
+ const bool __res = __pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred,
+ __is_vector, std::true_type());
return __res ? __first : __last;
}
else
{
- return except_handler([&]() {
- return internal::parallel_find(
+ return __except_handler([&]() {
+ return __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__last, __s_first, __s_last, __pred, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
- return internal::find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, __is_vector);
+ return __find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, __is_vector);
},
std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
});
@@ -761,53 +761,53 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_ForwardIterator
-brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value,
- _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept
+__brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value,
+ _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept
{
return std::search_n(__first, __last, __count, __value, __pred);
}
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_ForwardIterator
-brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value,
- _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
+__brick_search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value,
+ _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
{
- return internal::find_subrange(__first, __last, __last, __count, __value, __pred, std::true_type());
+ return __find_subrange(__first, __last, __last, __count, __value, __pred, std::true_type());
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate,
class _IsVector>
_ForwardIterator
-pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
- const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_search_n(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
+ const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_search_n(__first, __last, __count, __value, __pred, __is_vector);
+ return __brick_search_n(__first, __last, __count, __value, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate,
class _IsVector>
_RandomAccessIterator
-pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Size __count,
- const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
- /*is_parallel=*/std::true_type) noexcept
+__pattern_search_n(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Size __count, const _Tp& __value, _BinaryPredicate __pred, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type) noexcept
{
if (__last - __first == __count)
{
- const bool __result =
- !internal::pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); },
- __is_vector, /*is_parallel*/ std::true_type());
+ const bool __result = !__pattern_any_of(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [&__value, &__pred](const _Tp& __val) { return !__pred(__val, __value); }, __is_vector,
+ /*is_parallel*/ std::true_type());
return __result ? __first : __last;
}
else
{
- return except_handler([&__exec, __first, __last, __count, &__value, __pred, __is_vector]() {
- return internal::parallel_find(
+ return __except_handler([&__exec, __first, __last, __count, &__value, __pred, __is_vector]() {
+ return __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__last, __count, &__value, __pred, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) {
- return internal::find_subrange(__i, __j, __last, __count, __value, __pred, __is_vector);
+ return __find_subrange(__i, __j, __last, __count, __value, __pred, __is_vector);
},
std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
});
@@ -821,17 +821,17 @@
template <class _ForwardIterator, class _Size, class _OutputIterator>
_OutputIterator
-brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept
+__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept
{
return std::copy_n(__first, __n, __result);
}
template <class _ForwardIterator, class _Size, class _OutputIterator>
_OutputIterator
-brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::true_type) noexcept
+__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_assign(__first, __n, __result,
- [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; });
+ return __unseq_backend::__simd_assign(
+ __first, __n, __result, [](_ForwardIterator __first, _OutputIterator __result) { *__result = *__first; });
}
//------------------------------------------------------------------------
@@ -839,18 +839,18 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::false_type) noexcept
+__brick_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::false_type) noexcept
{
return std::copy(__first, __last, __result);
}
template <class _RandomAccessIterator, class _OutputIterator>
_OutputIterator
-brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result,
- /*vector=*/std::true_type) noexcept
+__brick_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result,
+ /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_assign(
+ return __unseq_backend::__simd_assign(
__first, __last - __first, __result,
[](_RandomAccessIterator __first, _OutputIterator __result) { *__result = *__first; });
}
@@ -860,18 +860,18 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::false_type) noexcept
+__brick_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::false_type) noexcept
{
return std::move(__first, __last, __result);
}
template <class _RandomAccessIterator, class _OutputIterator>
_OutputIterator
-brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result,
- /*vector=*/std::true_type) noexcept
+__brick_move(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator __result,
+ /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_assign(
+ return __unseq_backend::__simd_assign(
__first, __last - __first, __result,
[](_RandomAccessIterator __first, _OutputIterator __result) { *__result = std::move(*__first); });
}
@@ -881,20 +881,20 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::false_type) noexcept
+__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::false_type) noexcept
{
return std::swap_ranges(__first, __last, __result);
}
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::true_type) noexcept
+__brick_swap_ranges(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::true_type) noexcept
{
using std::iter_swap;
- return unseq_backend::simd_assign(__first, __last - __first, __result,
- iter_swap<_ForwardIterator, _OutputIterator>);
+ return __unseq_backend::__simd_assign(__first, __last - __first, __result,
+ iter_swap<_ForwardIterator, _OutputIterator>);
}
//------------------------------------------------------------------------
@@ -902,34 +902,34 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
_OutputIterator
-brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
- /*vector=*/std::false_type) noexcept
+__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
+ /*vector=*/std::false_type) noexcept
{
return std::copy_if(__first, __last, __result, __pred);
}
template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
_OutputIterator
-brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
- /*vector=*/std::true_type) noexcept
+__brick_copy_if(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, _UnaryPredicate __pred,
+ /*vector=*/std::true_type) noexcept
{
#if (__PSTL_MONOTONIC_PRESENT)
- return unseq_backend::simd_copy_if(__first, __last - __first, __result, __pred);
+ return __unseq_backend::__simd_copy_if(__first, __last - __first, __result, __pred);
#else
return std::copy_if(__first, __last, __result, __pred);
#endif
}
-// TODO: Try to use transform_reduce for combining brick_copy_if_phase1 on IsVector.
+// TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector.
template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
std::pair<_DifferenceType, _DifferenceType>
-brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred,
- /*vector=*/std::false_type) noexcept
+__brick_calc_mask_1(_ForwardIterator __first, _ForwardIterator __last, bool* __restrict __mask, _UnaryPredicate __pred,
+ /*vector=*/std::false_type) noexcept
{
auto __count_true = _DifferenceType(0);
auto __size = __last - __first;
- static_assert(internal::is_random_access_iterator<_ForwardIterator>::value,
+ static_assert(__is_random_access_iterator<_ForwardIterator>::value,
"Pattern-brick error. Should be a random access iterator.");
for (; __first != __last; ++__first, ++__mask)
@@ -945,17 +945,17 @@
template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
std::pair<_DifferenceType, _DifferenceType>
-brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred,
- /*vector=*/std::true_type) noexcept
+__brick_calc_mask_1(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __mask, _UnaryPredicate __pred,
+ /*vector=*/std::true_type) noexcept
{
- auto __result = unseq_backend::simd_calc_mask_1(__first, __last - __first, __mask, __pred);
+ auto __result = __unseq_backend::__simd_calc_mask_1(__first, __last - __first, __mask, __pred);
return std::make_pair(__result, (__last - __first) - __result);
}
template <class _ForwardIterator, class _OutputIterator, class _Assigner>
void
-brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask,
- _Assigner __assigner, /*vector=*/std::false_type) noexcept
+__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __mask,
+ _Assigner __assigner, /*vector=*/std::false_type) noexcept
{
for (; __first != __last; ++__first, ++__mask)
{
@@ -969,20 +969,20 @@
template <class _ForwardIterator, class _OutputIterator, class _Assigner>
void
-brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result, bool* __restrict __mask,
- _Assigner __assigner, /*vector=*/std::true_type) noexcept
+__brick_copy_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ bool* __restrict __mask, _Assigner __assigner, /*vector=*/std::true_type) noexcept
{
#if (__PSTL_MONOTONIC_PRESENT)
- unseq_backend::simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner);
+ __unseq_backend::__simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner);
#else
- internal::brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type());
+ __brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type());
#endif
}
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
void
-brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
- _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::false_type) noexcept
+__brick_partition_by_mask(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
+ _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::false_type) noexcept
{
for (; __first != __last; ++__first, ++__mask)
{
@@ -1001,58 +1001,58 @@
template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
void
-brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true,
- _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept
+__brick_partition_by_mask(_RandomAccessIterator __first, _RandomAccessIterator __last, _OutputIterator1 __out_true,
+ _OutputIterator2 __out_false, bool* __mask, /*vector=*/std::true_type) noexcept
{
#if (__PSTL_MONOTONIC_PRESENT)
- unseq_backend::simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask);
+ __unseq_backend::__simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask);
#else
- internal::brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type());
+ __brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type());
#endif
}
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate, class _IsVector>
_OutputIterator
-pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
+__pattern_copy_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{
- return internal::brick_copy_if(__first, __last, __result, __pred, __is_vector);
+ return __brick_copy_if(__first, __last, __result, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate,
class _IsVector>
_OutputIterator
-pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type)
+__pattern_copy_if(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _OutputIterator __result, _UnaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
const _DifferenceType __n = __last - __first;
if (_DifferenceType(1) < __n)
{
- par_backend::buffer<bool> __mask_buf(__n);
- return except_handler([&__exec, __n, __first, __result, __is_vector, __pred, &__mask_buf]() {
+ __par_backend::__buffer<bool> __mask_buf(__n);
+ return __except_handler([&__exec, __n, __first, __result, __is_vector, __pred, &__mask_buf]() {
bool* __mask = __mask_buf.get();
_DifferenceType __m{};
- par_backend::parallel_strict_scan(
+ __par_backend::parallel_strict_scan(
std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0),
[=](_DifferenceType __i, _DifferenceType __len) { // Reduce
- return brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i,
- __pred, __is_vector)
+ return __brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i,
+ __pred, __is_vector)
.first;
},
std::plus<_DifferenceType>(), // Combine
[=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan
- brick_copy_by_mask(__first + __i, __first + (__i + __len), __result + __initial, __mask + __i,
- [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; },
- __is_vector);
+ __brick_copy_by_mask(
+ __first + __i, __first + (__i + __len), __result + __initial, __mask + __i,
+ [](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, __is_vector);
},
[&__m](_DifferenceType __total) { __m = __total; });
return __result + __m;
});
}
// trivial sequence - use serial algorithm
- return brick_copy_if(__first, __last, __result, __pred, __is_vector);
+ return __brick_copy_if(__first, __last, __result, __pred, __is_vector);
}
#endif
@@ -1061,40 +1061,40 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Predicate>
typename std::iterator_traits<_ForwardIterator>::difference_type
-brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- /* is_vector = */ std::true_type) noexcept
+__brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ /* is_vector = */ std::true_type) noexcept
{
- return unseq_backend::simd_count(__first, __last - __first, __pred);
+ return __unseq_backend::__simd_count(__first, __last - __first, __pred);
}
template <class _ForwardIterator, class _Predicate>
typename std::iterator_traits<_ForwardIterator>::difference_type
-brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- /* is_vector = */ std::false_type) noexcept
+__brick_count(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ /* is_vector = */ std::false_type) noexcept
{
return std::count_if(__first, __last, __pred);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type
-pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept
+__pattern_count(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ /* is_parallel */ std::false_type, _IsVector __is_vector) noexcept
{
- return brick_count(__first, __last, __pred, __is_vector);
+ return __brick_count(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate, class _IsVector>
typename std::iterator_traits<_ForwardIterator>::difference_type
-pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
- /* is_parallel */ std::true_type, _IsVector __is_vector)
+__pattern_count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
+ /* is_parallel */ std::true_type, _IsVector __is_vector)
{
typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType;
- return except_handler([&]() {
- return par_backend::parallel_reduce(
+ return __except_handler([&]() {
+ return __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last, _SizeType(0),
[__pred, __is_vector](_ForwardIterator __begin, _ForwardIterator __end, _SizeType __value) -> _SizeType {
- return __value + brick_count(__begin, __end, __pred, __is_vector);
+ return __value + __brick_count(__begin, __end, __pred, __is_vector);
},
std::plus<_SizeType>());
});
@@ -1107,16 +1107,16 @@
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
-brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- /*is_vector=*/std::false_type) noexcept
+__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ /*is_vector=*/std::false_type) noexcept
{
return std::unique(__first, __last, __pred);
}
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
-brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- /*is_vector=*/std::true_type) noexcept
+__brick_unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ /*is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::unique(__first, __last, __pred);
@@ -1124,14 +1124,14 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator
-pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_unique(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_unique(__first, __last, __pred, __is_vector);
+ return __brick_unique(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
-// That function is shared between two algorithms - remove_if (pattern_remove_if) and unique (pattern unique). But a mask calculation is different.
+// That function is shared between two algorithms - remove_if (__pattern_remove_if) and unique (pattern unique). But a mask calculation is different.
// So, a caller passes _CalcMask brick into remove_elements.
template <class _ExecutionPolicy, class _ForwardIterator, class _CalcMask, class _IsVector>
_ForwardIterator
@@ -1141,11 +1141,11 @@
typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
_DifferenceType __n = __last - __first;
- par_backend::buffer<bool> __mask_buf(__n);
+ __par_backend::__buffer<bool> __mask_buf(__n);
// 1. find a first iterator that should be removed
- return except_handler([&]() {
+ return __except_handler([&]() {
bool* __mask = __mask_buf.get();
- _DifferenceType __min = par_backend::parallel_reduce(
+ _DifferenceType __min = __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), _DifferenceType(0), __n, __n,
[__first, __mask, &__calc_mask, __is_vector](_DifferenceType __i, _DifferenceType __j,
_DifferenceType __local_min) -> _DifferenceType {
@@ -1158,8 +1158,8 @@
return __local_min;
}
// find first iterator that should be removed
- bool* __result =
- brick_find_if(__mask + __i, __mask + __j, [](bool __val) { return !__val; }, __is_vector);
+ bool* __result = __brick_find_if(
+ __mask + __i, __mask + __j, [](bool __val) { return !__val; }, __is_vector);
if (__result - __mask == __j)
{
return __local_min;
@@ -1178,32 +1178,35 @@
__n -= __min;
__first += __min;
- par_backend::buffer<_Tp> __buf(__n);
+ __par_backend::__buffer<_Tp> __buf(__n);
_Tp* __result = __buf.get();
__mask += __min;
_DifferenceType __m{};
// 2. Elements that doesn't satisfy pred are moved to result
- par_backend::parallel_strict_scan(
+ __par_backend::parallel_strict_scan(
std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0),
[__mask, __is_vector](_DifferenceType __i, _DifferenceType __len) {
- return brick_count(__mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector);
+ return __brick_count(
+ __mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, __is_vector);
},
std::plus<_DifferenceType>(),
[=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) {
- brick_copy_by_mask(__first + __i, __first + __i + __len, __result + __initial, __mask + __i,
- [](_ForwardIterator __x, _Tp* __z) {
- invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); },
- [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
- },
- __is_vector);
+ __brick_copy_by_mask(
+ __first + __i, __first + __i + __len, __result + __initial, __mask + __i,
+ [](_ForwardIterator __x, _Tp* __z) {
+ __invoke_if_else(
+ std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); },
+ [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
+ },
+ __is_vector);
},
[&__m](_DifferenceType __total) { __m = __total; });
// 3. Elements from result are moved to [first, last)
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
- [__result, __first, __is_vector](_Tp* __i, _Tp* __j) {
- brick_move(__i, __j, __first + (__i - __result), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
+ [__result, __first, __is_vector](_Tp* __i, _Tp* __j) {
+ __brick_move(__i, __j, __first + (__i - __result), __is_vector);
+ });
return __first + __m;
});
}
@@ -1212,8 +1215,8 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator
-pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
+__pattern_unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType;
@@ -1224,14 +1227,14 @@
if (__first + 1 == __last || __first + 2 == __last)
{
// Trivial sequence - use serial algorithm
- return brick_unique(__first, __last, __pred, __is_vector);
+ return __brick_unique(__first, __last, __pred, __is_vector);
}
return remove_elements(
std::forward<_ExecutionPolicy>(__exec), ++__first, __last,
[&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) {
- brick_walk3(__b, __e, __it - 1, __it,
- [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); },
- __is_vector);
+ __brick_walk3(
+ __b, __e, __it - 1, __it,
+ [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); }, __is_vector);
},
__is_vector);
}
@@ -1243,19 +1246,19 @@
template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
OutputIterator
-brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred,
- /*vector=*/std::false_type) noexcept
+__brick_unique_copy(_ForwardIterator __first, _ForwardIterator __last, OutputIterator __result, _BinaryPredicate __pred,
+ /*vector=*/std::false_type) noexcept
{
return std::unique_copy(__first, __last, __result, __pred);
}
template <class _RandomAccessIterator, class OutputIterator, class _BinaryPredicate>
OutputIterator
-brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result,
- _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
+__brick_unique_copy(_RandomAccessIterator __first, _RandomAccessIterator __last, OutputIterator __result,
+ _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
{
#if (__PSTL_MONOTONIC_PRESENT)
- return unseq_backend::simd_unique_copy(__first, __last - __first, __result, __pred);
+ return __unseq_backend::__simd_unique_copy(__first, __last - __first, __result, __pred);
#else
return std::unique_copy(__first, __last, __result, __pred);
#endif
@@ -1264,16 +1267,16 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate,
class _IsVector>
_OutputIterator
-pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _BinaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
+__pattern_unique_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ _BinaryPredicate __pred, _IsVector __is_vector, /*parallel=*/std::false_type) noexcept
{
- return internal::brick_unique_copy(__first, __last, __result, __pred, __is_vector);
+ return __brick_unique_copy(__first, __last, __result, __pred, __is_vector);
}
template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
_DifferenceType
-brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
- _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept
+__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
+ _BinaryPredicate __pred, /*vector=*/std::false_type) noexcept
{
_DifferenceType __count = 0;
for (; __first != __last; ++__first, ++__mask)
@@ -1286,31 +1289,31 @@
template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
_DifferenceType
-brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
- _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
+__brick_calc_mask_2(_RandomAccessIterator __first, _RandomAccessIterator __last, bool* __restrict __mask,
+ _BinaryPredicate __pred, /*vector=*/std::true_type) noexcept
{
- return unseq_backend::simd_calc_mask_2(__first, __last - __first, __mask, __pred);
+ return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate,
class _IsVector>
_OutputIterator
-pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector,
- /*parallel=*/std::true_type)
+__pattern_unique_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _OutputIterator __result, _BinaryPredicate __pred, _IsVector __is_vector,
+ /*parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
const _DifferenceType __n = __last - __first;
if (_DifferenceType(2) < __n)
{
- par_backend::buffer<bool> __mask_buf(__n);
+ __par_backend::__buffer<bool> __mask_buf(__n);
if (_DifferenceType(2) < __n)
{
- return internal::except_handler([&__exec, __n, __first, __result, __pred, __is_vector, &__mask_buf]() {
+ return __except_handler([&__exec, __n, __first, __result, __pred, __is_vector, &__mask_buf]() {
bool* __mask = __mask_buf.get();
_DifferenceType __m{};
- par_backend::parallel_strict_scan(
+ __par_backend::parallel_strict_scan(
std::forward<_ExecutionPolicy>(__exec), __n, _DifferenceType(0),
[=](_DifferenceType __i, _DifferenceType __len) -> _DifferenceType { // Reduce
_DifferenceType __extra = 0;
@@ -1323,14 +1326,14 @@
++__i;
++__extra;
}
- return brick_calc_mask_2<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i,
- __pred, __is_vector) +
+ return __brick_calc_mask_2<_DifferenceType>(__first + __i, __first + (__i + __len),
+ __mask + __i, __pred, __is_vector) +
__extra;
},
std::plus<_DifferenceType>(), // Combine
[=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan
- // Phase 2 is same as for pattern_copy_if
- internal::brick_copy_by_mask(
+ // Phase 2 is same as for __pattern_copy_if
+ __brick_copy_by_mask(
__first + __i, __first + (__i + __len), __result + __initial, __mask + __i,
[](_RandomAccessIterator __x, _OutputIterator __z) { *__z = *__x; }, __is_vector);
},
@@ -1340,7 +1343,7 @@
}
}
// trivial sequence - use serial algorithm
- return brick_unique_copy(__first, __last, __result, __pred, __is_vector);
+ return __brick_unique_copy(__first, __last, __result, __pred, __is_vector);
}
#endif
@@ -1349,30 +1352,30 @@
//------------------------------------------------------------------------
template <class _BidirectionalIterator>
void
-brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept
+__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept
{
std::reverse(__first, __last);
}
template <class _BidirectionalIterator>
void
-brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::true_type) noexcept
+__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType;
const auto __n = (__last - __first) / 2;
- unseq_backend::simd_walk_2(__first, __n, std::reverse_iterator<_BidirectionalIterator>(__last),
- [](_ReferenceType __x, _ReferenceType __y) {
- using std::swap;
- swap(__x, __y);
- });
+ __unseq_backend::__simd_walk_2(__first, __n, std::reverse_iterator<_BidirectionalIterator>(__last),
+ [](_ReferenceType __x, _ReferenceType __y) {
+ using std::swap;
+ swap(__x, __y);
+ });
}
// this brick is called in parallel version, so we can use iterator arithmetic
template <class _BidirectionalIterator>
void
-brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last,
- /*is_vector=*/std::false_type) noexcept
+__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last,
+ /*is_vector=*/std::false_type) noexcept
{
for (--__d_last; __first != __last; ++__first, --__d_last)
{
@@ -1384,36 +1387,37 @@
// this brick is called in parallel version, so we can use iterator arithmetic
template <class _BidirectionalIterator>
void
-brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last,
- /*is_vector=*/std::true_type) noexcept
+__brick_reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, _BidirectionalIterator __d_last,
+ /*is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType;
- unseq_backend::simd_walk_2(__first, __last - __first, std::reverse_iterator<_BidirectionalIterator>(__d_last),
- [](_ReferenceType __x, _ReferenceType __y) {
- using std::swap;
- swap(__x, __y);
- });
+ __unseq_backend::__simd_walk_2(__first, __last - __first, std::reverse_iterator<_BidirectionalIterator>(__d_last),
+ [](_ReferenceType __x, _ReferenceType __y) {
+ using std::swap;
+ swap(__x, __y);
+ });
}
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void
-pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last, _IsVector _is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_reverse(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
+ _IsVector _is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- brick_reverse(__first, __last, _is_vector);
+ __brick_reverse(__first, __last, _is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _IsVector>
void
-pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
- _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
+ _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
- par_backend::parallel_for(
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first, __first + (__last - __first) / 2,
[__is_vector, __first, __last](_BidirectionalIterator __inner_first, _BidirectionalIterator __inner_last) {
- brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector);
+ __brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), __is_vector);
});
}
#endif
@@ -1424,45 +1428,45 @@
template <class _BidirectionalIterator, class _OutputIterator>
_OutputIterator
-brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first,
- /*is_vector=*/std::false_type) noexcept
+__brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first,
+ /*is_vector=*/std::false_type) noexcept
{
return std::reverse_copy(__first, __last, __d_first);
}
template <class _BidirectionalIterator, class _OutputIterator>
_OutputIterator
-brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first,
- /*is_vector=*/std::true_type) noexcept
+__brick_reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __d_first,
+ /*is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_BidirectionalIterator>::reference _ReferenceType1;
typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2;
- return unseq_backend::simd_walk_2(std::reverse_iterator<_BidirectionalIterator>(__last), __last - __first,
- __d_first, [](_ReferenceType1 __x, _ReferenceType2 __y) { __y = __x; });
+ return __unseq_backend::__simd_walk_2(std::reverse_iterator<_BidirectionalIterator>(__last), __last - __first,
+ __d_first, [](_ReferenceType1 __x, _ReferenceType2 __y) { __y = __x; });
}
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator
-pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
- _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_reverse_copy(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
+ _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_reverse_copy(__first, __last, __d_first, __is_vector);
+ return __brick_reverse_copy(__first, __last, __d_first, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator, class _IsVector>
_OutputIterator
-pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
- _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
+ _OutputIterator __d_first, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
auto __len = __last - __first;
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first,
- _BidirectionalIterator __inner_last) {
- brick_reverse_copy(__inner_first, __inner_last,
- __d_first + (__len - (__inner_last - __first)), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__is_vector, __first, __len, __d_first](_BidirectionalIterator __inner_first,
+ _BidirectionalIterator __inner_last) {
+ __brick_reverse_copy(__inner_first, __inner_last,
+ __d_first + (__len - (__inner_last - __first)), __is_vector);
+ });
return __d_first + __len;
}
#endif
@@ -1472,8 +1476,8 @@
//------------------------------------------------------------------------
template <class _ForwardIterator>
_ForwardIterator
-brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- /*is_vector=*/std::false_type) noexcept
+__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+ /*is_vector=*/std::false_type) noexcept
{
#if __PSTL_CPP11_STD_ROTATE_BROKEN
std::rotate(__first, __middle, __last);
@@ -1485,8 +1489,8 @@
template <class _ForwardIterator>
_ForwardIterator
-brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- /*is_vector=*/std::true_type) noexcept
+__brick_rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+ /*is_vector=*/std::true_type) noexcept
{
auto __n = __last - __first;
auto __m = __middle - __first;
@@ -1504,15 +1508,16 @@
{
for (; __last - __first >= __m_2; __first += __m)
{
- unseq_backend::simd_assign(__first, __m, __first + __m, iter_swap<_ForwardIterator, _ForwardIterator>);
+ __unseq_backend::__simd_assign(__first, __m, __first + __m,
+ iter_swap<_ForwardIterator, _ForwardIterator>);
}
}
else
{
for (; __last - __first >= __m_2; __last -= __m)
{
- unseq_backend::simd_assign(__last - __m, __m, __last - __m_2,
- iter_swap<_ForwardIterator, _ForwardIterator>);
+ __unseq_backend::__simd_assign(__last - __m, __m, __last - __m_2,
+ iter_swap<_ForwardIterator, _ForwardIterator>);
}
}
__is_left = !__is_left;
@@ -1525,67 +1530,66 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator
-pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_rotate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+ _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_rotate(__first, __middle, __last, __is_vector);
+ return __brick_rotate(__first, __middle, __last, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _IsVector>
_ForwardIterator
-pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
+ _ForwardIterator __last, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
auto __n = __last - __first;
auto __m = __middle - __first;
if (__m <= __n / 2)
{
- par_backend::buffer<_Tp> __buf(__n - __m);
- return except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
+ __par_backend::__buffer<_Tp> __buf(__n - __m);
+ return __except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
_Tp* __result = __buf.get();
- par_backend::parallel_for(
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __middle, __last,
[__middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
- brick_uninitialized_move(__b, __e, __result + (__b - __middle), __is_vector);
+ __brick_uninitialized_move(__b, __e, __result + (__b - __middle), __is_vector);
});
- par_backend::parallel_for(
- std::forward<_ExecutionPolicy>(__exec), __first, __middle,
- [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
- brick_move(__b, __e, __b + (__last - __middle), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle,
+ [__last, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
+ __brick_move(__b, __e, __b + (__last - __middle), __is_vector);
+ });
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m),
- [__first, __result, __is_vector](_Tp* __b, _Tp* __e) {
- brick_move(__b, __e, __first + (__b - __result), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + (__n - __m),
+ [__first, __result, __is_vector](_Tp* __b, _Tp* __e) {
+ __brick_move(__b, __e, __first + (__b - __result), __is_vector);
+ });
return __first + (__last - __middle);
});
}
else
{
- par_backend::buffer<_Tp> __buf(__m);
- return except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
+ __par_backend::__buffer<_Tp> __buf(__m);
+ return __except_handler([&__exec, __n, __m, __first, __middle, __last, __is_vector, &__buf]() {
_Tp* __result = __buf.get();
- par_backend::parallel_for(
- std::forward<_ExecutionPolicy>(__exec), __first, __middle,
- [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
- brick_uninitialized_move(__b, __e, __result + (__b - __first), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __middle,
+ [__first, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
+ __brick_uninitialized_move(__b, __e, __result + (__b - __first),
+ __is_vector);
+ });
- par_backend::parallel_for(
- std::forward<_ExecutionPolicy>(__exec), __middle, __last,
- [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
- brick_move(__b, __e, __first + (__b - __middle), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __middle, __last,
+ [__first, __middle, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
+ __brick_move(__b, __e, __first + (__b - __middle), __is_vector);
+ });
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
- [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) {
- brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)), __is_vector);
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __result, __result + __m,
+ [__n, __m, __first, __result, __is_vector](_Tp* __b, _Tp* __e) {
+ __brick_move(__b, __e, __first + ((__n - __m) + (__b - __result)),
+ __is_vector);
+ });
return __first + (__last - __middle);
});
@@ -1599,54 +1603,54 @@
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- _OutputIterator __result, /*__is_vector=*/std::false_type) noexcept
+__brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+ _OutputIterator __result, /*__is_vector=*/std::false_type) noexcept
{
return std::rotate_copy(__first, __middle, __last, __result);
}
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- _OutputIterator __result, /*__is_vector=*/std::true_type) noexcept
+__brick_rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+ _OutputIterator __result, /*__is_vector=*/std::true_type) noexcept
{
- _OutputIterator __res = brick_copy(__middle, __last, __result, std::true_type());
- return brick_copy(__first, __middle, __res, std::true_type());
+ _OutputIterator __res = __brick_copy(__middle, __last, __result, std::true_type());
+ return __brick_copy(__first, __middle, __res, std::true_type());
}
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator
-pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
- _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_rotate_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+ _OutputIterator __result, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_rotate_copy(__first, __middle, __last, __result, __is_vector);
+ return __brick_rotate_copy(__first, __middle, __last, __result, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _IsVector>
_OutputIterator
-pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
- _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle,
+ _ForwardIterator __last, _OutputIterator __result, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
- par_backend::parallel_for(
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__first, __last, __middle, __result, __is_vector](_ForwardIterator __b, _ForwardIterator __e) {
if (__b > __middle)
{
- brick_copy(__b, __e, __result + (__b - __middle), __is_vector);
+ __brick_copy(__b, __e, __result + (__b - __middle), __is_vector);
}
else
{
_OutputIterator __new_result = __result + ((__last - __middle) + (__b - __first));
if (__e < __middle)
{
- brick_copy(__b, __e, __new_result, __is_vector);
+ __brick_copy(__b, __e, __new_result, __is_vector);
}
else
{
- brick_copy(__b, __middle, __new_result, __is_vector);
- brick_copy(__middle, __e, __result, __is_vector);
+ __brick_copy(__b, __middle, __new_result, __is_vector);
+ __brick_copy(__middle, __e, __result, __is_vector);
}
}
});
@@ -1660,16 +1664,16 @@
template <class _ForwardIterator, class _UnaryPredicate>
bool
-brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- /*is_vector=*/std::false_type) noexcept
+__brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ /*is_vector=*/std::false_type) noexcept
{
return std::is_partitioned(__first, __last, __pred);
}
template <class _ForwardIterator, class _UnaryPredicate>
bool
-brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- /*is_vector=*/std::true_type) noexcept
+__brick_is_partitioned(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ /*is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_ForwardIterator>::difference_type _SizeType;
if (__first == __last)
@@ -1678,9 +1682,9 @@
}
else
{
- _ForwardIterator __result =
- unseq_backend::simd_first(__first, _SizeType(0), __last - __first,
- [&__pred](_ForwardIterator __it, _SizeType __i) { return !__pred(__it[__i]); });
+ _ForwardIterator __result = __unseq_backend::__simd_first(
+ __first, _SizeType(0), __last - __first,
+ [&__pred](_ForwardIterator __it, _SizeType __i) { return !__pred(__it[__i]); });
if (__result == __last)
{
return true;
@@ -1688,24 +1692,24 @@
else
{
++__result;
- return !unseq_backend::simd_or(__result, __last - __result, __pred);
+ return !__unseq_backend::__simd_or(__result, __last - __result, __pred);
}
}
}
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool
-pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_is_partitioned(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_is_partitioned(__first, __last, __pred, __is_vector);
+ return __brick_is_partitioned(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
bool
-pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
- _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+ _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
if (__first == __last)
{
@@ -1713,7 +1717,7 @@
}
else
{
- return except_handler([&]() {
+ return __except_handler([&]() {
// State of current range:
// broken - current range is not partitioned by pred
// all_true - all elements in current range satisfy pred
@@ -1735,7 +1739,7 @@
__true_false, __true_false, __broken, __broken, __all_false, __broken,
__broken, __broken, __true_false, __broken};
- __init = par_backend::parallel_reduce(
+ __init = __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
[&__pred, &__table, __is_vector](_ForwardIterator __i, _ForwardIterator __j,
_ReduceType __value) -> _ReduceType {
@@ -1749,11 +1753,11 @@
{
// find first element that don't satisfy pred
_ForwardIterator __x =
- brick_find_if(__i + 1, __j, not_pred<_UnaryPredicate>(__pred), __is_vector);
+ __brick_find_if(__i + 1, __j, __not_pred<_UnaryPredicate>(__pred), __is_vector);
if (__x != __j)
{
// find first element after "x" that satisfy pred
- _ForwardIterator __y = brick_find_if(__x + 1, __j, __pred, __is_vector);
+ _ForwardIterator __y = __brick_find_if(__x + 1, __j, __pred, __is_vector);
// if it was found then range isn't partitioned by pred
if (__y != __j)
{
@@ -1773,7 +1777,7 @@
{ // if first element doesn't satisfy pred
// then we should find the first element that satisfy pred.
// If we found it then range isn't partitioned by pred
- if (brick_find_if(__i + 1, __j, __pred, __is_vector) != __j)
+ if (__brick_find_if(__i + 1, __j, __pred, __is_vector) != __j)
{
return __broken;
}
@@ -1806,16 +1810,16 @@
template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator
-brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- /*is_vector=*/std::false_type) noexcept
+__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ /*is_vector=*/std::false_type) noexcept
{
return std::partition(__first, __last, __pred);
}
template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator
-brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- /*is_vector=*/std::true_type) noexcept
+__brick_partition(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ /*is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::partition(__first, __last, __pred);
@@ -1823,17 +1827,17 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator
-pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_partition(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_partition(__first, __last, __pred, __is_vector);
+ return __brick_partition(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator
-pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+ _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
// partitioned range: elements before pivot satisfy pred (true part),
@@ -1845,12 +1849,11 @@
_ForwardIterator __end;
};
- return except_handler([&]() {
+ return __except_handler([&]() {
_PartitionRange __init{__last, __last, __last};
// lambda for merging two partitioned ranges to one partitioned range
- auto __reductor = [&__exec, __is_vector](_PartitionRange __val1,
- _PartitionRange __val2) -> _PartitionRange {
+ auto __reductor = [&__exec, __is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange {
auto __size1 = __val1.__end - __val1.__pivot;
auto __size2 = __val2.__pivot - __val2.__begin;
auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin);
@@ -1864,31 +1867,31 @@
// then we should swap the false part of left range and last part of true part of right range
else if (__size2 > __size1)
{
- par_backend::parallel_for(
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size1,
[__val1, __val2, __size1, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
- brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector);
+ __brick_swap_ranges(__i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), __is_vector);
});
return {__new_begin, __val2.__pivot - __size1, __val2.__end};
}
// else we should swap the first part of false part of left range and true part of right range
else
{
- par_backend::parallel_for(
+ __par_backend::__parallel_for(
std::forward<_ExecutionPolicy>(__exec), __val1.__pivot, __val1.__pivot + __size2,
[__val1, __val2, __is_vector](_ForwardIterator __i, _ForwardIterator __j) {
- brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector);
+ __brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), __is_vector);
});
return {__new_begin, __val1.__pivot + __size2, __val2.__end};
}
};
- _PartitionRange __result = par_backend::parallel_reduce(
+ _PartitionRange __result = __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
[__pred, __is_vector, __reductor](_ForwardIterator __i, _ForwardIterator __j,
_PartitionRange __value) -> _PartitionRange {
//1. serial partition
- _ForwardIterator __pivot = brick_partition(__i, __j, __pred, __is_vector);
+ _ForwardIterator __pivot = __brick_partition(__i, __j, __pred, __is_vector);
// 2. merging of two ranges (left and right respectively)
return __reductor(__value, {__i, __pivot, __j});
@@ -1905,16 +1908,16 @@
template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator
-brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,
- /*__is_vector=*/std::false_type) noexcept
+__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,
+ /*__is_vector=*/std::false_type) noexcept
{
return std::stable_partition(__first, __last, __pred);
}
template <class _BidirectionalIterator, class _UnaryPredicate>
_BidirectionalIterator
-brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,
- /*__is_vector=*/std::true_type) noexcept
+__brick_stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred,
+ /*__is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::stable_partition(__first, __last, __pred);
@@ -1922,17 +1925,19 @@
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator
-pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
- _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept
+__pattern_stable_partition(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last,
+ _UnaryPredicate __pred, _IsVector __is_vector,
+ /*is_parallelization=*/std::false_type) noexcept
{
- return internal::brick_stable_partition(__first, __last, __pred, __is_vector);
+ return __brick_stable_partition(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate, class _IsVector>
_BidirectionalIterator
-pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
- _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallelization=*/std::true_type) noexcept
+__pattern_stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
+ _UnaryPredicate __pred, _IsVector __is_vector,
+ /*is_parallelization=*/std::true_type) noexcept
{
// partitioned range: elements before pivot satisfy pred (true part),
// elements after pivot don't satisfy pred (false part)
@@ -1943,12 +1948,11 @@
_BidirectionalIterator __end;
};
- return except_handler([&]() {
+ return __except_handler([&]() {
_PartitionRange __init{__last, __last, __last};
// lambda for merging two partitioned ranges to one partitioned range
- auto __reductor = [__is_vector](_PartitionRange __val1,
- _PartitionRange __val2) -> _PartitionRange {
+ auto __reductor = [__is_vector](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange {
auto __size1 = __val1.__end - __val1.__pivot;
auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin);
@@ -1961,17 +1965,17 @@
// then we should swap the false part of left range and last part of true part of right range
else
{
- brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector);
+ __brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, __is_vector);
return {__new_begin, __val2.__pivot - __size1, __val2.__end};
}
};
- _PartitionRange __result = par_backend::parallel_reduce(
+ _PartitionRange __result = __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __init,
[&__pred, __is_vector, __reductor](_BidirectionalIterator __i, _BidirectionalIterator __j,
_PartitionRange __value) -> _PartitionRange {
//1. serial stable_partition
- _BidirectionalIterator __pivot = brick_stable_partition(__i, __j, __pred, __is_vector);
+ _BidirectionalIterator __pivot = __brick_stable_partition(__i, __j, __pred, __is_vector);
// 2. merging of two ranges (left and right respectively)
return __reductor(__value, {__i, __pivot, __j});
@@ -1988,19 +1992,19 @@
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2>
-brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
- _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::false_type) noexcept
+__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
+ _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::false_type) noexcept
{
return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
}
template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2>
-brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
- _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept
+__brick_partition_copy(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator1 __out_true,
+ _OutputIterator2 __out_false, _UnaryPredicate __pred, /*is_vector=*/std::true_type) noexcept
{
#if (__PSTL_MONOTONIC_PRESENT)
- return unseq_backend::simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred);
+ return __unseq_backend::__simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred);
#else
return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
#endif
@@ -2009,51 +2013,49 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2>
-pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
- _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept
+__pattern_partition_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
+ _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallelization=*/std::false_type) noexcept
{
- return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
+ return __brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate, class _IsVector>
std::pair<_OutputIterator1, _OutputIterator2>
-pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallelization=*/std::true_type)
+__pattern_partition_copy(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _OutputIterator1 __out_true, _OutputIterator2 __out_false, _UnaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallelization=*/std::true_type)
{
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
typedef std::pair<_DifferenceType, _DifferenceType> _ReturnType;
const _DifferenceType __n = __last - __first;
if (_DifferenceType(1) < __n)
{
- par_backend::buffer<bool> __mask_buf(__n);
- return internal::except_handler(
- [&__exec, __n, __first, __out_true, __out_false, __is_vector, __pred, &__mask_buf]() {
- bool* __mask = __mask_buf.get();
- _ReturnType __m{};
- par_backend::parallel_strict_scan(
- std::forward<_ExecutionPolicy>(__exec), __n, std::make_pair(_DifferenceType(0), _DifferenceType(0)),
- [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
- return internal::brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len),
- __mask + __i, __pred, __is_vector);
- },
- [](const _ReturnType& __x, const _ReturnType& __y) -> _ReturnType {
- return std::make_pair(__x.first + __y.first, __x.second + __y.second);
- }, // Combine
- [=](_DifferenceType __i, _DifferenceType __len, _ReturnType __initial) { // Scan
- internal::brick_partition_by_mask(__first + __i, __first + (__i + __len),
- __out_true + __initial.first, __out_false + __initial.second,
- __mask + __i, __is_vector);
- },
- [&__m](_ReturnType __total) { __m = __total; });
- return std::make_pair(__out_true + __m.first, __out_false + __m.second);
- });
+ __par_backend::__buffer<bool> __mask_buf(__n);
+ return __except_handler([&__exec, __n, __first, __out_true, __out_false, __is_vector, __pred, &__mask_buf]() {
+ bool* __mask = __mask_buf.get();
+ _ReturnType __m{};
+ __par_backend::parallel_strict_scan(
+ std::forward<_ExecutionPolicy>(__exec), __n, std::make_pair(_DifferenceType(0), _DifferenceType(0)),
+ [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
+ return __brick_calc_mask_1<_DifferenceType>(__first + __i, __first + (__i + __len), __mask + __i,
+ __pred, __is_vector);
+ },
+ [](const _ReturnType& __x, const _ReturnType& __y) -> _ReturnType {
+ return std::make_pair(__x.first + __y.first, __x.second + __y.second);
+ }, // Combine
+ [=](_DifferenceType __i, _DifferenceType __len, _ReturnType __initial) { // Scan
+ __brick_partition_by_mask(__first + __i, __first + (__i + __len), __out_true + __initial.first,
+ __out_false + __initial.second, __mask + __i, __is_vector);
+ },
+ [&__m](_ReturnType __total) { __m = __total; });
+ return std::make_pair(__out_true + __m.first, __out_false + __m.second);
+ });
}
// trivial sequence - use serial algorithm
- return internal::brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
+ return __brick_partition_copy(__first, __last, __out_true, __out_false, __pred, __is_vector);
}
#endif
@@ -2064,8 +2066,8 @@
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector,
class _IsMoveConstructible>
void
-pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
- _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept
+__pattern_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
+ _IsVector /*is_vector*/, /*is_parallel=*/std::false_type, _IsMoveConstructible) noexcept
{
std::sort(__first, __last, __comp);
}
@@ -2073,14 +2075,16 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
- _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type)
+__pattern_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
+ _IsVector /*is_vector*/, /*is_parallel=*/std::true_type, /*is_move_constructible=*/std::true_type)
{
- except_handler([&]() {
- par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- [](_RandomAccessIterator __first, _RandomAccessIterator __last,
- _Compare __comp) { std::sort(__first, __last, __comp); },
- __last - __first);
+ __except_handler([&]() {
+ __par_backend::__parallel_stable_sort(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
+ [](_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+ std::sort(__first, __last, __comp);
+ },
+ __last - __first);
});
}
#endif
@@ -2091,8 +2095,8 @@
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
- _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept
+__pattern_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
+ _IsVector /*is_vector*/, /*is_parallel=*/std::false_type) noexcept
{
std::stable_sort(__first, __last, __comp);
}
@@ -2100,13 +2104,13 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type)
+__pattern_stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp, _IsVector /*is_vector*/, /*is_parallel=*/std::true_type)
{
- internal::except_handler([&]() {
- par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- [](_RandomAccessIterator __first, _RandomAccessIterator __last,
- _Compare __comp) { std::stable_sort(__first, __last, __comp); });
+ __except_handler([&]() {
+ __par_backend::__parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
+ [](_RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp) { std::stable_sort(__first, __last, __comp); });
});
}
#endif
@@ -2117,8 +2121,9 @@
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle,
- _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::false_type) noexcept
+__pattern_partial_sort(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __middle,
+ _RandomAccessIterator __last, _Compare __comp, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept
{
std::partial_sort(__first, __middle, __last, __comp);
}
@@ -2126,12 +2131,12 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
- _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type)
+__pattern_partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
+ _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::true_type)
{
const auto __n = __middle - __first;
- except_handler([&]() {
- par_backend::parallel_stable_sort(
+ __except_handler([&]() {
+ __par_backend::__parallel_stable_sort(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
[__n](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Compare __comp) {
if (__n < __end - __begin)
@@ -2150,9 +2155,9 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator
-pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
- _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_partial_sort_copy(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
+ _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept
{
return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp);
}
@@ -2160,9 +2165,9 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator
-pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
- _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp,
- _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+ _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp,
+ _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
if (__last == __first || __d_last == __d_first)
{
@@ -2170,10 +2175,10 @@
}
auto __n1 = __last - __first;
auto __n2 = __d_last - __d_first;
- return except_handler([&]() {
+ return __except_handler([&]() {
if (__n2 >= __n1)
{
- par_backend::parallel_stable_sort(
+ __par_backend::__parallel_stable_sort(
std::forward<_ExecutionPolicy>(__exec), __d_first, __d_first + __n1, __comp,
[__first, __d_first, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j,
_Compare __comp) {
@@ -2182,7 +2187,7 @@
// 1. Copy elements from input to output
#if !__PSTL_ICC_18_OMP_SIMD_BROKEN
- brick_copy(__i1, __j1, __i, __is_vector);
+ __brick_copy(__i1, __j1, __i, __is_vector);
#else
std::copy(__i1, __j1, __i);
#endif
@@ -2196,32 +2201,33 @@
{
typedef typename std::iterator_traits<_ForwardIterator>::value_type _T1;
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _T2;
- par_backend::buffer<_T1> __buf(__n1);
+ __par_backend::__buffer<_T1> __buf(__n1);
_T1* __r = __buf.get();
- par_backend::parallel_stable_sort(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp,
- [__n2, __first, __r](_T1* __i, _T1* __j, _Compare __comp) {
- _ForwardIterator __it = __first + (__i - __r);
+ __par_backend::__parallel_stable_sort(
+ std::forward<_ExecutionPolicy>(__exec), __r, __r + __n1, __comp,
+ [__n2, __first, __r](_T1* __i, _T1* __j, _Compare __comp) {
+ _ForwardIterator __it = __first + (__i - __r);
- // 1. Copy elements from input to raw memory
- for (_T1* __k = __i; __k != __j; ++__k, ++__it)
- {
- ::new (__k) _T2(*__it);
- }
+ // 1. Copy elements from input to raw memory
+ for (_T1* __k = __i; __k != __j; ++__k, ++__it)
+ {
+ ::new (__k) _T2(*__it);
+ }
- // 2. Sort elements in temporary buffer
- if (__n2 < __j - __i)
- std::partial_sort(__i, __i + __n2, __j, __comp);
- else
- std::sort(__i, __j, __comp);
- },
- __n2);
+ // 2. Sort elements in temporary __buffer
+ if (__n2 < __j - __i)
+ std::partial_sort(__i, __i + __n2, __j, __comp);
+ else
+ std::sort(__i, __j, __comp);
+ },
+ __n2);
- // 3. Move elements from temporary buffer to output
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2,
- [__r, __d_first, __is_vector](_T1* __i, _T1* __j) {
- brick_move(__i, __j, __d_first + (__i - __r), __is_vector);
- });
+ // 3. Move elements from temporary __buffer to output
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n2,
+ [__r, __d_first, __is_vector](_T1* __i, _T1* __j) {
+ __brick_move(__i, __j, __d_first + (__i - __r), __is_vector);
+ });
return __d_first + __n2;
}
});
@@ -2233,40 +2239,40 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
-brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- /* IsVector = */ std::true_type, bool __or_semantic) noexcept
+__brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ /* IsVector = */ std::true_type, bool __or_semantic) noexcept
{
- return unseq_backend::simd_adjacent_find(__first, __last, __pred, __or_semantic);
+ return __unseq_backend::__simd_adjacent_find(__first, __last, __pred, __or_semantic);
}
template <class _ForwardIterator, class _BinaryPredicate>
_ForwardIterator
-brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- /* IsVector = */ std::false_type, bool __or_semantic) noexcept
+__brick_adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ /* IsVector = */ std::false_type, bool __or_semantic) noexcept
{
return std::adjacent_find(__first, __last, __pred);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate, class _IsVector>
_ForwardIterator
-pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
- /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept
+__pattern_adjacent_find(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred,
+ /* is_parallel */ std::false_type, _IsVector __is_vector, bool __or_semantic) noexcept
{
- return internal::brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic);
+ return __brick_adjacent_find(__first, __last, __pred, __is_vector, __or_semantic);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate, class _IsVector>
_RandomAccessIterator
-pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector,
- bool __or_semantic)
+__pattern_adjacent_find(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _BinaryPredicate __pred, /* is_parallel */ std::true_type, _IsVector __is_vector,
+ bool __or_semantic)
{
if (__last - __first < 2)
return __last;
- return internal::except_handler([&]() {
- return par_backend::parallel_reduce(
+ return __except_handler([&]() {
+ return __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __last,
[__last, __pred, __is_vector, __or_semantic](_RandomAccessIterator __begin, _RandomAccessIterator __end,
_RandomAccessIterator __value) -> _RandomAccessIterator {
@@ -2274,7 +2280,7 @@
// checking (compare_and_swap idiom) its __value at __first.
if (__or_semantic && __value < __last)
{ //found
- par_backend::cancel_execution();
+ __par_backend::__cancel_execution();
return __value;
}
@@ -2289,7 +2295,7 @@
//correct the global result iterator if the "brick" returns a local "__last"
const _RandomAccessIterator __res =
- internal::brick_adjacent_find(__begin, __end, __pred, __is_vector, __or_semantic);
+ __brick_adjacent_find(__begin, __end, __pred, __is_vector, __or_semantic);
if (__res < __end)
__value = __res;
}
@@ -2309,8 +2315,9 @@
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth,
- _RandomAccessIterator __last, _Compare __comp, _IsVector, /*is_parallel=*/std::false_type) noexcept
+__pattern_nth_element(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __nth,
+ _RandomAccessIterator __last, _Compare __comp, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept
{
std::nth_element(__first, __nth, __last, __comp);
}
@@ -2318,9 +2325,9 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
void
-pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
- _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector,
- /*is_parallel=*/std::true_type) noexcept
+__pattern_nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
+ _RandomAccessIterator __last, _Compare __comp, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type) noexcept
{
if (__first == __last || __nth == __last)
{
@@ -2332,9 +2339,10 @@
_RandomAccessIterator __x;
do
{
- __x = pattern_partition(std::forward<_ExecutionPolicy>(__exec), __first + 1, __last,
- [&__comp, __first](const _Tp& __x) { return __comp(__x, *__first); }, __is_vector,
- /*is_parallel=*/std::true_type());
+ __x = __pattern_partition(
+ std::forward<_ExecutionPolicy>(__exec), __first + 1, __last,
+ [&__comp, __first](const _Tp& __x) { return __comp(__x, *__first); }, __is_vector,
+ /*is_parallel=*/std::true_type());
--__x;
if (__x != __first)
{
@@ -2368,39 +2376,39 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Tp>
void
-brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
- /* __is_vector = */ std::true_type) noexcept
+__brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
+ /* __is_vector = */ std::true_type) noexcept
{
- unseq_backend::simd_fill_n(__first, __last - __first, __value);
+ __unseq_backend::__simd_fill_n(__first, __last - __first, __value);
}
template <class _ForwardIterator, class _Tp>
void
-brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
- /* __is_vector = */ std::false_type) noexcept
+__brick_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
+ /* __is_vector = */ std::false_type) noexcept
{
std::fill(__first, __last, __value);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
void
-pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
- /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
+__pattern_fill(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
+ /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{
- internal::brick_fill(__first, __last, __value, __is_vector);
+ __brick_fill(__first, __last, __value, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _IsVector>
_ForwardIterator
-pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
- /*is_parallel=*/std::true_type, _IsVector __is_vector)
+__pattern_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value,
+ /*is_parallel=*/std::true_type, _IsVector __is_vector)
{
- return except_handler([&__exec, __first, __last, &__value, __is_vector]() {
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
- internal::brick_fill(__begin, __end, __value, __is_vector);
- });
+ return __except_handler([&__exec, __first, __last, &__value, __is_vector]() {
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [&__value, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
+ __brick_fill(__begin, __end, __value, __is_vector);
+ });
return __last;
});
}
@@ -2408,33 +2416,33 @@
template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator
-brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept
+__brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::true_type) noexcept
{
- return unseq_backend::simd_fill_n(__first, __count, __value);
+ return __unseq_backend::__simd_fill_n(__first, __count, __value);
}
template <class _OutputIterator, class _Size, class _Tp>
_OutputIterator
-brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept
+__brick_fill_n(_OutputIterator __first, _Size __count, const _Tp& __value, /* __is_vector = */ std::false_type) noexcept
{
return std::fill_n(__first, __count, __value);
}
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator
-pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value,
- /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
+__pattern_fill_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, const _Tp& __value,
+ /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{
- return internal::brick_fill_n(__first, __count, __value, __is_vector);
+ return __brick_fill_n(__first, __count, __value, __is_vector);
}
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp, class _IsVector>
_OutputIterator
-pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value,
- /*is_parallel=*/std::true_type, _IsVector __is_vector)
+__pattern_fill_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, const _Tp& __value,
+ /*is_parallel=*/std::true_type, _IsVector __is_vector)
{
- return internal::pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value,
- std::true_type(), __is_vector);
+ return __pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __value, std::true_type(),
+ __is_vector);
}
//------------------------------------------------------------------------
@@ -2442,39 +2450,39 @@
//------------------------------------------------------------------------
template <class _RandomAccessIterator, class _Generator>
void
-brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g,
- /* is_vector = */ std::true_type) noexcept
+__brick_generate(_RandomAccessIterator __first, _RandomAccessIterator __last, _Generator __g,
+ /* is_vector = */ std::true_type) noexcept
{
- unseq_backend::simd_generate_n(__first, __last - __first, __g);
+ __unseq_backend::__simd_generate_n(__first, __last - __first, __g);
}
template <class _ForwardIterator, class _Generator>
void
-brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g,
- /* is_vector = */ std::false_type) noexcept
+__brick_generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __g,
+ /* is_vector = */ std::false_type) noexcept
{
std::generate(__first, __last, __g);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
void
-pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
- /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
+__pattern_generate(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
+ /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{
- internal::brick_generate(__first, __last, __g, __is_vector);
+ __brick_generate(__first, __last, __g, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator, class _IsVector>
_ForwardIterator
-pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
- /*is_parallel=*/std::true_type, _IsVector __is_vector)
+__pattern_generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g,
+ /*is_parallel=*/std::true_type, _IsVector __is_vector)
{
- return internal::except_handler([&]() {
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
- internal::brick_generate(__begin, __end, __g, __is_vector);
- });
+ return __except_handler([&]() {
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__g, __is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
+ __brick_generate(__begin, __end, __g, __is_vector);
+ });
return __last;
});
}
@@ -2482,36 +2490,36 @@
template <class OutputIterator, class Size, class _Generator>
OutputIterator
-brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept
+__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::true_type) noexcept
{
- return unseq_backend::simd_generate_n(__first, __count, __g);
+ return __unseq_backend::__simd_generate_n(__first, __count, __g);
}
template <class OutputIterator, class Size, class _Generator>
OutputIterator
-brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept
+__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept
{
return std::generate_n(__first, __count, __g);
}
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector>
_OutputIterator
-pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g,
- /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
+__pattern_generate_n(_ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g,
+ /*is_parallel=*/std::false_type, _IsVector __is_vector) noexcept
{
- return internal::brick_generate_n(__first, __count, __g, __is_vector);
+ return __brick_generate_n(__first, __count, __g, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator, class _IsVector>
_OutputIterator
-pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g,
- /*is_parallel=*/std::true_type, _IsVector __is_vector)
+__pattern_generate_n(_ExecutionPolicy&& __exec, _OutputIterator __first, _Size __count, _Generator __g,
+ /*is_parallel=*/std::true_type, _IsVector __is_vector)
{
- static_assert(internal::is_random_access_iterator<_OutputIterator>::value,
+ static_assert(__is_random_access_iterator<_OutputIterator>::value,
"Pattern-brick error. Should be a random access iterator.");
- return internal::pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g,
- std::true_type(), __is_vector);
+ return __pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g, std::true_type(),
+ __is_vector);
}
#endif
@@ -2521,19 +2529,19 @@
template <class _ForwardIterator, class _UnaryPredicate>
_ForwardIterator
-brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- /* __is_vector = */ std::false_type) noexcept
+__brick_remove_if(_ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ /* __is_vector = */ std::false_type) noexcept
{
return std::remove_if(__first, __last, __pred);
}
template <class _RandomAccessIterator, class _UnaryPredicate>
_RandomAccessIterator
-brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred,
- /* __is_vector = */ std::true_type) noexcept
+__brick_remove_if(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryPredicate __pred,
+ /* __is_vector = */ std::true_type) noexcept
{
#if __PSTL_MONOTONIC_PRESENT
- return unseq_backend::simd_remove_if(__first, __last - __first, __pred);
+ return __unseq_backend::__simd_remove_if(__first, __last - __first, __pred);
#else
return std::remove_if(__first, __last, __pred);
#endif
@@ -2541,30 +2549,31 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator
-pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept
+__pattern_remove_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
+ _IsVector __is_vector, /*is_parallel*/ std::false_type) noexcept
{
- return internal::brick_remove_if(__first, __last, __pred, __is_vector);
+ return __brick_remove_if(__first, __last, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _IsVector>
_ForwardIterator
-pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
- _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept
+__pattern_remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
+ _UnaryPredicate __pred, _IsVector __is_vector, /*is_parallel*/ std::true_type) noexcept
{
typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType;
if (__first == __last || __first + 1 == __last)
{
// Trivial sequence - use serial algorithm
- return brick_remove_if(__first, __last, __pred, __is_vector);
+ return __brick_remove_if(__first, __last, __pred, __is_vector);
}
return remove_elements(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[&__pred, __is_vector](bool* __b, bool* __e, _ForwardIterator __it) {
- brick_walk2(__b, __e, __it, [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, __is_vector);
+ __brick_walk2(
+ __b, __e, __it, [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, __is_vector);
},
__is_vector);
}
@@ -2576,18 +2585,18 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp,
- /* __is_vector = */ std::false_type) noexcept
+__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp,
+ /* __is_vector = */ std::false_type) noexcept
{
return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp,
- /* __is_vector = */ std::true_type) noexcept
+__brick_merge(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp,
+ /* __is_vector = */ std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::merge(__first1, __last1, __first2, __last2, __d_first, __comp);
@@ -2596,26 +2605,26 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector,
- /* is_parallel = */ std::false_type) noexcept
+__pattern_merge(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __d_first, _Compare __comp, _IsVector __is_vector,
+ /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector);
+ return __brick_merge(__first1, __last1, __first2, __last2, __d_first, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
- _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first,
- _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
+__pattern_merge(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _OutputIterator __d_first,
+ _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
{
- par_backend::parallel_merge(
+ __par_backend::__parallel_merge(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp,
[__is_vector](_RandomAccessIterator1 __f1, _RandomAccessIterator1 __l1, _RandomAccessIterator2 __f2,
_RandomAccessIterator2 __l2, _OutputIterator __f3,
- _Compare __comp) { return brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); });
+ _Compare __comp) { return __brick_merge(__f1, __l1, __f2, __l2, __f3, __comp, __is_vector); });
return __d_first + (__last1 - __first1) + (__last2 - __first2);
}
#endif
@@ -2625,16 +2634,16 @@
//------------------------------------------------------------------------
template <class _BidirectionalIterator, class _Compare>
void
-brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
- _Compare __comp, /* __is_vector = */ std::false_type) noexcept
+__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
+ _Compare __comp, /* __is_vector = */ std::false_type) noexcept
{
std::inplace_merge(__first, __middle, __last, __comp);
}
template <class _BidirectionalIterator, class _Compare>
void
-brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
- _Compare __comp, /* __is_vector = */ std::true_type) noexcept
+__brick_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
+ _Compare __comp, /* __is_vector = */ std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial")
std::inplace_merge(__first, __middle, __last, __comp);
@@ -2642,19 +2651,19 @@
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void
-pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle,
- _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
- /* is_parallel = */ std::false_type) noexcept
+__pattern_inplace_merge(_ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __middle,
+ _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
+ /* is_parallel = */ std::false_type) noexcept
{
- internal::brick_inplace_merge(__first, __middle, __last, __comp, __is_vector);
+ __brick_inplace_merge(__first, __middle, __last, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare, class _IsVector>
void
-pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
- _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
+ _BidirectionalIterator __last, _Compare __comp, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
if (__first == __last || __first == __middle || __middle == __last)
{
@@ -2662,32 +2671,34 @@
}
typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _Tp;
auto __n = __last - __first;
- par_backend::buffer<_Tp> __buf(__n);
+ __par_backend::__buffer<_Tp> __buf(__n);
_Tp* __r = __buf.get();
- except_handler([&]() {
+ __except_handler([&]() {
auto __move_values = [](_BidirectionalIterator __x, _Tp* __z) {
- invoke_if_else(std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); },
- [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
+ __invoke_if_else(
+ std::is_trivial<_Tp>(), [&]() { *__z = std::move(*__x); },
+ [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
};
auto __move_sequences = [](_BidirectionalIterator __first1, _BidirectionalIterator __last1, _Tp* __first2) {
- return brick_uninitialized_move(__first1, __last1, __first2, _IsVector());
+ return __brick_uninitialized_move(__first1, __last1, __first2, _IsVector());
};
- par_backend::parallel_merge(
+ __par_backend::__parallel_merge(
std::forward<_ExecutionPolicy>(__exec), __first, __middle, __middle, __last, __r, __comp,
[__n, __move_values, __move_sequences](_BidirectionalIterator __f1, _BidirectionalIterator __l1,
_BidirectionalIterator __f2, _BidirectionalIterator __l2, _Tp* __f3,
_Compare __comp) {
- auto __func = par_backend::serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(
+ auto __func = __par_backend::__serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(
__n, __move_values, __move_sequences);
__func(__f1, __l1, __f2, __l2, __f3, __comp);
return __f3 + (__l1 - __f1) + (__l2 - __f2);
});
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n,
- [__r, __first, __is_vector](_Tp* __i, _Tp* __j) {
- brick_move(__i, __j, __first + (__i - __r), __is_vector);
- });
+
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __r, __r + __n,
+ [__r, __first, __is_vector](_Tp* __i, _Tp* __j) {
+ __brick_move(__i, __j, __first + (__i - __r), __is_vector);
+ });
});
}
#endif
@@ -2698,9 +2709,9 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool
-pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept
{
return std::includes(__first1, __last1, __first2, __last2, __comp);
}
@@ -2708,9 +2719,9 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool
-pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
if (__first2 >= __last2)
return true;
@@ -2725,8 +2736,8 @@
if (__last2 - __first2 == 1)
return !__comp(*__first1, *__first2) && !__comp(*__first2, *__first1);
- return except_handler([&]() {
- return !internal::parallel_or(
+ return __except_handler([&]() {
+ return !__parallel_or(
std::forward<_ExecutionPolicy>(__exec), __first2, __last2,
[__first1, __last1, __first2, __last2, &__comp](_ForwardIterator2 __i, _ForwardIterator2 __j) {
assert(__j > __i);
@@ -2768,9 +2779,9 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector, class _SizeFunction, class _SetOP>
_OutputIterator
-parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector)
+__parallel_set_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ _SizeFunction __size_func, _SetOP __set_op, _IsVector __is_vector)
{
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
@@ -2788,18 +2799,18 @@
const _DifferenceType __n1 = __last1 - __first1;
const _DifferenceType __n2 = __last2 - __first2;
- par_backend::buffer<_T> __buf(__size_func(__n1, __n2));
+ __par_backend::__buffer<_T> __buf(__size_func(__n1, __n2));
- return except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp,
- __size_func, __set_op, &__buf]() {
+ return __except_handler([&__exec, __n1, __first1, __last1, __first2, __last2, __result, __is_vector, __comp,
+ __size_func, __set_op, &__buf]() {
auto __buffer = __buf.get();
_DifferenceType __m{};
auto __scan = [=](_DifferenceType, _DifferenceType, const _SetRange& __s) { // Scan
if (!__s.empty())
- brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos,
- __is_vector);
+ __brick_move(__buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos,
+ __is_vector);
};
- par_backend::parallel_strict_scan(
+ __par_backend::parallel_strict_scan(
std::forward<_ExecutionPolicy>(__exec), __n1, _SetRange{0, 0, 0}, //-1, 0},
[=](_DifferenceType __i, _DifferenceType __len) { // Reduce
//[__b; __e) - a subrange of the first sequence, to reduce
@@ -2856,13 +2867,13 @@
#endif
#if __PSTL_USE_PAR_POLICIES
-//a shared parallel pattern for 'pattern_set_union' and 'pattern_set_symmetric_difference'
+//a shared parallel pattern for '__pattern_set_union' and '__pattern_set_symmetric_difference'
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _SetUnionOp, class _IsVector>
_OutputIterator
-parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- _SetUnionOp __set_union_op, _IsVector __is_vector)
+__parallel_set_union_op(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _SetUnionOp __set_union_op, _IsVector __is_vector)
{
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
@@ -2870,21 +2881,21 @@
const auto __n2 = __last2 - __first2;
auto copy_range1 = [__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) {
- return brick_copy(__begin, __end, __res, __is_vector);
+ return __brick_copy(__begin, __end, __res, __is_vector);
};
auto copy_range2 = [__is_vector](_ForwardIterator2 __begin, _ForwardIterator2 __end, _OutputIterator __res) {
- return brick_copy(__begin, __end, __res, __is_vector);
+ return __brick_copy(__begin, __end, __res, __is_vector);
};
// {1} {}: parallel copying just first sequence
if (__n2 == 0)
- return pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1,
- std::true_type());
+ return __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1,
+ std::true_type());
// {} {2}: parallel copying justmake second sequence
if (__n1 == 0)
- return pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2,
- std::true_type());
+ return __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2,
+ std::true_type());
// testing whether the sequences are intersected
_ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp);
@@ -2892,15 +2903,16 @@
if (__left_bound_seq_1 == __last1)
{
//{1} < {2}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2
- par_backend::parallel_invoke(std::forward<_ExecutionPolicy>(__exec),
- [=] {
- pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
- __result, copy_range1, std::true_type());
- },
- [=] {
- pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2,
- __result + __n1, copy_range2, std::true_type());
- });
+ __par_backend::__parallel_invoke(
+ std::forward<_ExecutionPolicy>(__exec),
+ [=] {
+ __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1,
+ std::true_type());
+ },
+ [=] {
+ __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result + __n1,
+ copy_range2, std::true_type());
+ });
return __result + __n1 + __n2;
}
@@ -2910,15 +2922,16 @@
if (__left_bound_seq_2 == __last2)
{
//{2} < {1}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2
- par_backend::parallel_invoke(std::forward<_ExecutionPolicy>(__exec),
- [=] {
- pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2,
- __result, copy_range2, std::true_type());
- },
- [=] {
- pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
- __result + __n2, copy_range1, std::true_type());
- });
+ __par_backend::__parallel_invoke(
+ std::forward<_ExecutionPolicy>(__exec),
+ [=] {
+ __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2,
+ std::true_type());
+ },
+ [=] {
+ __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result + __n2,
+ copy_range1, std::true_type());
+ });
return __result + __n1 + __n2;
}
@@ -2927,18 +2940,18 @@
{
auto __res_or = __result;
__result += __m1; //we know proper offset due to [first1; left_bound_seq_1) < [first2; last2)
- par_backend::parallel_invoke(
+ __par_backend::__parallel_invoke(
std::forward<_ExecutionPolicy>(__exec),
//do parallel copying of [first1; left_bound_seq_1)
[=] {
- pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or,
- copy_range1, std::true_type());
+ __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or,
+ copy_range1, std::true_type());
},
[=, &__result] {
- __result = parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1,
- __first2, __last2, __result, __comp,
- [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
- __set_union_op, __is_vector);
+ __result = __parallel_set_op(
+ std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2, __result,
+ __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op,
+ __is_vector);
});
return __result;
}
@@ -2949,25 +2962,25 @@
{
auto __res_or = __result;
__result += __m2; //we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
- par_backend::parallel_invoke(
+ __par_backend::__parallel_invoke(
std::forward<_ExecutionPolicy>(__exec),
//do parallel copying of [first2; left_bound_seq_2)
[=] {
- pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or,
- copy_range2, std::true_type());
+ __pattern_walk2_brick(std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or,
+ copy_range2, std::true_type());
},
[=, &__result] {
- __result = parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
- __left_bound_seq_2, __last2, __result, __comp,
- [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
- __set_union_op, __is_vector);
+ __result = __parallel_set_op(
+ std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __left_bound_seq_2, __last2, __result,
+ __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op,
+ __is_vector);
});
return __result;
}
- return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
- __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op,
- __is_vector);
+ return __parallel_set_op(
+ std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
+ [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; }, __set_union_op, __is_vector);
}
#endif
@@ -2977,18 +2990,18 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::false_type) noexcept
+__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::false_type) noexcept
{
return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::true_type) noexcept
+__brick_set_union(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
@@ -2997,20 +3010,21 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_set_union(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
+ return __brick_set_union(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- _IsVector __is_vector, /*__is_parallel=*/std::true_type)
+__pattern_set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ _IsVector __is_vector, /*__is_parallel=*/std::true_type)
{
const auto __n1 = __last1 - __first1;
@@ -3021,13 +3035,12 @@
return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
- return parallel_set_union_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
- __comp,
- [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
- return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
- },
- __is_vector);
+ return __parallel_set_union_op(
+ std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
+ [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+ _T* __result,
+ _Compare __comp) { return std::set_union(__first1, __last1, __first2, __last2, __result, __comp); },
+ __is_vector);
}
#endif
@@ -3037,18 +3050,18 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::false_type) noexcept
+__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::false_type) noexcept
{
return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::true_type) noexcept
+__brick_set_intersection(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
@@ -3057,20 +3070,20 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
- _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_set_intersection(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
+ return __brick_set_intersection(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
- _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
@@ -3098,21 +3111,21 @@
if (__m1 > __set_algo_cut_off)
{
//we know proper offset due to [first1; left_bound_seq_1) < [first2; last2)
- return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2,
- __result, __comp,
- [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
- [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
- return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
- },
- __is_vector);
+ return __parallel_set_op(
+ std::forward<_ExecutionPolicy>(__exec), __left_bound_seq_1, __last1, __first2, __last2, __result, __comp,
+ [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
+ [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
+ return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
+ },
+ __is_vector);
}
const auto __m2 = __last2 - __left_bound_seq_2 + __n1;
if (__m2 > __set_algo_cut_off)
{
//we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
- __result = parallel_set_op(
+ __result = __parallel_set_op(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __left_bound_seq_2, __last2, __result, __comp,
[](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
[](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
@@ -3134,18 +3147,18 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::false_type) noexcept
+__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::false_type) noexcept
{
return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::true_type) noexcept
+__brick_set_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
@@ -3154,20 +3167,20 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_set_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
+ return __brick_set_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
@@ -3181,10 +3194,10 @@
// {1} \ {}: parallel copying just first sequence
if (__n2 == 0)
- return pattern_walk2_brick(
+ return __pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result,
[__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) {
- return brick_copy(__begin, __end, __res, __is_vector);
+ return __brick_copy(__begin, __end, __res, __is_vector);
},
std::true_type());
@@ -3192,10 +3205,10 @@
_ForwardIterator1 __left_bound_seq_1 = lower_bound(__first1, __last1, *__first2, __comp);
//{1} < {2}: seq 2 is wholly greater than seq 1, so, parallel copying just first sequence
if (__left_bound_seq_1 == __last1)
- return pattern_walk2_brick(
+ return __pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result,
[__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) {
- return brick_copy(__begin, __end, __res, __is_vector);
+ return __brick_copy(__begin, __end, __res, __is_vector);
},
std::true_type());
@@ -3203,21 +3216,21 @@
_ForwardIterator2 __left_bound_seq_2 = lower_bound(__first2, __last2, *__first1, __comp);
//{2} < {1}: seq 1 is wholly greater than seq 2, so, parallel copying just first sequence
if (__left_bound_seq_2 == __last2)
- return pattern_walk2_brick(
+ return __pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result,
[__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) {
- return brick_copy(__begin, __end, __res, __is_vector);
+ return __brick_copy(__begin, __end, __res, __is_vector);
},
std::true_type());
if (__n1 + __n2 > __set_algo_cut_off)
- return parallel_set_op(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result,
- __comp, [](_DifferenceType __n, _DifferenceType __m) { return __n; },
- [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _T* __result, _Compare __comp) {
- return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
- },
- __is_vector);
+ return __parallel_set_op(
+ std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
+ [](_DifferenceType __n, _DifferenceType __m) { return __n; },
+ [](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _T* __result,
+ _Compare __comp) { return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp); },
+ __is_vector);
// use serial algorithm
return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
@@ -3230,18 +3243,18 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::false_type) noexcept
+__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::false_type) noexcept
{
return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
_OutputIterator
-brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
- /*__is_vector=*/std::true_type) noexcept
+__brick_set_symmetric_difference(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
+ /*__is_vector=*/std::true_type) noexcept
{
__PSTL_PRAGMA_MESSAGE("Vectorized algorithm unimplemented, redirected to serial");
return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
@@ -3250,21 +3263,20 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
- _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_set_symmetric_difference(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp,
- __is_vector);
+ return __brick_set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator,
class _Compare, class _IsVector>
_OutputIterator
-pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
- _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _OutputIterator __result,
+ _Compare __comp, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
const auto __n1 = __last1 - __first1;
@@ -3275,7 +3287,7 @@
return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
typedef typename std::iterator_traits<_OutputIterator>::value_type _T;
- return parallel_set_union_op(
+ return __parallel_set_union_op(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
[](_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2,
_T* __result, _Compare __comp) {
@@ -3291,37 +3303,37 @@
template <class _RandomAccessIterator, class _Compare>
_RandomAccessIterator
-brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
- /* __is_vector = */ std::false_type) noexcept
+__brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
+ /* __is_vector = */ std::false_type) noexcept
{
return std::is_heap_until(__first, __last, __comp);
}
template <class _RandomAccessIterator, class _Compare>
_RandomAccessIterator
-brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
- /* __is_vector = */ std::true_type) noexcept
+__brick_is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
+ /* __is_vector = */ std::true_type) noexcept
{
if (__last - __first < 2)
return __last;
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
- return unseq_backend::simd_first(
+ return __unseq_backend::__simd_first(
__first, _SizeType(0), __last - __first,
[&__comp](_RandomAccessIterator __it, _SizeType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); });
}
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator
-pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
- _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
+__pattern_is_heap_until(_ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_is_heap_until(__first, __last, __comp, __is_vector);
+ return __brick_is_heap_until(__first, __last, __comp, __is_vector);
}
template <class _RandomAccessIterator, class _DifferenceType, class _Compare>
_RandomAccessIterator
-is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
- /* __is_vector = */ std::false_type) noexcept
+__is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
+ /* __is_vector = */ std::false_type) noexcept
{
_DifferenceType __i = __begin;
for (; __i < __end; ++__i)
@@ -3336,10 +3348,10 @@
template <class _RandomAccessIterator, class _DifferenceType, class _Compare>
_RandomAccessIterator
-is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
- /* __is_vector = */ std::true_type) noexcept
+__is_heap_until_local(_RandomAccessIterator __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp,
+ /* __is_vector = */ std::true_type) noexcept
{
- return unseq_backend::simd_first(
+ return __unseq_backend::__simd_first(
__first, __begin, __end,
[&__comp](_RandomAccessIterator __it, _DifferenceType __i) { return __comp(__it[(__i - 1) / 2], __it[__i]); });
}
@@ -3347,17 +3359,17 @@
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsVector>
_RandomAccessIterator
-pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
+__pattern_is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
{
if (__last - __first < 2)
return __last;
- return internal::except_handler([&]() {
- return internal::parallel_find(
+ return __except_handler([&]() {
+ return __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__first, __comp, __is_vector](_RandomAccessIterator __i, _RandomAccessIterator __j) {
- return internal::is_heap_until_local(__first, __i - __first, __j - __first, __comp, __is_vector);
+ return __is_heap_until_local(__first, __i - __first, __j - __first, __comp, __is_vector);
},
std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(), /*is_first=*/true);
});
@@ -3370,19 +3382,19 @@
template <typename _ForwardIterator, typename _Compare>
_ForwardIterator
-brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- /* __is_vector = */ std::false_type) noexcept
+__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ /* __is_vector = */ std::false_type) noexcept
{
return std::min_element(__first, __last, __comp);
}
template <typename _ForwardIterator, typename _Compare>
_ForwardIterator
-brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- /* __is_vector = */ std::true_type) noexcept
+__brick_min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ /* __is_vector = */ std::true_type) noexcept
{
#if __PSTL_UDR_PRESENT
- return unseq_backend::simd_min_element(__first, __last - __first, __comp);
+ return __unseq_backend::__simd_min_element(__first, __last - __first, __comp);
#else
return std::min_element(__first, __last, __comp);
#endif
@@ -3390,31 +3402,31 @@
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
_ForwardIterator
-pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
+__pattern_min_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_min_element(__first, __last, __comp, __is_vector);
+ return __brick_min_element(__first, __last, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _IsVector>
_RandomAccessIterator
-pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
+__pattern_min_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp, _IsVector __is_vector, /* is_parallel = */ std::true_type)
{
if (__first == __last)
return __last;
- return internal::except_handler([&]() {
- return par_backend::parallel_reduce(
+ return __except_handler([&]() {
+ return __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, __first,
[=](_RandomAccessIterator __begin, _RandomAccessIterator __end,
_RandomAccessIterator __init) -> _RandomAccessIterator {
- const _RandomAccessIterator subresult = brick_min_element(__begin, __end, __comp, __is_vector);
- return internal::cmp_iterators_by_values(__init, subresult, __comp);
+ const _RandomAccessIterator subresult = __brick_min_element(__begin, __end, __comp, __is_vector);
+ return __cmp_iterators_by_values(__init, subresult, __comp);
},
[=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator {
- return internal::cmp_iterators_by_values(__it1, __it2, __comp);
+ return __cmp_iterators_by_values(__it1, __it2, __comp);
});
});
}
@@ -3426,19 +3438,19 @@
template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator>
-brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- /* __is_vector = */ std::false_type) noexcept
+__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ /* __is_vector = */ std::false_type) noexcept
{
return std::minmax_element(__first, __last, __comp);
}
template <typename _ForwardIterator, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator>
-brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- /* __is_vector = */ std::true_type) noexcept
+__brick_minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ /* __is_vector = */ std::true_type) noexcept
{
#if __PSTL_UDR_PRESENT
- return unseq_backend::simd_minmax_element(__first, __last - __first, __comp);
+ return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp);
#else
return std::minmax_element(__first, __last, __comp);
#endif
@@ -3446,36 +3458,36 @@
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator>
-pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
+__pattern_minmax_element(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_minmax_element(__first, __last, __comp, __is_vector);
+ return __brick_minmax_element(__first, __last, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare, typename _IsVector>
std::pair<_ForwardIterator, _ForwardIterator>
-pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
- _IsVector __is_vector, /* is_parallel = */ std::true_type)
+__pattern_minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp,
+ _IsVector __is_vector, /* is_parallel = */ std::true_type)
{
if (__first == __last)
return std::make_pair(__first, __first);
- return internal::except_handler([&]() {
+ return __except_handler([&]() {
typedef std::pair<_ForwardIterator, _ForwardIterator> _Result;
- return par_backend::parallel_reduce(
+ return __par_backend::__parallel_reduce(
std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, std::make_pair(__first, __first),
[=](_ForwardIterator __begin, _ForwardIterator __end, _Result __init) -> _Result {
- const _Result __subresult = brick_minmax_element(__begin, __end, __comp, __is_vector);
- return std::make_pair(internal::cmp_iterators_by_values(__subresult.first, __init.first, __comp),
- internal::cmp_iterators_by_values(__init.second, __subresult.second,
- internal::not_pred<_Compare>(__comp)));
+ const _Result __subresult = __brick_minmax_element(__begin, __end, __comp, __is_vector);
+ return std::make_pair(
+ __cmp_iterators_by_values(__subresult.first, __init.first, __comp),
+ __cmp_iterators_by_values(__init.second, __subresult.second, __not_pred<_Compare>(__comp)));
},
[=](_Result __p1, _Result __p2) -> _Result {
return std::make_pair(
- internal::cmp_iterators_by_values(__p1.first, __p2.first, __comp),
- internal::cmp_iterators_by_values(__p2.second, __p1.second, internal::not_pred<_Compare>(__comp)));
+ __cmp_iterators_by_values(__p1.first, __p2.first, __comp),
+ __cmp_iterators_by_values(__p2.second, __p1.second, __not_pred<_Compare>(__comp)));
});
});
}
@@ -3486,8 +3498,8 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
std::pair<_ForwardIterator1, _ForwardIterator2>
-mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _BinaryPredicate __pred)
+__mismatch_serial(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _BinaryPredicate __pred)
{
#if __PSTL_CPP14_2RANGE_MISMATCH_EQUAL_PRESENT
return std::mismatch(__first1, __last1, __first2, __last2, __pred);
@@ -3501,45 +3513,45 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
std::pair<_ForwardIterator1, _ForwardIterator2>
-brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::false_type) noexcept
+__brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::false_type) noexcept
{
- return internal::mismatch_serial(__first1, __last1, __first2, __last2, __pred);
+ return __mismatch_serial(__first1, __last1, __first2, __last2, __pred);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
std::pair<_ForwardIterator1, _ForwardIterator2>
-brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::true_type) noexcept
+__brick_mismatch(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _Predicate __pred, /* __is_vector = */ std::true_type) noexcept
{
auto __n = std::min(__last1 - __first1, __last2 - __first2);
- return unseq_backend::simd_first(__first1, __n, __first2, not_pred<_Predicate>(__pred));
+ return __unseq_backend::__simd_first(__first1, __n, __first2, __not_pred<_Predicate>(__pred));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate, class _IsVector>
std::pair<_ForwardIterator1, _ForwardIterator2>
-pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector,
- /* is_parallel = */ std::false_type) noexcept
+__pattern_mismatch(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Predicate __pred, _IsVector __is_vector,
+ /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector);
+ return __brick_mismatch(__first1, __last1, __first2, __last2, __pred, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate,
class _IsVector>
std::pair<_RandomAccessIterator1, _RandomAccessIterator2>
-pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
- _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred,
- _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
+__pattern_mismatch(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _Predicate __pred,
+ _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
{
- return internal::except_handler([&]() {
+ return __except_handler([&]() {
auto __n = std::min(__last1 - __first1, __last2 - __first2);
- auto __result = internal::parallel_find(
+ auto __result = __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
[__first1, __first2, __pred, __is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
- return internal::brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1),
- __pred, __is_vector)
+ return __brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), __pred,
+ __is_vector)
.first;
},
std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(), /*is_first=*/true);
@@ -3554,16 +3566,17 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
bool
-brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::false_type) noexcept
+__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _Compare __comp,
+ /* __is_vector = */ std::false_type) noexcept
{
return std::lexicographical_compare(__first1, __last1, __first2, __last2, __comp);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
bool
-brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
- _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::true_type) noexcept
+__brick_lexicographical_compare(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
+ _ForwardIterator2 __last2, _Compare __comp, /* __is_vector = */ std::true_type) noexcept
{
if (__first2 == __last2)
{ // if second sequence is empty
@@ -3580,7 +3593,7 @@
--__last1;
--__last2;
auto __n = std::min(__last1 - __first1, __last2 - __first2);
- std::pair<_ForwardIterator1, _ForwardIterator2> __result = unseq_backend::simd_first(
+ std::pair<_ForwardIterator1, _ForwardIterator2> __result = __unseq_backend::__simd_first(
__first1, __n, __first2, [__comp](const ref_type1 __x, const ref_type2 __y) mutable {
return __comp(__x, __y) || __comp(__y, __x);
});
@@ -3598,19 +3611,19 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool
-pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
- _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
+__pattern_lexicographical_compare(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
+ _IsVector __is_vector, /* is_parallel = */ std::false_type) noexcept
{
- return internal::brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector);
+ return __brick_lexicographical_compare(__first1, __last1, __first2, __last2, __comp, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare, class _IsVector>
bool
-pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
- _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
+__pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp,
+ _IsVector __is_vector, /* is_parallel = */ std::true_type) noexcept
{
if (__first2 == __last2)
{ // if second sequence is empty
@@ -3627,14 +3640,15 @@
--__last1;
--__last2;
auto __n = std::min(__last1 - __first1, __last2 - __first2);
- auto __result = internal::parallel_find(
+ auto __result = __parallel_find(
std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n,
[__first1, __first2, &__comp, __is_vector](_ForwardIterator1 __i, _ForwardIterator1 __j) {
- return brick_mismatch(__i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1),
- [&__comp](const _RefType1 __x, const _RefType2 __y) {
- return !__comp(__x, __y) && !__comp(__y, __x);
- },
- __is_vector)
+ return __brick_mismatch(
+ __i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1),
+ [&__comp](const _RefType1 __x, const _RefType2 __y) {
+ return !__comp(__x, __y) && !__comp(__y, __x);
+ },
+ __is_vector)
.first;
},
std::less<typename std::iterator_traits<_ForwardIterator1>::difference_type>(), /*is_first=*/true);
@@ -3651,7 +3665,7 @@
}
#endif
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_algorithm_impl_H */
diff --git a/include/pstl/internal/execution_defs.h b/include/pstl/internal/execution_defs.h
index 42faf2f..be8a4a3 100644
--- a/include/pstl/internal/execution_defs.h
+++ b/include/pstl/internal/execution_defs.h
@@ -149,13 +149,13 @@
} // namespace v1
} // namespace execution
-namespace internal
+namespace __internal
{
template <class ExecPolicy, class T>
-using enable_if_execution_policy =
+using __enable_if_execution_policy =
typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<ExecPolicy>::type>::value,
T>::type;
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
diff --git a/include/pstl/internal/execution_impl.h b/include/pstl/internal/execution_impl.h
index 24f5508..f33e6fc 100644
--- a/include/pstl/internal/execution_impl.h
+++ b/include/pstl/internal/execution_impl.h
@@ -17,7 +17,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
using namespace __pstl::execution;
@@ -25,54 +25,54 @@
/* predicate */
template <typename _Tp>
-std::false_type lazy_and(_Tp, std::false_type)
+std::false_type __lazy_and(_Tp, std::false_type)
{
return std::false_type{};
};
template <typename _Tp>
inline _Tp
-lazy_and(_Tp __a, std::true_type)
+__lazy_and(_Tp __a, std::true_type)
{
return __a;
}
template <typename _Tp>
-std::true_type lazy_or(_Tp, std::true_type)
+std::true_type __lazy_or(_Tp, std::true_type)
{
return std::true_type{};
};
template <typename _Tp>
inline _Tp
-lazy_or(_Tp __a, std::false_type)
+__lazy_or(_Tp __a, std::false_type)
{
return __a;
}
/* iterator */
template <typename _IteratorType, typename... _OtherIteratorTypes>
-struct is_random_access_iterator
+struct __is_random_access_iterator
{
static constexpr bool value =
- is_random_access_iterator<_IteratorType>::value && is_random_access_iterator<_OtherIteratorTypes...>::value;
+ __is_random_access_iterator<_IteratorType>::value && __is_random_access_iterator<_OtherIteratorTypes...>::value;
typedef std::integral_constant<bool, value> type;
};
template <typename _IteratorType>
-struct is_random_access_iterator<_IteratorType>
+struct __is_random_access_iterator<_IteratorType>
: std::is_same<typename std::iterator_traits<_IteratorType>::iterator_category, std::random_access_iterator_tag>
{
};
/* policy */
template <typename Policy>
-struct policy_traits
+struct __policy_traits
{
};
template <>
-struct policy_traits<sequenced_policy>
+struct __policy_traits<sequenced_policy>
{
typedef std::false_type allow_parallel;
typedef std::false_type allow_unsequenced;
@@ -80,7 +80,7 @@
};
template <>
-struct policy_traits<unsequenced_policy>
+struct __policy_traits<unsequenced_policy>
{
typedef std::false_type allow_parallel;
typedef std::true_type allow_unsequenced;
@@ -89,7 +89,7 @@
#if __PSTL_USE_PAR_POLICIES
template <>
-struct policy_traits<parallel_policy>
+struct __policy_traits<parallel_policy>
{
typedef std::true_type allow_parallel;
typedef std::false_type allow_unsequenced;
@@ -97,7 +97,7 @@
};
template <>
-struct policy_traits<parallel_unsequenced_policy>
+struct __policy_traits<parallel_unsequenced_policy>
{
typedef std::true_type allow_parallel;
typedef std::true_type allow_unsequenced;
@@ -106,50 +106,50 @@
#endif
template <typename _ExecutionPolicy>
-using collector_t = typename policy_traits<typename std::decay<_ExecutionPolicy>::type>::collector_type;
+using __collector_t = typename __policy_traits<typename std::decay<_ExecutionPolicy>::type>::__collector_type;
template <typename _ExecutionPolicy>
-using allow_vector = typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_vector;
+using __allow_vector = typename __policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_vector;
template <typename _ExecutionPolicy>
-using allow_unsequenced =
- typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_unsequenced;
+using __allow_unsequenced = typename __policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_unsequenced;
template <typename _ExecutionPolicy>
-using allow_parallel = typename internal::policy_traits<typename std::decay<_ExecutionPolicy>::type>::allow_parallel;
+using __allow_parallel = typename __policy_traits<typename std::decay<_ExecutionPolicy>::type>::__allow_parallel;
template <typename _ExecutionPolicy, typename... _IteratorTypes>
auto
-is_vectorization_preferred(_ExecutionPolicy&& __exec)
- -> decltype(lazy_and(__exec.__allow_vector(), typename is_random_access_iterator<_IteratorTypes...>::type()))
+__is_vectorization_preferred(_ExecutionPolicy&& __exec)
+ -> decltype(__lazy_and(__exec.__allow_vector(), typename __is_random_access_iterator<_IteratorTypes...>::type()))
{
- return internal::lazy_and(__exec.__allow_vector(), typename is_random_access_iterator<_IteratorTypes...>::type());
+ return __lazy_and(__exec.__allow_vector(), typename __is_random_access_iterator<_IteratorTypes...>::type());
}
template <typename _ExecutionPolicy, typename... _IteratorTypes>
auto
-is_parallelization_preferred(_ExecutionPolicy&& __exec)
- -> decltype(lazy_and(__exec.__allow_parallel(), typename is_random_access_iterator<_IteratorTypes...>::type()))
+__is_parallelization_preferred(_ExecutionPolicy&& __exec)
+ -> decltype(__lazy_and(__exec.__allow_parallel(), typename __is_random_access_iterator<_IteratorTypes...>::type()))
{
- return internal::lazy_and(__exec.__allow_parallel(), typename is_random_access_iterator<_IteratorTypes...>::type());
+ return __lazy_and(__exec.__allow_parallel(), typename __is_random_access_iterator<_IteratorTypes...>::type());
}
template <typename policy, typename... _IteratorTypes>
-struct prefer_unsequenced_tag
+struct __prefer_unsequenced_tag
{
static constexpr bool value =
- allow_unsequenced<policy>::value && is_random_access_iterator<_IteratorTypes...>::value;
+ __allow_unsequenced<policy>::value && __is_random_access_iterator<_IteratorTypes...>::value;
typedef std::integral_constant<bool, value> type;
};
template <typename policy, typename... _IteratorTypes>
-struct prefer_parallel_tag
+struct __prefer_parallel_tag
{
- static constexpr bool value = allow_parallel<policy>::value && is_random_access_iterator<_IteratorTypes...>::value;
+ static constexpr bool value =
+ __allow_parallel<policy>::value && __is_random_access_iterator<_IteratorTypes...>::value;
typedef std::integral_constant<bool, value> type;
};
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_execution_impl_H */
diff --git a/include/pstl/internal/glue_algorithm_defs.h b/include/pstl/internal/glue_algorithm_defs.h
index 54638f8..c622ed3 100644
--- a/include/pstl/internal/glue_algorithm_defs.h
+++ b/include/pstl/internal/glue_algorithm_defs.h
@@ -20,422 +20,422 @@
// [alg.any_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
// [alg.all_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
// [alg.none_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
// [alg.foreach]
template <class _ExecutionPolicy, class _ForwardIterator, class _Function>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f);
// [alg.find]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
// [alg.find.end]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last, _BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last);
// [alg.find_first_of]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__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);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __s_first, _ForwardIterator2 __s_last);
// [alg.adjacent_find]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);
// [alg.count]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy,
- typename iterator_traits<_ForwardIterator>::difference_type>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+ typename iterator_traits<_ForwardIterator>::difference_type>
count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy,
- typename iterator_traits<_ForwardIterator>::difference_type>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+ typename iterator_traits<_ForwardIterator>::difference_type>
count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
// [alg.search]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last, _BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
const _Tp& __value, _BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
const _Tp& __value);
// [alg.copy]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result,
_Predicate __pred);
// [alg.swap]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2);
// [alg.transform]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
_UnaryOperation __op);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator __result, _BinaryOperation __op);
// [alg.replace]
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
const _Tp& __new_value);
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value,
const _Tp& __new_value);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
const _Tp& __old_value, const _Tp& __new_value);
// [alg.fill]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value);
// [alg.generate]
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g);
// [alg.remove]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _Predicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
const _Tp& __value);
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
// [alg.unique]
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
_BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);
// [alg.reverse]
template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last);
template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_ForwardIterator __d_first);
// [alg.rotate]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
_ForwardIterator2 __result);
// [alg.partitions]
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_UnaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__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);
// [alg.sort]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
// [stable.sort]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
// [mismatch]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate __pred);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
// [alg.equal]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate __p);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __p);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2);
// [alg.move]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);
// [partial.sort]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
_RandomAccessIterator __last);
// [partial.sort.copy]
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+__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);
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
_RandomAccessIterator __d_first, _RandomAccessIterator __d_last);
// [is.sorted]
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
// [alg.nth.element]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last);
// [alg.merge]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __d_first);
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
_BidirectionalIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
_BidirectionalIterator __last);
// [includes]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2);
@@ -443,12 +443,12 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __result);
@@ -456,12 +456,12 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);
@@ -469,12 +469,12 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);
@@ -482,68 +482,68 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__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);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);
// [is.heap]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
// [alg.min.max]
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
// [alg.lex.comparison]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2);
diff --git a/include/pstl/internal/glue_algorithm_impl.h b/include/pstl/internal/glue_algorithm_impl.h
index d46f17f..b0bf40e 100644
--- a/include/pstl/internal/glue_algorithm_impl.h
+++ b/include/pstl/internal/glue_algorithm_impl.h
@@ -23,29 +23,30 @@
// [alg.any_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
using namespace __pstl;
- return internal::pattern_any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ return __internal::__pattern_any_of(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
// [alg.all_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Pred>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred)
{
return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- __pstl::internal::not_pred<_Pred>(__pred));
+ __pstl::__internal::__not_pred<_Pred>(__pred));
}
// [alg.none_of]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
return !std::any_of(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
@@ -54,121 +55,121 @@
// [alg.foreach]
template <class _ExecutionPolicy, class _ForwardIterator, class _Function>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f)
{
using namespace __pstl;
- internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last, __f,
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f)
{
using namespace __pstl;
- return internal::pattern_walk1_n(
+ return __internal::__pattern_walk1_n(
std::forward<_ExecutionPolicy>(__exec), __first, __n, __f,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
// [alg.find]
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
using namespace __pstl;
- return internal::pattern_find_if(
+ return __internal::__pattern_find_if(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- __pstl::internal::not_pred<_Predicate>(__pred));
+ __pstl::__internal::__not_pred<_Predicate>(__pred));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
return std::find_if(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- __pstl::internal::equal_value<_Tp>(__value));
+ __pstl::__internal::__equal_value<_Tp>(__value));
}
// [alg.find.end]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last, _BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_find_end(
+ return __internal::__pattern_find_end(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__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,
- __pstl::internal::pstl_equal());
+ __pstl::__internal::__pstl_equal());
}
// [alg.find_first_of]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__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)
{
using namespace __pstl;
- return internal::pattern_find_first_of(
+ return __internal::__pattern_find_first_of(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__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,
- __pstl::internal::pstl_equal());
+ __pstl::__internal::__pstl_equal());
}
// [alg.adjacent_find]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
using namespace __pstl;
- return internal::pattern_adjacent_find(
+ return __internal::__pattern_adjacent_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<_ValueType>(),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
}
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_adjacent_find(
+ return __internal::__pattern_adjacent_find(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
}
// [alg.count]
@@ -177,66 +178,68 @@
// 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>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+ typename iterator_traits<_ForwardIterator>::difference_type>
count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
using namespace __pstl;
- return internal::pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [&__value](const _ValueType& __x) { return __value == __x; },
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ return __internal::__pattern_count(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [&__value](const _ValueType& __x) { return __value == __x; },
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy,
- typename iterator_traits<_ForwardIterator>::difference_type>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+ typename iterator_traits<_ForwardIterator>::difference_type>
count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
{
using namespace __pstl;
- return internal::pattern_count(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ return __internal::__pattern_count(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
// [alg.search]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
_ForwardIterator2 __s_last, _BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_search(
+ return __internal::__pattern_search(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
+__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,
- __pstl::internal::pstl_equal());
+ __pstl::__internal::__pstl_equal());
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
const _Tp& __value, _BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_search_n(
+ return __internal::__pattern_search_n(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
const _Tp& __value)
{
@@ -247,89 +250,89 @@
// [alg.copy]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result)
{
using namespace __pstl;
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
- return internal::pattern_walk2_brick(
+ return __internal::__pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
[__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
- return internal::brick_copy(__begin, __end, __res, __is_vector);
+ return __internal::__brick_copy(__begin, __end, __res, __is_vector);
},
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result)
{
using namespace __pstl;
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
- return internal::pattern_walk2_brick_n(
+ return __internal::__pattern_walk2_brick_n(
std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
[__is_vector](_ForwardIterator1 __begin, _Size __sz, _ForwardIterator2 __res) {
- return internal::brick_copy_n(__begin, __sz, __res, __is_vector);
+ return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector);
},
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
_Predicate __pred)
{
using namespace __pstl;
- return internal::pattern_copy_if(
+ return __internal::__pattern_copy_if(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
// [alg.swap]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2)
{
using namespace __pstl;
typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
- return internal::pattern_walk2(
+ return __internal::__pattern_walk2(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2,
[](_ReferenceType1 __x, _ReferenceType2 __y) {
using std::swap;
swap(__x, __y);
},
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
// [alg.transform]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
_UnaryOperation __op)
{
typedef typename iterator_traits<_ForwardIterator1>::reference _InputType;
typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType;
using namespace __pstl;
- return internal::pattern_walk2(
+ return __internal::__pattern_walk2(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
[__op](_InputType __x, _OutputType __y) mutable { __y = __op(__x); },
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator __result, _BinaryOperation __op)
{
@@ -337,311 +340,317 @@
typedef typename iterator_traits<_ForwardIterator2>::reference _Input2Type;
typedef typename iterator_traits<_ForwardIterator>::reference _OutputType;
using namespace __pstl;
- return internal::pattern_walk3(
+ return __internal::__pattern_walk3(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __result,
[__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); },
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec));
}
// [alg.replace]
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
const _Tp& __new_value)
{
using namespace __pstl;
typedef typename iterator_traits<_ForwardIterator>::reference _ElementType;
- internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [&__pred, &__new_value](_ElementType __elem) {
- if (__pred(__elem))
- {
- __elem = __new_value;
- }
- },
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__pattern_walk1(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [&__pred, &__new_value](_ElementType __elem) {
+ if (__pred(__elem))
+ {
+ __elem = __new_value;
+ }
+ },
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value,
const _Tp& __new_value)
{
std::replace_if(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- __pstl::internal::equal_value<_Tp>(__old_value), __new_value);
+ __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value);
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value)
{
typedef typename iterator_traits<_ForwardIterator1>::reference _InputType;
typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType;
using namespace __pstl;
- return internal::pattern_walk2(
+ return __internal::__pattern_walk2(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
[__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; },
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
const _Tp& __old_value, const _Tp& __new_value)
{
return std::replace_copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
- __pstl::internal::equal_value<_Tp>(__old_value), __new_value);
+ __pstl::__internal::__equal_value<_Tp>(__old_value), __new_value);
}
// [alg.fill]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
using namespace __pstl;
- internal::pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value,
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__pattern_fill(std::forward<_ExecutionPolicy>(__exec), __first, __last, __value,
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value)
{
if (__count <= 0)
return __first;
using namespace __pstl;
- return internal::pattern_fill_n(std::forward<_ExecutionPolicy>(__exec), __first, __count, __value,
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ return __internal::__pattern_fill_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __count, __value,
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
// [alg.generate]
template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g)
{
using namespace __pstl;
- internal::pattern_generate(std::forward<_ExecutionPolicy>(__exec), __first, __last, __g,
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__pattern_generate(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __g,
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, _Generator __g)
{
if (__count <= 0)
return __first;
using namespace __pstl;
- return internal::pattern_generate_n(
+ return __internal::__pattern_generate_n(
std::forward<_ExecutionPolicy>(__exec), __first, __count, __g,
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
// [alg.remove]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__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,
- __pstl::internal::not_pred<_Predicate>(__pred));
+ __pstl::__internal::__not_pred<_Predicate>(__pred));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__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));
+ __pstl::__internal::__not_equal_value<_Tp>(__value));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_remove_if(
+ return __internal::__pattern_remove_if(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__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));
+ __pstl::__internal::__equal_value<_Tp>(__value));
}
// [alg.unique]
template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ return __internal::__pattern_unique(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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, __pstl::internal::pstl_equal());
+ return std::unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__pstl_equal());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
_BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_unique_copy(
+ return __internal::__pattern_unique_copy(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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, __pstl::internal::pstl_equal());
+ return std::unique_copy(__exec, __first, __last, __result, __pstl::__internal::__pstl_equal());
}
// [alg.reverse]
template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last)
{
using namespace __pstl;
- internal::pattern_reverse(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
+ __internal::__pattern_reverse(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
}
template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_ForwardIterator __d_first)
{
using namespace __pstl;
- return internal::pattern_reverse_copy(
+ return __internal::__pattern_reverse_copy(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first,
- internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator, _ForwardIterator>(__exec));
}
// [alg.rotate]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
{
using namespace __pstl;
- return internal::pattern_rotate(std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ return __internal::__pattern_rotate(
+ std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last,
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
_ForwardIterator2 __result)
{
using namespace __pstl;
- return internal::pattern_rotate_copy(
+ return __internal::__pattern_rotate_copy(
std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
// [alg.partitions]
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_is_partitioned(
+ return __internal::__pattern_is_partitioned(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_partition(
+ return __internal::__pattern_partition(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
_UnaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_stable_partition(
+ return __internal::__pattern_stable_partition(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
class _UnaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__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)
{
using namespace __pstl;
- return internal::pattern_partition_copy(
+ return __internal::__pattern_partition_copy(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1, _ForwardIterator2>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
- _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
+ _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _ForwardIterator1,
+ _ForwardIterator2>(__exec));
}
// [alg.sort]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
using namespace __pstl;
- return internal::pattern_sort(
+ return __internal::__pattern_sort(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
typename std::is_move_constructible<_InputType>::type());
}
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last)
{
typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
@@ -651,18 +660,18 @@
// [stable.sort]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_stable_sort(
+ return __internal::__pattern_stable_sort(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
}
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__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;
@@ -672,19 +681,19 @@
// [mismatch]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __pred)
{
using namespace __pstl;
- return internal::pattern_mismatch(
+ return __internal::__pattern_mismatch(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate __pred)
{
@@ -693,16 +702,16 @@
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _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,
- __pstl::internal::pstl_equal());
+ __pstl::__internal::__pstl_equal());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _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"
@@ -713,26 +722,27 @@
// [alg.equal]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_BinaryPredicate __p)
{
using namespace __pstl;
- return internal::pattern_equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec));
+ return __internal::__pattern_equal(
+ std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p,
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__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,
- __pstl::internal::pstl_equal());
+ __pstl::__internal::__pstl_equal());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _BinaryPredicate __p)
{
@@ -743,46 +753,47 @@
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__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, __pstl::internal::pstl_equal());
+ return equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2,
+ __pstl::__internal::__pstl_equal());
}
// [alg.move]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first)
{
using namespace __pstl;
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec);
- return internal::pattern_walk2_brick(
+ return __internal::__pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first,
[__is_vector](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
- return internal::brick_move(__begin, __end, __res, __is_vector);
+ return __internal::__brick_move(__begin, __end, __res, __is_vector);
},
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
// [partial.sort]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
_RandomAccessIterator __last, _Compare __comp)
{
using namespace __pstl;
- internal::pattern_partial_sort(
+ __internal::__pattern_partial_sort(
std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
}
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
_RandomAccessIterator __last)
{
@@ -793,41 +804,41 @@
// [partial.sort.copy]
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+__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)
{
using namespace __pstl;
- return internal::pattern_partial_sort_copy(
+ return __internal::__pattern_partial_sort_copy(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator, _RandomAccessIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
// [is.sorted]
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
using namespace __pstl;
- const _ForwardIterator __res = internal::pattern_adjacent_find(
- std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::internal::reorder_pred<_Compare>(__comp),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
+ const _ForwardIterator __res = __internal::__pattern_adjacent_find(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred<_Compare>(__comp),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec), /*first_semantic*/ false);
return __res == __last ? __last : std::next(__res);
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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;
@@ -835,19 +846,19 @@
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_adjacent_find(
- std::forward<_ExecutionPolicy>(__exec), __first, __last, internal::reorder_pred<_Compare>(__comp),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ return __internal::__pattern_adjacent_find(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __internal::__reorder_pred<_Compare>(__comp),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
/*or_semantic*/ true) == __last;
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__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;
@@ -857,42 +868,42 @@
// [alg.merge]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_merge(
+ return __internal::__pattern_merge(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __d_first)
{
return std::merge(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __d_first,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
_BidirectionalIterator __last, _Compare __comp)
{
using namespace __pstl;
- internal::pattern_inplace_merge(
+ __internal::__pattern_inplace_merge(
std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _BidirectionalIterator>(__exec));
}
template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
_BidirectionalIterator __last)
{
@@ -903,145 +914,145 @@
// [includes]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_includes(
+ return __internal::__pattern_includes(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__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,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
// [set.union]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
_ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_set_union(
+ return __internal::__pattern_set_union(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
// [set.intersection]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_set_intersection(
+ return __internal::__pattern_set_intersection(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
// [set.difference]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_set_difference(
+ return __internal::__pattern_set_difference(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
// [set.symmetric.difference]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__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)
{
using namespace __pstl;
- return internal::pattern_set_symmetric_difference(
+ return __internal::__pattern_set_symmetric_difference(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2, _ForwardIterator>(
- __exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
- _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2,
+ _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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, __pstl::internal::pstl_less());
+ __result, __pstl::__internal::__pstl_less());
}
// [is.heap]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_is_heap_until(
+ return __internal::__pattern_is_heap_until(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
}
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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;
@@ -1049,14 +1060,14 @@
}
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__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>
+__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;
@@ -1066,18 +1077,18 @@
// [alg.min.max]
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_min_element(
+ return __internal::__pattern_min_element(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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;
@@ -1085,35 +1096,35 @@
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__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));
+ __pstl::__internal::__reorder_pred<_Compare>(__comp));
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _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>()));
+ __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>>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_minmax_element(
+ return __internal::__pattern_minmax_element(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _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;
@@ -1123,19 +1134,19 @@
// [alg.nth.element]
template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last, _Compare __comp)
{
using namespace __pstl;
- internal::pattern_nth_element(
+ __internal::__pattern_nth_element(
std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _RandomAccessIterator>(__exec));
}
template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
_RandomAccessIterator __last)
{
@@ -1146,24 +1157,24 @@
// [alg.lex.comparison]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp)
{
using namespace __pstl;
- return internal::pattern_lexicographical_compare(
+ return __internal::__pattern_lexicographical_compare(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, bool>
+__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,
- __pstl::internal::pstl_less());
+ __pstl::__internal::__pstl_less());
}
} // namespace std
diff --git a/include/pstl/internal/glue_memory_defs.h b/include/pstl/internal/glue_memory_defs.h
index d00faeb..79e4ed7 100644
--- a/include/pstl/internal/glue_memory_defs.h
+++ b/include/pstl/internal/glue_memory_defs.h
@@ -18,61 +18,61 @@
// [uninitialized.copy]
template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);
// [uninitialized.move]
template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);
// [uninitialized.fill]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value);
// [specialized.destroy]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
// [uninitialized.construct.default]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
// [uninitialized.construct.value]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
} // namespace std
diff --git a/include/pstl/internal/glue_memory_impl.h b/include/pstl/internal/glue_memory_impl.h
index 47bbffc..9cfea41 100644
--- a/include/pstl/internal/glue_memory_impl.h
+++ b/include/pstl/internal/glue_memory_impl.h
@@ -19,7 +19,7 @@
// [uninitialized.copy]
template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
@@ -29,31 +29,32 @@
using namespace __pstl;
const auto __is_parallel =
- internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
[&]() {
- return internal::pattern_walk2_brick(
+ return __internal::__pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
[__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) {
- return internal::brick_copy(__begin, __end, __res, __is_vector);
+ return __internal::__brick_copy(__begin, __end, __res, __is_vector);
},
__is_parallel);
},
[&]() {
- return internal::pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
- [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
- ::new (std::addressof(__val2)) _ValueType2(__val1);
- },
- __is_vector, __is_parallel);
+ return __internal::__pattern_walk2(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
+ [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
+ ::new (std::addressof(__val2)) _ValueType2(__val1);
+ },
+ __is_vector, __is_parallel);
});
}
template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
@@ -63,33 +64,34 @@
using namespace __pstl;
const auto __is_parallel =
- internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
[&]() {
- return internal::pattern_walk2_brick_n(
+ return __internal::__pattern_walk2_brick_n(
std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
[__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) {
- return internal::brick_copy_n(__begin, __sz, __res, __is_vector);
+ return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector);
},
__is_parallel);
},
[&]() {
- return internal::pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
- [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
- ::new (std::addressof(__val2)) _ValueType2(__val1);
- },
- __is_vector, __is_parallel);
+ return __internal::__pattern_walk2_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
+ [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
+ ::new (std::addressof(__val2)) _ValueType2(__val1);
+ },
+ __is_vector, __is_parallel);
});
}
// [uninitialized.move]
template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
@@ -99,31 +101,32 @@
using namespace __pstl;
const auto __is_parallel =
- internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
[&]() {
- return internal::pattern_walk2_brick(
+ return __internal::__pattern_walk2_brick(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
[__is_vector](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) {
- return internal::brick_copy(__begin, __end, __res, __is_vector);
+ return __internal::__brick_copy(__begin, __end, __res, __is_vector);
},
__is_parallel);
},
[&]() {
- return internal::pattern_walk2(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
- [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
- ::new (std::addressof(__val2)) _ValueType2(std::move(__val1));
- },
- __is_vector, __is_parallel);
+ return __internal::__pattern_walk2(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
+ [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
+ ::new (std::addressof(__val2)) _ValueType2(std::move(__val1));
+ },
+ __is_vector, __is_parallel);
});
}
template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result)
{
typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
@@ -133,53 +136,55 @@
using namespace __pstl;
const auto __is_parallel =
- internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
const auto __is_vector =
- internal::is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::integral_constant < bool, std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
[&]() {
- return internal::pattern_walk2_brick_n(
+ return __internal::__pattern_walk2_brick_n(
std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
[__is_vector](_InputIterator __begin, _Size __sz, _ForwardIterator __res) {
- return internal::brick_copy_n(__begin, __sz, __res, __is_vector);
+ return __internal::__brick_copy_n(__begin, __sz, __res, __is_vector);
},
__is_parallel);
},
[&]() {
- return internal::pattern_walk2_n(std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
- [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
- ::new (std::addressof(__val2)) _ValueType2(std::move(__val1));
- },
- __is_vector, __is_parallel);
+ return __internal::__pattern_walk2_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n, __result,
+ [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
+ ::new (std::addressof(__val2)) _ValueType2(std::move(__val1));
+ },
+ __is_vector, __is_parallel);
});
}
// [uninitialized.fill]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- internal::invoke_if_else(
+ __internal::__invoke_if_else(
std::is_arithmetic<_ValueType>(),
[&]() {
- internal::pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [&__value, &__is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
- internal::brick_fill(__begin, __end, _ValueType(__value), __is_vector);
- },
- __is_parallel);
+ __internal::__pattern_walk_brick(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [&__value, &__is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
+ __internal::__brick_fill(__begin, __end, _ValueType(__value), __is_vector);
+ },
+ __is_parallel);
},
[&]() {
- internal::pattern_walk1(
+ __internal::__pattern_walk1(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector,
__is_parallel);
@@ -187,28 +192,28 @@
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::is_arithmetic<_ValueType>(),
[&]() {
- return internal::pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n,
- [&__value, &__is_vector](_ForwardIterator __begin, _Size __count) {
- return internal::brick_fill_n(__begin, __count,
- _ValueType(__value), __is_vector);
- },
- __is_parallel);
+ return __internal::__pattern_walk_brick_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n,
+ [&__value, &__is_vector](_ForwardIterator __begin, _Size __count) {
+ return __internal::__brick_fill_n(__begin, __count, _ValueType(__value), __is_vector);
+ },
+ __is_parallel);
},
[&]() {
- return internal::pattern_walk1_n(
+ return __internal::__pattern_walk1_n(
std::forward<_ExecutionPolicy>(__exec), __first, __n,
[&__value](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(__value); }, __is_vector,
__is_parallel);
@@ -218,136 +223,138 @@
// [specialized.destroy]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- internal::invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() {
- internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector, __is_parallel);
+ __internal::__invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() {
+ __internal::__pattern_walk1(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) { __val.~_ValueType(); },
+ __is_vector, __is_parallel);
});
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::is_trivially_destructible<_ValueType>(), [&]() { return std::next(__first, __n); },
[&]() {
- return internal::pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n,
- [](_ReferenceType __val) { __val.~_ValueType(); }, __is_vector,
- __is_parallel);
+ return __internal::__pattern_walk1_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) { __val.~_ValueType(); },
+ __is_vector, __is_parallel);
});
}
// [uninitialized.construct.default]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- internal::invoke_if_not(std::is_trivial<_ValueType>(), [&]() {
- internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector,
- __is_parallel);
+ __internal::__invoke_if_not(std::is_trivial<_ValueType>(), [&]() {
+ __internal::__pattern_walk1(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, __is_parallel);
});
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- return internal::invoke_if_else(std::is_trivial<_ValueType>(), [&]() { return std::next(__first, __n); },
- [&]() {
- return internal::pattern_walk1_n(
- std::forward<_ExecutionPolicy>(__exec), __first, __n,
- [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; },
- __is_vector, __is_parallel);
- });
+ return __internal::__invoke_if_else(
+ std::is_trivial<_ValueType>(), [&]() { return std::next(__first, __n); },
+ [&]() {
+ return __internal::__pattern_walk1_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n,
+ [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType; }, __is_vector, __is_parallel);
+ });
}
// [uninitialized.construct.value]
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, void>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- internal::invoke_if_else(
+ __internal::__invoke_if_else(
std::is_trivial<_ValueType>(),
[&]() {
- internal::pattern_walk_brick(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
- internal::brick_fill(__begin, __end, _ValueType(), __is_vector);
- },
- __is_parallel);
+ __internal::__pattern_walk_brick(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__is_vector](_ForwardIterator __begin, _ForwardIterator __end) {
+ __internal::__brick_fill(__begin, __end, _ValueType(), __is_vector);
+ },
+ __is_parallel);
},
[&]() {
- internal::pattern_walk1(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); },
- __is_vector, __is_parallel);
+ __internal::__pattern_walk1(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel);
});
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
using namespace __pstl;
- const auto __is_parallel = internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- const auto __is_vector = internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_parallel = __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
+ const auto __is_vector = __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec);
- return internal::invoke_if_else(
+ return __internal::__invoke_if_else(
std::is_trivial<_ValueType>(),
[&]() {
- return internal::pattern_walk_brick_n(std::forward<_ExecutionPolicy>(__exec), __first, __n,
- [__is_vector](_ForwardIterator __begin, _Size __count) {
- return internal::brick_fill_n(__begin, __count, _ValueType(),
- __is_vector);
- },
- __is_parallel);
+ return __internal::__pattern_walk_brick_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n,
+ [__is_vector](_ForwardIterator __begin, _Size __count) {
+ return __internal::__brick_fill_n(__begin, __count, _ValueType(), __is_vector);
+ },
+ __is_parallel);
},
[&]() {
- return internal::pattern_walk1_n(std::forward<_ExecutionPolicy>(__exec), __first, __n,
- [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); },
- __is_vector, __is_parallel);
+ return __internal::__pattern_walk1_n(
+ std::forward<_ExecutionPolicy>(__exec), __first, __n,
+ [](_ReferenceType __val) { ::new (std::addressof(__val)) _ValueType(); }, __is_vector, __is_parallel);
});
}
diff --git a/include/pstl/internal/glue_numeric_defs.h b/include/pstl/internal/glue_numeric_defs.h
index df4dbf7..55187f1 100644
--- a/include/pstl/internal/glue_numeric_defs.h
+++ b/include/pstl/internal/glue_numeric_defs.h
@@ -17,39 +17,40 @@
// [reduce]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
_BinaryOperation __binary_op);
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init);
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::value_type>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+ typename iterator_traits<_ForwardIterator>::value_type>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Tp __init);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
class _BinaryOperation2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
_BinaryOperation2 __binary_op2);
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
_BinaryOperation __binary_op, _UnaryOperation __unary_op);
// [exclusive.scan]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _Tp __init);
@@ -61,17 +62,17 @@
// [inclusive.scan]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init);
@@ -79,7 +80,7 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation,
class _UnaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op,
_UnaryOperation __unary_op);
@@ -88,26 +89,26 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
class _UnaryOperation, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op,
_Tp __init);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation,
class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op);
// [adjacent.difference]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first, _BinaryOperation op);
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first);
diff --git a/include/pstl/internal/glue_numeric_impl.h b/include/pstl/internal/glue_numeric_impl.h
index 1dcb526..bde0b03 100644
--- a/include/pstl/internal/glue_numeric_impl.h
+++ b/include/pstl/internal/glue_numeric_impl.h
@@ -21,81 +21,82 @@
// [reduce]
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
_BinaryOperation __binary_op)
{
return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op,
- __pstl::internal::no_op());
+ __pstl::__internal::__no_op());
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init)
{
return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, std::plus<_Tp>(),
- __pstl::internal::no_op());
+ __pstl::__internal::__no_op());
}
template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, typename iterator_traits<_ForwardIterator>::value_type>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
+ typename iterator_traits<_ForwardIterator>::value_type>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last)
{
typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
return transform_reduce(std::forward<_ExecutionPolicy>(__exec), __first, __last, _ValueType{},
- std::plus<_ValueType>(), __pstl::internal::no_op());
+ std::plus<_ValueType>(), __pstl::__internal::__no_op());
}
// [transform.reduce]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Tp __init)
{
typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType;
using namespace __pstl;
- return internal::pattern_transform_reduce(
+ return __internal::__pattern_transform_reduce(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, std::plus<_InputType>(),
std::multiplies<_InputType>(),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
class _BinaryOperation2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
_ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
{
using namespace __pstl;
- return internal::pattern_transform_reduce(
+ return __internal::__pattern_transform_reduce(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __init, __binary_op1, __binary_op2,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _Tp>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
_BinaryOperation __binary_op, _UnaryOperation __unary_op)
{
using namespace __pstl;
- return internal::pattern_transform_reduce(
+ return __internal::__pattern_transform_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __unary_op,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator>(__exec));
}
// [exclusive.scan]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _Tp __init)
{
return transform_exclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __init,
- std::plus<_Tp>(), __pstl::internal::no_op());
+ std::plus<_Tp>(), __pstl::__internal::__no_op());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
@@ -104,76 +105,76 @@
_ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op)
{
return transform_exclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __init,
- __binary_op, __pstl::internal::no_op());
+ __binary_op, __pstl::__internal::__no_op());
}
// [inclusive.scan]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result)
{
typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType;
return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result,
- std::plus<_InputType>(), __pstl::internal::no_op());
+ std::plus<_InputType>(), __pstl::__internal::__no_op());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op)
{
return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op,
- __pstl::internal::no_op());
+ __pstl::__internal::__no_op());
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init)
{
return transform_inclusive_scan(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op,
- __pstl::internal::no_op(), __init);
+ __pstl::__internal::__no_op(), __init);
}
// [transform.exclusive.scan]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation,
class _UnaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op,
_UnaryOperation __unary_op)
{
using namespace __pstl;
- return internal::pattern_transform_scan(
+ return __internal::__pattern_transform_scan(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op,
/*inclusive=*/std::false_type(),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
// [transform.inclusive.scan]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
class _UnaryOperation, class _Tp>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op,
_Tp __init)
{
using namespace __pstl;
- return internal::pattern_transform_scan(
+ return __internal::__pattern_transform_scan(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __unary_op, __init, __binary_op,
/*inclusive=*/std::true_type(),
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation,
class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op)
{
@@ -193,7 +194,7 @@
// [adjacent.difference]
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first, _BinaryOperation __op)
{
@@ -202,14 +203,14 @@
return __d_first;
using namespace __pstl;
- return internal::pattern_adjacent_difference(
+ return __internal::__pattern_adjacent_difference(
std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __op,
- internal::is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
- internal::is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
+ __internal::__is_vectorization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec),
+ __internal::__is_parallelization_preferred<_ExecutionPolicy, _ForwardIterator1, _ForwardIterator2>(__exec));
}
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::internal::enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
+__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
_ForwardIterator2 __d_first)
{
diff --git a/include/pstl/internal/memory_impl.h b/include/pstl/internal/memory_impl.h
index 4cedcca..0fadbc6 100644
--- a/include/pstl/internal/memory_impl.h
+++ b/include/pstl/internal/memory_impl.h
@@ -16,7 +16,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
//------------------------------------------------------------------------
@@ -25,8 +25,8 @@
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::false_type) noexcept
+__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::false_type) noexcept
{
typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType2;
for (; __first != __last; ++__first, ++__result)
@@ -38,19 +38,19 @@
template <class _ForwardIterator, class _OutputIterator>
_OutputIterator
-brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- /*vector=*/std::true_type) noexcept
+__brick_uninitialized_move(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ /*vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_OutputIterator>::value_type __ValueType2;
typedef typename std::iterator_traits<_ForwardIterator>::reference _ReferenceType1;
typedef typename std::iterator_traits<_OutputIterator>::reference _ReferenceType2;
- return unseq_backend::simd_walk_2(
+ return __unseq_backend::__simd_walk_2(
__first, __last - __first, __result,
[](_ReferenceType1 __x, _ReferenceType2 __y) { ::new (std::addressof(__y)) __ValueType2(std::move(__x)); });
}
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_memory_impl_H */
diff --git a/include/pstl/internal/numeric_fwd.h b/include/pstl/internal/numeric_fwd.h
index 82c84fd..5666796 100644
--- a/include/pstl/internal/numeric_fwd.h
+++ b/include/pstl/internal/numeric_fwd.h
@@ -15,7 +15,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
//------------------------------------------------------------------------
@@ -23,30 +23,29 @@
//------------------------------------------------------------------------
template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
-_Tp
-brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
- _BinaryOperation2,
- /*__is_vector=*/std::true_type) noexcept;
+_Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+ _BinaryOperation2,
+ /*__is_vector=*/std::true_type) noexcept;
template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
-_Tp
-brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
- _BinaryOperation2,
- /*__is_vector=*/std::false_type) noexcept;
+_Tp __brick_transform_reduce(_ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
+ _BinaryOperation2,
+ /*__is_vector=*/std::false_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2,
- class _IsVector>
-_Tp
-pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp, _BinaryOperation1,
- _BinaryOperation2, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
-
-#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp, class _BinaryOperation1,
+template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
class _BinaryOperation2, class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Tp, _BinaryOperation1,
- _BinaryOperation2, _IsVector __is_vector, /*is_parallel=*/std::true_type);
+__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Tp,
+ _BinaryOperation1, _BinaryOperation2, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
+
+#if __PSTL_USE_PAR_POLICIES
+template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp,
+ class _BinaryOperation1, class _BinaryOperation2, class _IsVector>
+_Tp
+__pattern_transform_reduce(_ExecutionPolicy&&, _RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2,
+ _Tp, _BinaryOperation1, _BinaryOperation2, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -54,25 +53,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
-_Tp
-brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
- /*is_vector=*/std::true_type) noexcept;
+_Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
+ /*is_vector=*/std::true_type) noexcept;
template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-_Tp
-brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
- /*is_vector=*/std::false_type) noexcept;
+_Tp __brick_transform_reduce(_ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation,
+ /*is_vector=*/std::false_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
+ class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation,
+ _UnaryOperation, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation, class _IsVector>
+template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
+ class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation, _IsVector,
- /*is_parallel=*/std::true_type);
+__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation,
+ _UnaryOperation, _IsVector,
+ /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -82,37 +83,36 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
-std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
- _UnaryOperation, _Tp, _BinaryOperation,
- /*Inclusive*/ std::false_type) noexcept;
+std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
+ _UnaryOperation, _Tp, _BinaryOperation,
+ /*Inclusive*/ std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
-std::pair<_OutputIterator, _Tp> brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
- _UnaryOperation, _Tp, _BinaryOperation,
- /*Inclusive*/ std::true_type) noexcept;
+std::pair<_OutputIterator, _Tp> __brick_transform_scan(_ForwardIterator, _ForwardIterator, _OutputIterator,
+ _UnaryOperation, _Tp, _BinaryOperation,
+ /*Inclusive*/ std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
- class _Inclusive, class _IsVector>
-_OutputIterator pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp,
- _BinaryOperation, _Inclusive, _IsVector,
- /*is_parallel=*/std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
+ class _BinaryOperation, class _Inclusive, class _IsVector>
+_OutputIterator
+__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryOperation, _Tp,
+ _BinaryOperation, _Inclusive, _IsVector,
+ /*is_parallel=*/std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type
-pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
- _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation,
- _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
+__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+ _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
#endif
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type
-pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator,
- _OutputIterator, _UnaryOperation, _Tp, _BinaryOperation,
- _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
+__pattern_transform_scan(_ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator,
+ _UnaryOperation, _Tp, _BinaryOperation, _Inclusive, _IsVector, /*is_parallel=*/std::true_type);
#endif
//------------------------------------------------------------------------
@@ -120,23 +120,27 @@
//------------------------------------------------------------------------
template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
- /*is_vector*/ std::false_type) noexcept;
+_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+ /*is_vector*/ std::false_type) noexcept;
template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
- /*is_vector*/ std::true_type) noexcept;
+_OutputIterator __brick_adjacent_difference(_ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+ /*is_vector*/ std::true_type) noexcept;
-template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
-_OutputIterator pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
- _IsVector, /*is_parallel*/ std::false_type) noexcept;
+template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation,
+ class _IsVector>
+_OutputIterator
+__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+ _IsVector, /*is_parallel*/ std::false_type) noexcept;
#if __PSTL_USE_PAR_POLICIES
-template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation, class _IsVector>
-_OutputIterator pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
- _IsVector, /*is_parallel*/ std::true_type);
+template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation,
+ class _IsVector>
+_OutputIterator
+__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation,
+ _IsVector, /*is_parallel*/ std::true_type);
#endif
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_numeric_fwd_H */
diff --git a/include/pstl/internal/numeric_impl.h b/include/pstl/internal/numeric_impl.h
index dd9943b..803e2d8 100644
--- a/include/pstl/internal/numeric_impl.h
+++ b/include/pstl/internal/numeric_impl.h
@@ -24,7 +24,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
//------------------------------------------------------------------------
@@ -33,21 +33,21 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
_Tp
-brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init,
- _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2,
- /*is_vector=*/std::false_type) noexcept
+__brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init,
+ _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2,
+ /*is_vector=*/std::false_type) noexcept
{
return std::inner_product(__first1, __last1, __first2, __init, __binary_op1, __binary_op2);
}
template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
_Tp
-brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init,
- _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2,
- /*is_vector=*/std::true_type) noexcept
+__brick_transform_reduce(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _Tp __init,
+ _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2,
+ /*is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
- return unseq_backend::simd_transform_reduce(
+ return __unseq_backend::__simd_transform_reduce(
__last1 - __first1, __init, __binary_op1,
[=, &__binary_op2](_DifferenceType __i) { return __binary_op2(__first1[__i], __first2[__i]); });
}
@@ -55,24 +55,24 @@
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
class _BinaryOperation2, class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
- _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
- _BinaryOperation2 __binary_op2, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+ _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
+ _BinaryOperation2 __binary_op2, _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector);
+ return __brick_transform_reduce(__first1, __last1, __first2, __init, __binary_op1, __binary_op2, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2, class _Tp,
class _BinaryOperation1, class _BinaryOperation2, class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
- _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
- _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_transform_reduce(_ExecutionPolicy&& __exec, _RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+ _RandomAccessIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
+ _BinaryOperation2 __binary_op2, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
- return internal::except_handler([&]() {
- return par_backend::parallel_transform_reduce(
+ return __except_handler([&]() {
+ return __par_backend::__parallel_transform_reduce(
std::forward<_ExecutionPolicy>(__exec), __first1, __last1,
[__first1, __first2, __binary_op2](_RandomAccessIterator1 __i) mutable {
return __binary_op2(*__i, *(__first2 + (__i - __first1)));
@@ -81,8 +81,8 @@
__binary_op1, // Combine
[__first1, __first2, __binary_op1, __binary_op2,
__is_vector](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp {
- return internal::brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1,
- __binary_op2, __is_vector);
+ return __brick_transform_reduce(__i, __j, __first2 + (__i - __first1), __init, __binary_op1,
+ __binary_op2, __is_vector);
});
});
}
@@ -94,8 +94,8 @@
template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
_Tp
-brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op,
- _UnaryOperation __unary_op, /*is_vector=*/std::false_type) noexcept
+__brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op,
+ _UnaryOperation __unary_op, /*is_vector=*/std::false_type) noexcept
{
for (; __first != __last; ++__first)
{
@@ -106,11 +106,11 @@
template <class _ForwardIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
_Tp
-brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op,
- _UnaryOperation __unary_op, /*is_vector=*/std::true_type) noexcept
+__brick_transform_reduce(_ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __binary_op,
+ _UnaryOperation __unary_op, /*is_vector=*/std::true_type) noexcept
{
typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
- return unseq_backend::simd_transform_reduce(
+ return __unseq_backend::__simd_transform_reduce(
__last - __first, __init, __binary_op,
[=, &__unary_op](_DifferenceType __i) { return __unary_op(__first[__i]); });
}
@@ -118,27 +118,27 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
- _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
- /*is_parallel=*/std::false_type) noexcept
+__pattern_transform_reduce(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
+ _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
+ /*is_parallel=*/std::false_type) noexcept
{
- return brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector);
+ return __brick_transform_reduce(__first, __last, __init, __binary_op, __unary_op, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation,
class _IsVector>
_Tp
-pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
- _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
+ _BinaryOperation __binary_op, _UnaryOperation __unary_op, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
- return except_handler([&]() {
- return par_backend::parallel_transform_reduce(
+ return __except_handler([&]() {
+ return __par_backend::__parallel_transform_reduce(
std::forward<_ExecutionPolicy>(__exec), __first, __last,
[__unary_op](_ForwardIterator __i) mutable { return __unary_op(*__i); }, __init, __binary_op,
[__unary_op, __binary_op, __is_vector](_ForwardIterator __i, _ForwardIterator __j, _Tp __init) {
- return brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector);
+ return __brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, __is_vector);
});
});
}
@@ -153,9 +153,9 @@
// Exclusive form
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
std::pair<_OutputIterator, _Tp>
-brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
- /*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept
+__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
+ /*Inclusive*/ std::false_type, /*is_vector=*/std::false_type) noexcept
{
for (; __first != __last; ++__first, ++__result)
{
@@ -169,9 +169,9 @@
// Inclusive form
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
std::pair<_OutputIterator, _Tp>
-brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
- /*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept
+__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
+ /*Inclusive*/ std::true_type, /*is_vector=*/std::false_type) noexcept
{
for (; __first != __last; ++__first, ++__result)
{
@@ -192,39 +192,39 @@
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
class _Inclusive>
typename std::enable_if<!is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
- /*is_vector=*/std::true_type) noexcept
+__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
+ /*is_vector=*/std::true_type) noexcept
{
#if (__PSTL_UDS_PRESENT)
- return unseq_backend::simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op, _Inclusive());
+ return __unseq_backend::__simd_scan(__first, __last - __first, __result, __unary_op, __init, __binary_op,
+ _Inclusive());
#else
// We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive() value
- return brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
- /*is_vector=*/std::false_type());
+ return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
+ /*is_vector=*/std::false_type());
#endif
}
template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation,
class _Inclusive>
typename std::enable_if<is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
- /*is_vector=*/std::true_type) noexcept
+__brick_transform_scan(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
+ _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
+ /*is_vector=*/std::true_type) noexcept
{
- return brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
- /*is_vector=*/std::false_type());
+ return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
+ /*is_vector=*/std::false_type());
}
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector>
_OutputIterator
-pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result,
- _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op, _Inclusive,
- _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
+__pattern_transform_scan(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
+ _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
+ _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::false_type) noexcept
{
- return internal::brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(),
- __is_vector)
+ return __brick_transform_scan(__first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), __is_vector)
.first;
}
@@ -232,26 +232,26 @@
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type
-pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
- _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
+ _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
- return internal::except_handler([&]() {
- par_backend::parallel_transform_scan(
+ return __except_handler([&]() {
+ __par_backend::__parallel_transform_scan(
std::forward<_ExecutionPolicy>(__exec), __last - __first,
[__first, __unary_op](_DifferenceType __i) mutable { return __unary_op(__first[__i]); }, __init,
__binary_op,
[__first, __unary_op, __binary_op](_DifferenceType __i, _DifferenceType __j, _Tp __init) {
- // Execute serial brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a commutative operation for the guarantee of correct scan.
- return internal::brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op,
- /*__is_vector*/ std::false_type());
+ // Execute serial __brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a commutative operation for the guarantee of correct scan.
+ return __brick_transform_reduce(__first + __i, __first + __j, __init, __binary_op, __unary_op,
+ /*__is_vector*/ std::false_type());
},
[__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __j,
_Tp __init) {
- return internal::brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, __init,
- __binary_op, _Inclusive(), __is_vector)
+ return __brick_transform_scan(__first + __i, __first + __j, __result + __i, __unary_op, __init,
+ __binary_op, _Inclusive(), __is_vector)
.second;
});
return __result + (__last - __first);
@@ -263,9 +263,9 @@
template <class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation, class _Inclusive, class _IsVector>
typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type
-pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
- _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
- _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
+__pattern_transform_scan(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last,
+ _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init, _BinaryOperation __binary_op,
+ _Inclusive, _IsVector __is_vector, /*is_parallel=*/std::true_type)
{
typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
_DifferenceType __n = __last - __first;
@@ -274,12 +274,12 @@
{
return __result;
}
- return except_handler([&]() {
- par_backend::parallel_strict_scan(
+ return __except_handler([&]() {
+ __par_backend::parallel_strict_scan(
std::forward<_ExecutionPolicy>(__exec), __n, __init,
[__first, __unary_op, __binary_op, __result, __is_vector](_DifferenceType __i, _DifferenceType __len) {
- return brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, __unary_op, _Tp{},
- __binary_op, _Inclusive(), __is_vector)
+ return __brick_transform_scan(__first + __i, __first + (__i + __len), __result + __i, __unary_op, _Tp{},
+ __binary_op, _Inclusive(), __is_vector)
.second;
},
__binary_op,
@@ -303,16 +303,16 @@
template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
_OutputIterator
-brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first,
- _BinaryOperation __op, /*is_vector*/ std::false_type) noexcept
+__brick_adjacent_difference(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __d_first,
+ _BinaryOperation __op, /*is_vector*/ std::false_type) noexcept
{
return std::adjacent_difference(__first, __last, __d_first, __op);
}
template <class _ForwardIterator1, class _ForwardIterator2, class BinaryOperation>
_ForwardIterator2
-brick_adjacent_difference(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first,
- BinaryOperation __op, /*is_vector=*/std::true_type) noexcept
+__brick_adjacent_difference(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first,
+ BinaryOperation __op, /*is_vector=*/std::true_type) noexcept
{
assert(__first != __last);
@@ -321,7 +321,7 @@
auto __n = __last - __first;
*__d_first = *__first;
- return unseq_backend::simd_walk_3(
+ return __unseq_backend::__simd_walk_3(
__first + 1, __n - 1, __first, __d_first + 1,
[&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__x, __y); });
}
@@ -329,40 +329,40 @@
template <class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation,
class _IsVector>
_OutputIterator
-pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
- _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector,
- /*is_parallel*/ std::false_type) noexcept
+__pattern_adjacent_difference(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last,
+ _OutputIterator __d_first, _BinaryOperation __op, _IsVector __is_vector,
+ /*is_parallel*/ std::false_type) noexcept
{
- return internal::brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector);
+ return __brick_adjacent_difference(__first, __last, __d_first, __op, __is_vector);
}
#if __PSTL_USE_PAR_POLICIES
template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
class _IsVector>
_ForwardIterator2
-pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
- _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector,
- /*is_parallel=*/std::true_type)
+__pattern_adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
+ _ForwardIterator2 __d_first, _BinaryOperation __op, _IsVector __is_vector,
+ /*is_parallel=*/std::true_type)
{
assert(__first != __last);
typedef typename std::iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
typedef typename std::iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
*__d_first = *__first;
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last - 1,
- [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) {
- _ForwardIterator2 __d_b = __d_first + (__b - __first);
- brick_walk3(__b, __e, __b + 1, __d_b + 1,
- [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) {
- __z = __op(__y, __x);
- },
- __is_vector);
- });
+ __par_backend::__parallel_for(
+ std::forward<_ExecutionPolicy>(__exec), __first, __last - 1,
+ [&__op, __is_vector, __d_first, __first](_ForwardIterator1 __b, _ForwardIterator1 __e) {
+ _ForwardIterator2 __d_b = __d_first + (__b - __first);
+ __brick_walk3(
+ __b, __e, __b + 1, __d_b + 1,
+ [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__y, __x); },
+ __is_vector);
+ });
return __d_first + (__last - __first);
}
#endif
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_numeric_impl_H */
diff --git a/include/pstl/internal/parallel_backend_tbb.h b/include/pstl/internal/parallel_backend_tbb.h
index cf6319a..2a22158 100644
--- a/include/pstl/internal/parallel_backend_tbb.h
+++ b/include/pstl/internal/parallel_backend_tbb.h
@@ -31,7 +31,7 @@
namespace __pstl
{
-namespace par_backend
+namespace __par_backend
{
//! Raw memory buffer with automatic freeing and no exceptions.
@@ -40,18 +40,18 @@
would make the span be at least O(N). */
// tbb::allocator can improve performance in some cases.
template <typename _Tp>
-class buffer
+class __buffer
{
tbb::tbb_allocator<_Tp> _M_allocator;
_Tp* _M_ptr;
const std::size_t _M_buf_size;
- buffer(const buffer&) = delete;
+ __buffer(const __buffer&) = delete;
void
- operator=(const buffer&) = delete;
+ operator=(const __buffer&) = delete;
public:
//! Try to obtain buffer of given size to store objects of _Tp type
- buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {}
+ __buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {}
//! True if buffer was successfully obtained, zero otherwise.
operator bool() const { return _M_ptr != NULL; }
//! Return pointer to buffer, or NULL if buffer could not be obtained.
@@ -61,12 +61,12 @@
return _M_ptr;
}
//! Destroy buffer
- ~buffer() { _M_allocator.deallocate(_M_ptr, _M_buf_size); }
+ ~__buffer() { _M_allocator.deallocate(_M_ptr, _M_buf_size); }
};
// Wrapper for tbb::task
inline void
-cancel_execution()
+__cancel_execution()
{
tbb::task::self().group()->cancel_group_execution();
}
@@ -76,11 +76,11 @@
//------------------------------------------------------------------------
template <class _Index, class _RealBody>
-class parallel_for_body
+class __parallel_for_body
{
public:
- parallel_for_body(const _RealBody& __body) : _M_body(__body) {}
- parallel_for_body(const parallel_for_body& __body) : _M_body(__body._M_body) {}
+ __parallel_for_body(const _RealBody& __body) : _M_body(__body) {}
+ __parallel_for_body(const __parallel_for_body& __body) : _M_body(__body._M_body) {}
void
operator()(const tbb::blocked_range<_Index>& __range) const
{
@@ -95,18 +95,19 @@
// wrapper over tbb::parallel_for
template <class _ExecutionPolicy, class _Index, class _Fp>
void
-parallel_for(_ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
+__parallel_for(_ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
{
- tbb::this_task_arena::isolate(
- [=]() { tbb::parallel_for(tbb::blocked_range<_Index>(__first, __last), parallel_for_body<_Index, _Fp>(__f)); });
+ tbb::this_task_arena::isolate([=]() {
+ tbb::parallel_for(tbb::blocked_range<_Index>(__first, __last), __parallel_for_body<_Index, _Fp>(__f));
+ });
}
//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
// wrapper over tbb::parallel_reduce
template <class _ExecutionPolicy, class _Value, class _Index, typename _RealBody, typename _Reduction>
_Value
-parallel_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, const _Value& __identity,
- const _RealBody& __real_body, const _Reduction& __reduction)
+__parallel_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, const _Value& __identity,
+ const _RealBody& __real_body, const _Reduction& __reduction)
{
return tbb::this_task_arena::isolate([__first, __last, &__identity, &__real_body, &__reduction]() -> _Value {
return tbb::parallel_reduce(
@@ -128,7 +129,7 @@
//------------------------------------------------------------------------
template <class _Index, class _Up, class _Tp, class _Cp, class _Rp>
-struct par_trans_red_body
+struct __par_trans_red_body
{
alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true
_Rp _M_brick_reduce; // Most likely to have non-empty layout
@@ -141,18 +142,18 @@
__TBB_ASSERT(_M_has_sum, "sum expected");
return *(_Tp*)_M_sum_storage;
}
- par_trans_red_body(_Up __u, _Tp __init, _Cp __c, _Rp __r)
+ __par_trans_red_body(_Up __u, _Tp __init, _Cp __c, _Rp __r)
: _M_brick_reduce(__r), _M_u(__u), _M_combine(__c), _M_has_sum(true)
{
new (_M_sum_storage) _Tp(__init);
}
- par_trans_red_body(par_trans_red_body& __left, tbb::split)
+ __par_trans_red_body(__par_trans_red_body& __left, tbb::split)
: _M_brick_reduce(__left._M_brick_reduce), _M_u(__left._M_u), _M_combine(__left._M_combine), _M_has_sum(false)
{
}
- ~par_trans_red_body()
+ ~__par_trans_red_body()
{
// 17.6.5.12 tells us to not worry about catching exceptions from destructors.
if (_M_has_sum)
@@ -160,7 +161,7 @@
}
void
- join(par_trans_red_body& __rhs)
+ join(__par_trans_red_body& __rhs)
{
sum() = _M_combine(sum(), __rhs.sum());
}
@@ -186,10 +187,10 @@
template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp>
_Tp
-parallel_transform_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, _Up __u, _Tp __init, _Cp __combine,
- _Rp __brick_reduce)
+__parallel_transform_reduce(_ExecutionPolicy&&, _Index __first, _Index __last, _Up __u, _Tp __init, _Cp __combine,
+ _Rp __brick_reduce)
{
- par_trans_red_body<_Index, _Up, _Tp, _Cp, _Rp> __body(__u, __init, __combine, __brick_reduce);
+ __par_trans_red_body<_Index, _Up, _Tp, _Cp, _Rp> __body(__u, __init, __combine, __brick_reduce);
// The grain size of 3 is used in order to provide mininum 2 elements for each body
tbb::this_task_arena::isolate(
[__first, __last, &__body]() { tbb::parallel_reduce(tbb::blocked_range<_Index>(__first, __last, 3), __body); });
@@ -201,7 +202,7 @@
//------------------------------------------------------------------------
template <class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
-class trans_scan_body
+class __trans_scan_body
{
alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true
_Rp _M_brick_reduce; // Most likely to have non-empty layout
@@ -210,19 +211,19 @@
_Sp _M_scan;
bool _M_has_sum; // Put last to minimize size of class
public:
- trans_scan_body(_Up __u, _Tp __init, _Cp __combine, _Rp __reduce, _Sp __scan)
+ __trans_scan_body(_Up __u, _Tp __init, _Cp __combine, _Rp __reduce, _Sp __scan)
: _M_brick_reduce(__reduce), _M_u(__u), _M_combine(__combine), _M_scan(__scan), _M_has_sum(true)
{
new (_M_sum_storage) _Tp(__init);
}
- trans_scan_body(trans_scan_body& __b, tbb::split)
+ __trans_scan_body(__trans_scan_body& __b, tbb::split)
: _M_brick_reduce(__b._M_brick_reduce), _M_u(__b._M_u), _M_combine(__b._M_combine), _M_scan(__b._M_scan),
_M_has_sum(false)
{
}
- ~trans_scan_body()
+ ~__trans_scan_body()
{
// 17.6.5.12 tells us to not worry about catching exceptions from destructors.
if (_M_has_sum)
@@ -259,7 +260,7 @@
}
void
- reverse_join(trans_scan_body& __a)
+ reverse_join(__trans_scan_body& __a)
{
if (_M_has_sum)
{
@@ -273,7 +274,7 @@
}
void
- assign(trans_scan_body& __b)
+ assign(__trans_scan_body& __b)
{
sum() = __b.sum();
}
@@ -281,7 +282,7 @@
template <typename _Index>
_Index
-split(_Index __m)
+__split(_Index __m)
{
_Index __k = 1;
while (2 * __k < __m)
@@ -295,18 +296,16 @@
template <typename _Index, typename _Tp, typename _Rp, typename _Cp>
void
-upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine)
+__upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine)
{
if (__m == 1)
__r[0] = __reduce(__i * __tilesize, __lastsize);
else
{
- _Index __k = split(__m);
- tbb::parallel_invoke([=] { par_backend::upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); },
- [=] {
- par_backend::upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce,
- __combine);
- });
+ _Index __k = __split(__m);
+ tbb::parallel_invoke(
+ [=] { __upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); },
+ [=] { __upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce, __combine); });
if (__m == 2 * __k)
__r[__m - 1] = __combine(__r[__k - 1], __r[__m - 1]);
}
@@ -314,22 +313,21 @@
template <typename _Index, typename _Tp, typename _Cp, typename _Sp>
void
-downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine,
- _Sp __scan)
+__downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine,
+ _Sp __scan)
{
if (__m == 1)
__scan(__i * __tilesize, __lastsize, __initial);
else
{
- const _Index __k = par_backend::split(__m);
- tbb::parallel_invoke(
- [=] { par_backend::downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); },
- // Assumes that __combine never throws.
- //TODO: Consider adding a requirement for user functors to be constant.
- [=, &__combine] {
- par_backend::downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize,
- __combine(__initial, __r[__k - 1]), __combine, __scan);
- });
+ const _Index __k = __split(__m);
+ tbb::parallel_invoke([=] { __downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); },
+ // Assumes that __combine never throws.
+ //TODO: Consider adding a requirement for user functors to be constant.
+ [=, &__combine] {
+ __downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize,
+ __combine(__initial, __r[__k - 1]), __combine, __scan);
+ });
}
}
@@ -345,7 +343,7 @@
// Thus callers can rely upon side effects in reduce.
// combine must not throw an exception.
// apex is called exactly once, after all calls to reduce and before all calls to scan.
-// For example, it's useful for allocating a buffer used by scan but whose size is the sum of all reduction values.
+// For example, it's useful for allocating a __buffer used by scan but whose size is the sum of all reduction values.
// T must have a trivial constructor and destructor.
template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
void
@@ -358,10 +356,10 @@
const _Index __slack = 4;
_Index __tilesize = (__n - 1) / (__slack * __p) + 1;
_Index __m = (__n - 1) / __tilesize;
- buffer<_Tp> __buf(__m + 1);
+ __buffer<_Tp> __buf(__m + 1);
_Tp* __r = __buf.get();
- par_backend::upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce,
- __combine);
+ __upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce, __combine);
+
// When __apex is a no-op and __combine has no side effects, a good optimizer
// should be able to eliminate all code between here and __apex.
// Alternatively, provide a default value for __apex that can be
@@ -371,8 +369,8 @@
while ((__k &= __k - 1))
__t = __combine(__r[__k - 1], __t);
__apex(__combine(__initial, __t));
- par_backend::downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial,
- __combine, __scan);
+ __downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial, __combine,
+ __scan);
return;
}
// Fewer than 2 elements in sequence, or out of memory. Handle has single block.
@@ -387,10 +385,10 @@
template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
_Tp
-parallel_transform_scan(_ExecutionPolicy&&, _Index __n, _Up __u, _Tp __init, _Cp __combine, _Rp __brick_reduce,
- _Sp __scan)
+__parallel_transform_scan(_ExecutionPolicy&&, _Index __n, _Up __u, _Tp __init, _Cp __combine, _Rp __brick_reduce,
+ _Sp __scan)
{
- trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan);
+ __trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan);
auto __range = tbb::blocked_range<_Index>(0, __n);
tbb::this_task_arena::isolate([__range, &__body]() { tbb::parallel_scan(__range, __body); });
return __body.sum();
@@ -408,7 +406,7 @@
template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
typename _Compare, typename _Cleanup, typename _LeafMerge>
-class merge_task : public tbb::task
+class __merge_task : public tbb::task
{
/*override*/ tbb::task*
execute();
@@ -420,9 +418,9 @@
_LeafMerge _M_leaf_merge;
public:
- merge_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
- _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _Cleanup __cleanup,
- _LeafMerge __leaf_merge)
+ __merge_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
+ _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _Cleanup __cleanup,
+ _LeafMerge __leaf_merge)
: _M_xs(__xs), _M_xe(__xe), _M_ys(__ys), _M_ye(__ye), _M_zs(__zs), _M_comp(__comp), _M_cleanup(__cleanup),
_M_leaf_merge(__leaf_merge)
{
@@ -434,8 +432,8 @@
template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
typename __M_Compare, typename _Cleanup, typename _LeafMerge>
tbb::task*
-merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup,
- _LeafMerge>::execute()
+__merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _Cleanup,
+ _LeafMerge>::execute()
{
typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
@@ -467,7 +465,7 @@
}
const _RandomAccessIterator3 __zm = _M_zs + ((__xm - _M_xs) + (__ym - _M_ys));
tbb::task* __right = new (tbb::task::allocate_additional_child_of(*parent()))
- merge_task(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _M_cleanup, _M_leaf_merge);
+ __merge_task(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _M_cleanup, _M_leaf_merge);
tbb::task::spawn(*__right);
tbb::task::recycle_as_continuation();
_M_xe = __xm;
@@ -477,7 +475,7 @@
}
template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
-class stable_sort_task : public tbb::task
+class __stable_sort_task : public tbb::task
{
public:
typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
@@ -495,8 +493,8 @@
_SizeType _M_nsort;
public:
- stable_sort_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __zs,
- int32_t __inplace, _Compare __comp, _LeafSort __leaf_sort, _SizeType __n)
+ __stable_sort_task(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __zs,
+ int32_t __inplace, _Compare __comp, _LeafSort __leaf_sort, _SizeType __n)
: _M_xs(__xs), _M_xe(__xe), _M_zs(__zs), _M_comp(__comp), _M_leaf_sort(__leaf_sort), _M_inplace(__inplace),
_M_nsort(__n)
{
@@ -504,7 +502,7 @@
};
//! Binary operator that does nothing
-struct binary_no_op
+struct __binary_no_op
{
template <typename _T>
void operator()(_T, _T)
@@ -516,7 +514,7 @@
template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
tbb::task*
-stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute()
+__stable_sort_task<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::execute()
{
const _SizeType __n = _M_xe - _M_xs;
const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n;
@@ -525,7 +523,7 @@
{
_M_leaf_sort(_M_xs, _M_xe, _M_comp);
if (_M_inplace != 2)
- init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0);
+ __init_buf(_M_xs, _M_xe, _M_zs, _M_inplace == 0);
return NULL;
}
else
@@ -539,18 +537,19 @@
_RandomAccessIterator1 __first2) { return std::move(__first1, __last1, __first2); };
if (_M_inplace == 2)
__m = new (allocate_continuation())
- merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
- serial_destroy, serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
- _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, serial_destroy(),
- serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
- __move_sequences));
+ __merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
+ __serial_destroy,
+ __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
+ _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, __serial_destroy(),
+ __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
+ __move_sequences));
else if (_M_inplace)
__m = new (allocate_continuation())
- merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
- binary_no_op, serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
- _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, binary_no_op(),
- serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
- __move_sequences));
+ __merge_task<_RandomAccessIterator2, _RandomAccessIterator2, _RandomAccessIterator1, _Compare,
+ __binary_no_op, __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
+ _M_zs, __zm, __zm, __ze, _M_xs, _M_comp, __binary_no_op(),
+ __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
+ __move_sequences));
else
{
auto __move_values = [](_RandomAccessIterator1 __x, _RandomAccessIterator2 __z) { *__z = std::move(*__x); };
@@ -559,15 +558,15 @@
return std::move(__first1, __last1, __first2);
};
__m = new (allocate_continuation())
- merge_task<_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Compare,
- binary_no_op, serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
- _M_xs, __xm, __xm, _M_xe, _M_zs, _M_comp, binary_no_op(),
- serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
- __move_sequences));
+ __merge_task<_RandomAccessIterator1, _RandomAccessIterator1, _RandomAccessIterator2, _Compare,
+ __binary_no_op, __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>>(
+ _M_xs, __xm, __xm, _M_xe, _M_zs, _M_comp, __binary_no_op(),
+ __serial_move_merge<decltype(__move_values), decltype(__move_sequences)>(__nmerge, __move_values,
+ __move_sequences));
}
__m->set_ref_count(2);
task* __right = new (__m->allocate_child())
- stable_sort_task(__xm, _M_xe, __zm, !_M_inplace, _M_comp, _M_leaf_sort, __nmerge);
+ __stable_sort_task(__xm, _M_xe, __zm, !_M_inplace, _M_comp, _M_leaf_sort, __nmerge);
spawn(*__right);
recycle_as_child_of(*__m);
_M_xe = __xm;
@@ -578,8 +577,8 @@
template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
void
-parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
- _LeafSort __leaf_sort, std::size_t __nsort = 0)
+__parallel_stable_sort(_ExecutionPolicy&&, _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
+ _LeafSort __leaf_sort, std::size_t __nsort = 0)
{
tbb::this_task_arena::isolate([=, &__nsort]() {
//sorting based on task tree and parallel merge
@@ -593,10 +592,10 @@
if (__n > __sort_cut_off)
{
assert(__nsort > 0 && __nsort <= __n);
- buffer<_ValueType> __buf(__n);
+ __buffer<_ValueType> __buf(__n);
using tbb::task;
task::spawn_root_and_wait(*new (task::allocate_root())
- stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>(
+ __stable_sort_task<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>(
__xs, __xe, (_ValueType*)__buf.get(), 2, __comp, __leaf_sort, __nsort));
return;
}
@@ -612,9 +611,9 @@
template <class _ExecutionPolicy, typename _RandomAccessIterator1, typename _RandomAccessIterator2,
typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
void
-parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe,
- _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp,
- _LeafMerge __leaf_merge)
+__parallel_merge(_ExecutionPolicy&&, _RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe,
+ _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp,
+ _LeafMerge __leaf_merge)
{
typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
@@ -629,11 +628,11 @@
else
{
tbb::this_task_arena::isolate([=]() {
- typedef merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Compare,
- par_backend::binary_no_op, _LeafMerge>
+ typedef __merge_task<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, _Compare,
+ __binary_no_op, _LeafMerge>
_TaskType;
tbb::task::spawn_root_and_wait(*new (tbb::task::allocate_root()) _TaskType(
- __xs, __xe, __ys, __ye, __zs, __comp, par_backend::binary_no_op(), __leaf_merge));
+ __xs, __xe, __ys, __ye, __zs, __comp, __binary_no_op(), __leaf_merge));
});
}
}
@@ -643,13 +642,13 @@
//------------------------------------------------------------------------
template <class _ExecutionPolicy, typename _F1, typename _F2>
void
-parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
+__parallel_invoke(_ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
{
//TODO: a version of tbb::this_task_arena::isolate with variadic arguments pack should be added in the future
tbb::this_task_arena::isolate([&]() { tbb::parallel_invoke(std::forward<_F1>(__f1), std::forward<_F2>(__f2)); });
}
-} // namespace par_backend
+} // namespace __par_backend
} // namespace __pstl
#endif /* __PSTL_parallel_backend_tbb_H */
diff --git a/include/pstl/internal/parallel_backend_utils.h b/include/pstl/internal/parallel_backend_utils.h
index 1d4f14b..6313890 100644
--- a/include/pstl/internal/parallel_backend_utils.h
+++ b/include/pstl/internal/parallel_backend_utils.h
@@ -17,11 +17,11 @@
namespace __pstl
{
-namespace par_backend
+namespace __par_backend
{
//! Destroy sequence [xs,xe)
-struct serial_destroy
+struct __serial_destroy
{
template <typename _RandomAccessIterator>
void
@@ -38,13 +38,13 @@
//! Merge sequences [__xs,__xe) and [__ys,__ye) to output sequence [__zs,(__xe-__xs)+(__ye-__ys)), using std::move
template <class _MoveValues, class _MoveSequences>
-struct serial_move_merge
+struct __serial_move_merge
{
const std::size_t _M_nmerge;
_MoveValues _M_move_values;
_MoveSequences _M_move_sequences;
- explicit serial_move_merge(std::size_t __nmerge, _MoveValues __move_values, _MoveSequences __move_sequences)
+ explicit __serial_move_merge(std::size_t __nmerge, _MoveValues __move_values, _MoveSequences __move_sequences)
: _M_nmerge(__nmerge), _M_move_values(__move_values), _M_move_sequences(__move_sequences)
{
}
@@ -108,7 +108,7 @@
template <typename _RandomAccessIterator1, typename _OutputIterator>
void
-init_buf(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _OutputIterator __zs, bool __bMove)
+__init_buf(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _OutputIterator __zs, bool __bMove)
{
const _OutputIterator __ze = __zs + (__xe - __xs);
typedef typename std::iterator_traits<_OutputIterator>::value_type _ValueType;
@@ -126,8 +126,9 @@
}
}
+// TODO is this actually used anywhere?
template <typename _Buf>
-class stack
+class __stack
{
typedef typename std::iterator_traits<decltype(_Buf(0).get())>::value_type _ValueType;
typedef typename std::iterator_traits<_ValueType*>::difference_type _DifferenceType;
@@ -136,14 +137,14 @@
_ValueType* _M_ptr;
_DifferenceType _M_maxsize;
- stack(const stack&) = delete;
+ __stack(const __stack&) = delete;
void
- operator=(const stack&) = delete;
+ operator=(const __stack&) = delete;
public:
- stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); }
+ __stack(_DifferenceType __max_size) : _M_buf(__max_size), _M_maxsize(__max_size) { _M_ptr = _M_buf.get(); }
- ~stack()
+ ~__stack()
{
assert(size() <= _M_maxsize);
while (!empty())
@@ -189,7 +190,7 @@
}
};
-} // namespace par_backend
+} // namespace __par_backend
} // namespace __pstl
#endif /* __PSTL_parallel_backend_utils_H */
diff --git a/include/pstl/internal/parallel_impl.h b/include/pstl/internal/parallel_impl.h
index f29d9cf..2498003 100644
--- a/include/pstl/internal/parallel_impl.h
+++ b/include/pstl/internal/parallel_impl.h
@@ -16,7 +16,7 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
//------------------------------------------------------------------------
@@ -26,32 +26,32 @@
Each f[i,j) must return a value in [i,j). */
template <class _ExecutionPolicy, class _Index, class _Brick, class _Compare>
_Index
-parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first)
+__parallel_find(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first)
{
typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
const _DifferenceType __n = __last - __first;
_DifferenceType __initial_dist = __b_first ? __n : -1;
std::atomic<_DifferenceType> __extremum(__initial_dist);
// TODO: find out what is better here: parallel_for or parallel_reduce
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__comp, __f, __first, &__extremum](_Index __i, _Index __j) {
- // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of
- // why using a shared variable scales fairly well in this situation.
- if (__comp(__i - __first, __extremum))
- {
- _Index __res = __f(__i, __j);
- // If not '__last' returned then we found what we want so put this to extremum
- if (__res != __j)
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__comp, __f, __first, &__extremum](_Index __i, _Index __j) {
+ // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of
+ // why using a shared variable scales fairly well in this situation.
+ if (__comp(__i - __first, __extremum))
{
- const _DifferenceType __k = __res - __first;
- for (_DifferenceType __old = __extremum; __comp(__k, __old);
- __old = __extremum)
+ _Index __res = __f(__i, __j);
+ // If not '__last' returned then we found what we want so put this to extremum
+ if (__res != __j)
{
- __extremum.compare_exchange_weak(__old, __k);
+ const _DifferenceType __k = __res - __first;
+ for (_DifferenceType __old = __extremum; __comp(__k, __old);
+ __old = __extremum)
+ {
+ __extremum.compare_exchange_weak(__old, __k);
+ }
}
}
- }
- });
+ });
return __extremum != __initial_dist ? __first + __extremum : __last;
}
@@ -61,21 +61,21 @@
//! Return true if brick f[i,j) returns true for some subrange [i,j) of [first,last)
template <class _ExecutionPolicy, class _Index, class _Brick>
bool
-parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f)
+__parallel_or(_ExecutionPolicy&& __exec, _Index __first, _Index __last, _Brick __f)
{
std::atomic<bool> __found(false);
- par_backend::parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
- [__f, &__found](_Index __i, _Index __j) {
- if (!__found.load(std::memory_order_relaxed) && __f(__i, __j))
- {
- __found.store(true, std::memory_order_relaxed);
- par_backend::cancel_execution();
- }
- });
+ __par_backend::__parallel_for(std::forward<_ExecutionPolicy>(__exec), __first, __last,
+ [__f, &__found](_Index __i, _Index __j) {
+ if (!__found.load(std::memory_order_relaxed) && __f(__i, __j))
+ {
+ __found.store(true, std::memory_order_relaxed);
+ __par_backend::__cancel_execution();
+ }
+ });
return __found;
}
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_parallel_impl_H */
diff --git a/include/pstl/internal/unseq_backend_simd.h b/include/pstl/internal/unseq_backend_simd.h
index 6d303b8..fed60a0 100644
--- a/include/pstl/internal/unseq_backend_simd.h
+++ b/include/pstl/internal/unseq_backend_simd.h
@@ -18,7 +18,7 @@
// to support parallel STL.
namespace __pstl
{
-namespace unseq_backend
+namespace __unseq_backend
{
// Expect vector width up to 64 (or 512 bit)
@@ -26,7 +26,7 @@
template <class _Iterator, class _DifferenceType, class _Function>
_Iterator
-simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
+__simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
{
__PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i)
@@ -37,7 +37,7 @@
template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
_Iterator2
-simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
+__simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
{
__PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i)
@@ -47,7 +47,8 @@
template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
_Iterator3
-simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, _Function __f) noexcept
+__simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3,
+ _Function __f) noexcept
{
__PSTL_PRAGMA_SIMD
for (_DifferenceType __i = 0; __i < __n; ++__i)
@@ -55,10 +56,10 @@
return __first3 + __n;
}
-// TODO: check whether simd_first() can be used here
+// TODO: check whether __simd_first() can be used here
template <class _Index, class _DifferenceType, class _Pred>
bool
-simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
+__simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
{
#if __PSTL_EARLYEXIT_PRESENT
_DifferenceType __i;
@@ -98,7 +99,7 @@
template <class _Index, class _DifferenceType, class _Compare>
_Index
-simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
+__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept
{
#if __PSTL_EARLYEXIT_PRESENT
_DifferenceType __i = __begin;
@@ -158,7 +159,7 @@
template <class _Index1, class _DifferenceType, class _Index2, class _Pred>
std::pair<_Index1, _Index2>
-simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
+__simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
{
#if __PSTL_EARLYEXIT_PRESENT
_DifferenceType __i = 0;
@@ -212,7 +213,7 @@
template <class _Index, class _DifferenceType, class _Pred>
_DifferenceType
-simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
+__simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
{
_DifferenceType __count = 0;
__PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
@@ -225,8 +226,8 @@
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _BinaryPredicate>
_OutputIterator
-simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
- _BinaryPredicate __pred) noexcept
+__simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
+ _BinaryPredicate __pred) noexcept
{
if (__n == 0)
return __result;
@@ -249,7 +250,7 @@
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
_OutputIterator
-simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
+__simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
{
__PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
__PSTL_PRAGMA_SIMD
@@ -260,7 +261,7 @@
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _UnaryPredicate>
_OutputIterator
-simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
+__simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
{
_DifferenceType __cnt = 0;
@@ -279,7 +280,7 @@
template <class _InputIterator, class _DifferenceType, class _BinaryPredicate>
_DifferenceType
-simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
+__simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
{
_DifferenceType __count = 0;
@@ -294,7 +295,7 @@
template <class _InputIterator, class _DifferenceType, class _UnaryPredicate>
_DifferenceType
-simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
+__simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
{
_DifferenceType __count = 0;
@@ -309,8 +310,8 @@
template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
void
-simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
- _Assigner __assigner) noexcept
+__simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
+ _Assigner __assigner) noexcept
{
_DifferenceType __cnt = 0;
__PSTL_PRAGMA_SIMD
@@ -329,8 +330,8 @@
template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2>
void
-simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
- _OutputIterator2 __out_false, bool* __mask) noexcept
+__simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
+ _OutputIterator2 __out_false, bool* __mask) noexcept
{
_DifferenceType __cnt_true = 0, __cnt_false = 0;
__PSTL_PRAGMA_SIMD
@@ -352,7 +353,7 @@
template <class _Index, class _DifferenceType, class _Tp>
_Index
-simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept
+__simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept
{
__PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
__PSTL_PRAGMA_SIMD
@@ -363,7 +364,7 @@
template <class _Index, class _DifferenceType, class _Generator>
_Index
-simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
+__simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
{
__PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
__PSTL_PRAGMA_SIMD
@@ -374,7 +375,7 @@
template <class _Index, class _BinaryPredicate>
_Index
-simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
+__simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
{
if (__last - __first < 2)
return __last;
@@ -443,7 +444,7 @@
template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
-simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
+__simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
{
__PSTL_PRAGMA_SIMD_REDUCTION(+ : __init)
for (_DifferenceType __i = 0; __i < __n; ++__i)
@@ -453,7 +454,7 @@
template <typename _Size, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
-simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
+__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
{
const _Size __block_size = __lane_size / sizeof(_Tp);
if (__n > 2 * __block_size && __block_size > 1)
@@ -510,8 +511,8 @@
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation>
typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
- _BinaryOperation, /*Inclusive*/ std::false_type)
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+ _BinaryOperation, /*Inclusive*/ std::false_type)
{
__PSTL_PRAGMA_SIMD_SCAN(+ : __init)
for (_Size __i = 0; __i < __n; ++__i)
@@ -545,8 +546,8 @@
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation>
typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
- _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+ _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
{
typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
_CombinerType __init_{__init, &__binary_op};
@@ -568,8 +569,8 @@
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation>
typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
- _BinaryOperation, /*Inclusive*/ std::true_type)
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+ _BinaryOperation, /*Inclusive*/ std::true_type)
{
__PSTL_PRAGMA_SIMD_SCAN(+ : __init)
for (_Size __i = 0; __i < __n; ++__i)
@@ -585,8 +586,8 @@
template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
class _BinaryOperation>
typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
- _BinaryOperation __binary_op, std::true_type)
+__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
+ _BinaryOperation __binary_op, std::true_type)
{
typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
_CombinerType __init_{__init, &__binary_op};
@@ -608,7 +609,7 @@
// complexity [violation] - We will have at most (__n-1 + number_of_lanes) comparisons instead of at most __n-1.
template <typename _ForwardIterator, typename _Size, typename _Compare>
_ForwardIterator
-simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
+__simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
{
if (__n == 0)
{
@@ -667,7 +668,7 @@
// complexity [violation] - We will have at most (2*(__n-1) + 4*number_of_lanes) comparisons instead of at most [1.5*(__n-1)].
template <typename _ForwardIterator, typename _Size, typename _Compare>
std::pair<_ForwardIterator, _ForwardIterator>
-simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
+__simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
{
if (__n == 0)
{
@@ -751,8 +752,8 @@
template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2,
class _UnaryPredicate>
std::pair<_OutputIterator1, _OutputIterator2>
-simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
- _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
+__simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
+ _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
{
_DifferenceType __cnt_true = 0, __cnt_false = 0;
@@ -776,8 +777,8 @@
template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
_ForwardIterator1
-simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
- _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept
+__simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
+ _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept
{
typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferencType;
@@ -795,8 +796,8 @@
{
for (; __first != __last; ++__first)
{
- if (simd_or(__s_first, __n2,
- internal::equal_value_by_pred<decltype(*__first), _BinaryPredicate>(*__first, __pred)))
+ if (__simd_or(__s_first, __n2,
+ __internal::__equal_value_by_pred<decltype(*__first), _BinaryPredicate>(*__first, __pred)))
{
return __first;
}
@@ -806,10 +807,10 @@
{
for (; __s_first != __s_last; ++__s_first)
{
- const auto __result = unseq_backend::simd_first(
- __first, _DifferencType(0), __n1, [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) {
- return __pred(__it[__i], *__s_first);
- });
+ const auto __result = __simd_first(__first, _DifferencType(0), __n1,
+ [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) {
+ return __pred(__it[__i], *__s_first);
+ });
if (__result != __last)
{
return __result;
@@ -821,12 +822,12 @@
template <class _RandomAccessIterator, class _DifferenceType, class _UnaryPredicate>
_RandomAccessIterator
-simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
+__simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
{
// find first element we need to remove
- auto __current = unseq_backend::simd_first(
- __first, _DifferenceType(0), __n,
- [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); });
+ auto __current =
+ __simd_first(__first, _DifferenceType(0), __n,
+ [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); });
__n -= __current - __first;
// if we have in sequence only one element that pred(__current[1]) != false we can exit the function
@@ -848,7 +849,7 @@
}
return __current + __cnt;
}
-} // namespace unseq_backend
+} // namespace __unseq_backend
} // namespace __pstl
#endif /* __PSTL_unseq_backend_simd_H */
diff --git a/include/pstl/internal/utils.h b/include/pstl/internal/utils.h
index 8c31031..00ccc62 100644
--- a/include/pstl/internal/utils.h
+++ b/include/pstl/internal/utils.h
@@ -15,12 +15,12 @@
namespace __pstl
{
-namespace internal
+namespace __internal
{
template <typename _Fp>
typename std::result_of<_Fp()>::type
-except_handler(_Fp __f)
+__except_handler(_Fp __f)
{
try
{
@@ -38,46 +38,46 @@
template <typename _Fp>
void
-invoke_if(std::true_type, _Fp __f)
+__invoke_if(std::true_type, _Fp __f)
{
__f();
}
template <typename _Fp>
void
-invoke_if(std::false_type, _Fp __f)
+__invoke_if(std::false_type, _Fp __f)
{
}
template <typename _Fp>
void
-invoke_if_not(std::false_type, _Fp __f)
+__invoke_if_not(std::false_type, _Fp __f)
{
__f();
}
template <typename _Fp>
void
-invoke_if_not(std::true_type, _Fp __f)
+__invoke_if_not(std::true_type, _Fp __f)
{
}
template <typename _F1, typename _F2>
typename std::result_of<_F1()>::type
-invoke_if_else(std::true_type, _F1 __f1, _F2 __f2)
+__invoke_if_else(std::true_type, _F1 __f1, _F2 __f2)
{
return __f1();
}
template <typename _F1, typename _F2>
typename std::result_of<_F2()>::type
-invoke_if_else(std::false_type, _F1 __f1, _F2 __f2)
+__invoke_if_else(std::false_type, _F1 __f1, _F2 __f2)
{
return __f2();
}
//! Unary operator that returns reference to its argument.
-struct no_op
+struct __no_op
{
template <typename _Tp>
_Tp&&
@@ -89,12 +89,12 @@
//! Logical negation of a predicate
template <typename _Pred>
-class not_pred
+class __not_pred
{
_Pred _M_pred;
public:
- explicit not_pred(_Pred __pred) : _M_pred(__pred) {}
+ explicit __not_pred(_Pred __pred) : _M_pred(__pred) {}
template <typename... _Args>
bool
@@ -105,12 +105,12 @@
};
template <typename _Pred>
-class reorder_pred
+class __reorder_pred
{
_Pred _M_pred;
public:
- explicit reorder_pred(_Pred __pred) : _M_pred(__pred) {}
+ explicit __reorder_pred(_Pred __pred) : _M_pred(__pred) {}
template <typename _FTp, typename _STp>
bool
@@ -123,10 +123,10 @@
//! "==" comparison.
/** Not called "equal" to avoid (possibly unfounded) concerns about accidental invocation via
argument-dependent name lookup by code expecting to find the usual std::equal. */
-class pstl_equal
+class __pstl_equal
{
public:
- explicit pstl_equal() {}
+ explicit __pstl_equal() {}
template <typename _Xp, typename _Yp>
bool
@@ -137,10 +137,10 @@
};
//! "<" comparison.
-class pstl_less
+class __pstl_less
{
public:
- explicit pstl_less() {}
+ explicit __pstl_less() {}
template <typename _Xp, typename _Yp>
bool
@@ -152,13 +152,13 @@
//! Like a polymorphic lambda for pred(...,value)
template <typename _Tp, typename _Predicate>
-class equal_value_by_pred
+class __equal_value_by_pred
{
const _Tp& _M_value;
_Predicate _M_pred;
public:
- equal_value_by_pred(const _Tp& __value, _Predicate __pred) : _M_value(__value), _M_pred(__pred) {}
+ __equal_value_by_pred(const _Tp& __value, _Predicate __pred) : _M_value(__value), _M_pred(__pred) {}
template <typename _Arg>
bool
@@ -170,12 +170,12 @@
//! Like a polymorphic lambda for ==value
template <typename _Tp>
-class equal_value
+class __equal_value
{
const _Tp& _M_value;
public:
- explicit equal_value(const _Tp& __value) : _M_value(__value) {}
+ explicit __equal_value(const _Tp& __value) : _M_value(__value) {}
template <typename _Arg>
bool
@@ -187,12 +187,12 @@
//! Logical negation of ==value
template <typename _Tp>
-class not_equal_value
+class __not_equal_value
{
const _Tp& _M_value;
public:
- explicit not_equal_value(const _Tp& __value) : _M_value(__value) {}
+ explicit __not_equal_value(const _Tp& __value) : _M_value(__value) {}
template <typename _Arg>
bool
@@ -204,7 +204,7 @@
template <typename _ForwardIterator, typename _Compare>
_ForwardIterator
-cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp)
+__cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp)
{
if (__a < __b)
{ // we should return closer iterator
@@ -216,7 +216,7 @@
}
}
-} // namespace internal
+} // namespace __internal
} // namespace __pstl
#endif /* __PSTL_utils_H */
diff --git a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
index c27e51c..1709851 100644
--- a/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp
@@ -39,7 +39,7 @@
EXPECT_TRUE(std::distance(true_first, actual_ret.first) == std::count_if(first, last, unary_op),
"partition_copy has wrong effect from true sequence");
EXPECT_TRUE(std::distance(false_first, actual_ret.second) ==
- std::count_if(first, last, __pstl::internal::not_pred<UnaryOp>(unary_op)),
+ std::count_if(first, last, __pstl::__internal::__not_pred<UnaryOp>(unary_op)),
"partition_copy has wrong effect from false sequence");
}
diff --git a/test/std/algorithms/alg.modifying.operations/replace.pass.cpp b/test/std/algorithms/alg.modifying.operations/replace.pass.cpp
index 5aeaac8..7784d38 100644
--- a/test/std/algorithms/alg.modifying.operations/replace.pass.cpp
+++ b/test/std/algorithms/alg.modifying.operations/replace.pass.cpp
@@ -151,7 +151,7 @@
int32_t
main()
{
- test<int32_t, float32_t>(__pstl::internal::equal_value<int32_t>(666));
+ test<int32_t, float32_t>(__pstl::__internal::__equal_value<int32_t>(666));
test<uint16_t, uint8_t>([](const uint16_t& elem) { return elem % 3 < 2; });
test<float64_t, int64_t>([](const float64_t& elem) { return elem * elem - 3.5 * elem > 10; });
test<copy_int, copy_int>([](const copy_int& val) { return val.value / 5 > 2; });
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp
index b18bb5f..fff2284 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp
@@ -103,7 +103,7 @@
main()
{
- test_includes<float64_t, float64_t>(__pstl::internal::pstl_less());
+ test_includes<float64_t, float64_t>(__pstl::__internal::__pstl_less());
test_includes<Num<int64_t>, Num<int32_t>>([](const Num<int64_t>& x, const Num<int32_t>& y) { return x < y; });
std::cout << done() << std::endl;
diff --git a/test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp b/test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp
index 33b7542..6d8c089 100644
--- a/test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp
+++ b/test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp
@@ -156,7 +156,7 @@
main()
{
- test_set<float64_t, float64_t>(__pstl::internal::pstl_less());
+ test_set<float64_t, float64_t>(__pstl::__internal::__pstl_less());
test_set<Num<int64_t>, Num<int32_t>>([](const Num<int64_t>& x, const Num<int32_t>& y) { return x < y; });
test_algo_basic_double<int32_t>(run_for_rnd_fw<test_non_const<int32_t>>());
diff --git a/test/support/utils.h b/test/support/utils.h
index 438d453..e4ef92c 100644
--- a/test/support/utils.h
+++ b/test/support/utils.h
@@ -1238,7 +1238,7 @@
invoke_if(Policy&& p, F f)
{
#if __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
- __pstl::internal::invoke_if_not(__pstl::internal::allow_unsequenced<Policy>(), f);
+ __pstl::__internal::invoke_if_not(__pstl::__internal::allow_unsequenced<Policy>(), f);
#else
f();
#endif
