algorithms_cpp: updated doxygen documentation links to embb:mtapi::ExecutionPolicy

algorithms_cpp/include/embb/algorithms/count.h

@@ -56,7 +56,7 @@ namespace algorithms {
  *             while the algorithm is executed.
  * \note No guarantee is given on the execution order of the comparison
  *       operations.
- * \see CountIf(), ExecutionPolicy
+ * \see CountIf(), embb::mtapi::ExecutionPolicy
  * \tparam RAI Random access iterator
  * \tparam ValueType Type of \c value that is compared to the elements in the
  *         range using the \c operator==.
@@ -72,7 +72,7 @@ typename std::iterator_traits<RAI>::difference_type Count(
   /**< [IN] Value that the elements in the range are compared to using
             \c operator== */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the counting algorithm */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the counting algorithm */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are sorted in parallel. Partitioning of a block stops if its size
@@ -96,7 +96,7 @@ typename std::iterator_traits<RAI>::difference_type Count(
  *             while the algorithm is executed.
  * \note No guarantee is given on the execution order of the comparison
  *       function.
- * \see Count(), ExecutionPolicy
+ * \see Count(), embb::mtapi::ExecutionPolicy
  * \tparam RAI Random access iterator
  * \tparam ComparisonFunction Unary predicate with argument of type
  *         <tt>std::iterator_traits<RAI>::value_type</tt>.
@@ -112,7 +112,7 @@ typename std::iterator_traits<RAI>::difference_type CountIf(
   /**< [IN] Unary predicate used to test the elements in the range. Elements for
             which \c comparison returns true are counted. */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the counting algorithm */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the counting algorithm */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are sorted in parallel. Partitioning of a block stops if its size

algorithms_cpp/include/embb/algorithms/for_each.h

@@ -53,7 +53,7 @@ namespace algorithms {
  *             while the algorithm is executed.
  * \note No guarantee is given on the order in which the function is applied to
  *       the elements.
- * \see ExecutionPolicy, ZipIterator
+ * \see embb::mtapi::ExecutionPolicy, ZipIterator
  * \tparam RAI Random access iterator
  * \tparam Function Unary function with argument of type
  *         <tt>std::iterator_traits<RAI>::value_type</tt>.
@@ -68,7 +68,7 @@ void ForEach(
   Function unary,
   /**< [IN] Unary function applied to each element in the range */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the foreach loop execution */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the foreach loop execution */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are treated in parallel. Partitioning of a block stops if its size

algorithms_cpp/include/embb/algorithms/invoke.h

@@ -63,7 +63,7 @@ void Invoke(
 
 /**
 * Spawns one to ten function objects at once and runs them in parallel using the
-* given ExecutionPolicy.
+* given embb::mtapi::ExecutionPolicy.
 *
 * Blocks until all of them are done.
 *
@@ -75,7 +75,7 @@ void Invoke(
   /**< [in] Function to invoke */
   ...,
   const embb::mtapi::ExecutionPolicy & policy
-  /**< [in] ExecutionPolicy to use */
+  /**< [in] embb::mtapi::ExecutionPolicy to use */
   );
 
 #else // DOXYGEN

algorithms_cpp/include/embb/algorithms/merge_sort.h

@@ -59,7 +59,7 @@ namespace algorithms {
  *             modified by another thread while the algorithm is executed.
  * \note No guarantee is given on the execution order of the comparison
          operations.
- * \see ExecutionPolicy, MergeSort()
+ * \see embb::mtapi::ExecutionPolicy, MergeSort()
  * \tparam RAI Random access iterator
  * \tparam ComparisonFunction Binary predicate with both arguments of type
  *         <tt>std::iterator_traits<RAI>::value_type</tt>.
@@ -78,7 +78,7 @@ void MergeSortAllocate(
             <tt>comparison(a, b) == true</tt>. The default value uses the
             less-than relation. */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the merge sort algorithm */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the merge sort algorithm */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are sorted in parallel. Partitioning of a block stops if its size
@@ -105,7 +105,7 @@ void MergeSortAllocate(
  *             modified by another thread while the algorithm is executed.
  * \note No guarantee is given on the execution order of the comparison
  *       operations.
- * \see ExecutionPolicy, MergeSortAllocate()
+ * \see embb::mtapi::ExecutionPolicy, MergeSortAllocate()
  * \tparam RAI Random access iterator
  * \tparam RAITemp Random access iterator for temporary memory. Has to have the
  *         same value type as RAI.
@@ -128,7 +128,7 @@ void MergeSort(
               <tt>comparison(a, b) == true</tt>. The default value uses the
               less-than relation. */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the merge sort algorithm */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the merge sort algorithm */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are sorted in parallel. Partitioning of a block stops if its size

algorithms_cpp/include/embb/algorithms/quick_sort.h

@@ -54,7 +54,7 @@ namespace algorithms {
  *             modified by another thread while the algorithm is executed.
  * \note No guarantee is given on the execution order of the comparison
  *       operations.
- * \see ExecutionPolicy, MergeSort()
+ * \see embb::mtapi::ExecutionPolicy, MergeSort()
  * \tparam RAI Random access iterator
  * \tparam ComparisonFunction Binary predicate with both arguments of type
  *         <tt>std::iterator_traits<RAI>::value_type</tt>.
@@ -73,7 +73,7 @@ void QuickSort(
             <tt>comparison(a, b) == true</tt>. The default value uses the
             less-than relation. */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the quick sort algorithm */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the quick sort algorithm */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are sorted in parallel. Partitioning of a block stops if its size

algorithms_cpp/include/embb/algorithms/reduce.h

@@ -64,7 +64,7 @@ namespace algorithms {
  *       associative, i.e., <tt>reduction(x, reduction(y, z)) ==
  *       reduction(reduction(x, y), z))</tt> for all \c x, \c y, \c z of type
  *       \c ReturnType.
- * \see ExecutionPolicy, ZipIterator, Identity
+ * \see embb::mtapi::ExecutionPolicy, ZipIterator, Identity
  * \tparam RAI Random access iterator
  * \tparam ReturnType Type of result of reduction operation, deduced from
  *         \c neutral
@@ -90,7 +90,7 @@ ReturnType Reduce(
   /**< [IN] Transforms the elements of the range before the reduction operation
             is applied */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the reduction computation */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the reduction computation */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are treated in parallel. Partitioning of a block stops if its size

algorithms_cpp/include/embb/algorithms/scan.h

@@ -66,7 +66,7 @@ namespace algorithms {
  *       associative, i.e., <tt>reduction(x, reduction(y, z)) ==
  *       reduction(reduction(x, y), z))</tt> for all \c x, \c y, \c z of type
  *       \c ReturnType.
- * \see ExecutionPolicy, Identity, ZipIterator
+ * \see embb::mtapi::ExecutionPolicy, Identity, ZipIterator
  * \tparam RAIIn Random access iterator type of input range
  * \tparam RAIOut Random access iterator type of output range
  * \tparam ReturnType Type of output elements of scan operation, deduced from
@@ -97,7 +97,7 @@ void Scan(
   /**< [IN] Transforms the elements of the input range before the scan operation
             is applied */
   const embb::mtapi::ExecutionPolicy& policy = embb::mtapi::ExecutionPolicy(),
-  /**< [IN] ExecutionPolicy for the scan computation */
+  /**< [IN] embb::mtapi::ExecutionPolicy for the scan computation */
   size_t block_size = 0
   /**< [IN] Lower bound for partitioning the range of elements into blocks that
             are treated in parallel. Partitioning of a block stops if its size