uglyfication for pstl namespace

include/pstl/execution

@@ -39,11 +39,21 @@
 #endif
 
 #if __PSTL_CPP17_EXECUTION_POLICIES_PRESENT
-__PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace pstl::execution")
+__PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution")
 #else
 #include "internal/glue_execution_defs.h"
 __PSTL_PRAGMA_MESSAGE_POLICIES(
     "The <Parallel STL> execution policies are injected into the standard namespace std::execution")
 #endif
 
+//TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of
+// standard C++ library
+namespace pstl
+{
+namespace execution
+{
+using namespace __pstl::execution;
+}
+}
+
 #endif /* __PSTL_execution */

include/pstl/internal/algorithm_impl.h

@@ -36,7 +36,7 @@
 #endif
 #include "parallel_impl.h"
 
-namespace pstl
+namespace __pstl
 {
 namespace internal
 {
@@ -3562,6 +3562,6 @@ pattern_lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __f
 }
 
 } // namespace internal
-} // namespace pstl
+} // namespace __pstl
 
 #endif /* __PSTL_algorithm_impl_H */

include/pstl/internal/execution_defs.h

@@ -23,7 +23,7 @@
 
 #include <type_traits>
 
-namespace pstl
+namespace __pstl
 {
 namespace execution
 {
@@ -164,10 +164,10 @@ namespace internal
 {
 template <class ExecPolicy, class T>
 using enable_if_execution_policy =
-    typename std::enable_if<pstl::execution::is_execution_policy<typename std::decay<ExecPolicy>::type>::value,
+    typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<ExecPolicy>::type>::value,
                             T>::type;
 } // namespace internal
 
-} // namespace pstl
+} // namespace __pstl
 
 #endif /* __PSTL_execution_policy_defs_H */

include/pstl/internal/execution_impl.h

@@ -26,12 +26,12 @@
 
 #include "execution_defs.h"
 
-namespace pstl
+namespace __pstl
 {
 namespace internal
 {
 
-using namespace pstl::execution;
+using namespace __pstl::execution;
 
 /* predicate */
 
@@ -161,6 +161,6 @@ struct prefer_parallel_tag
 };
 
 } // namespace internal
-} // namespace pstl
+} // namespace __pstl
 
 #endif /* __PSTL_execution_impl_H */

include/pstl/internal/glue_execution_defs.h

@@ -28,35 +28,35 @@
 namespace std
 {
 // Type trait
-using pstl::execution::is_execution_policy;
+using __pstl::execution::is_execution_policy;
 #if __PSTL_CPP14_VARIABLE_TEMPLATES_PRESENT
 #if __INTEL_COMPILER
 template <class T>
 constexpr bool is_execution_policy_v = is_execution_policy<T>::value;
 #else
-using pstl::execution::is_execution_policy_v;
+using __pstl::execution::is_execution_policy_v;
 #endif
 #endif
 
 namespace execution
 {
 // Standard C++ policy classes
-using pstl::execution::sequenced_policy;
+using __pstl::execution::sequenced_policy;
 #if __PSTL_USE_PAR_POLICIES
-using pstl::execution::parallel_policy;
-using pstl::execution::parallel_unsequenced_policy;
+using __pstl::execution::parallel_policy;
+using __pstl::execution::parallel_unsequenced_policy;
 #endif
 // Standard predefined policy instances
-using pstl::execution::seq;
+using __pstl::execution::seq;
 #if __PSTL_USE_PAR_POLICIES
-using pstl::execution::par;
-using pstl::execution::par_unseq;
+using __pstl::execution::par;
+using __pstl::execution::par_unseq;
 #endif
 // Implementation-defined names
 // Unsequenced policy is not yet standard, but for consistency
 // we include it into namespace std::execution as well
-using pstl::execution::unseq;
-using pstl::execution::unsequenced_policy;
+using __pstl::execution::unseq;
+using __pstl::execution::unsequenced_policy;
 } // namespace execution
 } // namespace std
 

include/pstl/internal/glue_memory_defs.h

@@ -29,61 +29,61 @@ namespace std
 // [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

include/pstl/internal/glue_memory_impl.h

@@ -30,14 +30,14 @@ namespace std
 // [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;
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
     typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-    using namespace pstl;
+    using namespace __pstl;
 
     const auto __is_parallel =
         internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
@@ -64,14 +64,14 @@ uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIter
 }
 
 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;
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
     typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-    using namespace pstl;
+    using namespace __pstl;
 
     const auto __is_parallel =
         internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
@@ -100,14 +100,14 @@ uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __
 // [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;
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
     typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-    using namespace pstl;
+    using namespace __pstl;
 
     const auto __is_parallel =
         internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
@@ -134,14 +134,14 @@ uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIter
 }
 
 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;
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
     typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-    using namespace pstl;
+    using namespace __pstl;
 
     const auto __is_parallel =
         internal::is_parallelization_preferred<_ExecutionPolicy, _InputIterator, _ForwardIterator>(__exec);
@@ -170,12 +170,12 @@ uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __
 // [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;
+    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);
@@ -198,12 +198,12 @@ uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Forward
 }
 
 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;
+    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);
@@ -229,12 +229,12 @@ uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size
 // [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;
+    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);
@@ -246,12 +246,12 @@ destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __
 }
 
 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;
+    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);
@@ -268,12 +268,12 @@ 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)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
     typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-    using namespace pstl;
+    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);
@@ -286,12 +286,12 @@ uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __fi
 }
 
 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;
+    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);
@@ -308,12 +308,12 @@ uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __
 // [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;
+    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);
@@ -335,12 +335,12 @@ uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __firs
 }
 
 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;
+    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);