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

3388a949 · Marcus Winter · 6acc663b · 3388a949 · 3388a949 · 3388a949
Commit 3388a949 authored Feb 03, 2015 by Marcus Winter
7 changed files
--- a/algorithms_cpp/include/embb/algorithms/count.h
+++ b/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

--- a/algorithms_cpp/include/embb/algorithms/for_each.h
+++ b/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

--- a/algorithms_cpp/include/embb/algorithms/invoke.h
+++ b/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

--- a/algorithms_cpp/include/embb/algorithms/merge_sort.h
+++ b/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

--- a/algorithms_cpp/include/embb/algorithms/quick_sort.h
+++ b/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

--- a/algorithms_cpp/include/embb/algorithms/reduce.h
+++ b/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

--- a/algorithms_cpp/include/embb/algorithms/scan.h
+++ b/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