algorithms_cpp: added guard definition for QuickSort, MergeSort restricting to RAI

algorithms_cpp/include/embb/algorithms/internal/merge_sort-inl.h

@@ -213,19 +213,18 @@ class MergeSortFunctor {
   }
   }
 };
 };
 
 
-}  // namespace internal
-
 template<typename RAI, typename RAITemp, typename ComparisonFunction>
 template<typename RAI, typename RAITemp, typename ComparisonFunction>
-void MergeSort(
+void MergeSortIteratorCheck(
   RAI first,
   RAI first,
   RAI last,
   RAI last,
   RAITemp temporary_first,
   RAITemp temporary_first,
   ComparisonFunction comparison,
   ComparisonFunction comparison,
   const embb::mtapi::ExecutionPolicy& policy,
   const embb::mtapi::ExecutionPolicy& policy,
-  size_t block_size
+  size_t block_size,
+  std::random_access_iterator_tag
   ) {
   ) {
   typedef typename std::iterator_traits<RAI>::difference_type difference_type;
   typedef typename std::iterator_traits<RAI>::difference_type difference_type;
-  typedef internal::MergeSortFunctor<RAI, RAITemp, ComparisonFunction>
+  typedef MergeSortFunctor<RAI, RAITemp, ComparisonFunction>
     functor_t;
     functor_t;
   difference_type distance = std::distance(first, last);
   difference_type distance = std::distance(first, last);
   if (distance == 0) {
   if (distance == 0) {
@@ -249,7 +248,7 @@ void MergeSort(
                "Not enough MTAPI tasks available to perform merge sort");
                "Not enough MTAPI tasks available to perform merge sort");
   }
   }
 
 
-  internal::BlockSizePartitioner<RAI> partitioner(first, last, block_size);
+  BlockSizePartitioner<RAI> partitioner(first, last, block_size);
   functor_t functor(0,
   functor_t functor(0,
                     partitioner.Size() - 1,
                     partitioner.Size() - 1,
                     temporary_first,
                     temporary_first,
@@ -266,6 +265,17 @@ void MergeSort(
   task.Wait(MTAPI_INFINITE);
   task.Wait(MTAPI_INFINITE);
 }
 }
 
 
+}  // namespace internal
+
+template<typename RAI, typename RAITemp, typename ComparisonFunction>
+void MergeSort(RAI first, RAI last, RAITemp temporary_first,
+  ComparisonFunction comparison, const embb::mtapi::ExecutionPolicy& policy,
+  size_t block_size) {
+  typedef typename std::iterator_traits<RAI>::iterator_category category;
+  internal::MergeSortIteratorCheck(first, last, temporary_first, comparison,
+    policy, block_size, category());
+}
+
 }  // namespace algorithms
 }  // namespace algorithms
 }  // namespace embb
 }  // namespace embb
 
 

algorithms_cpp/include/embb/algorithms/internal/quick_sort-inl.h

@@ -186,11 +186,12 @@ class QuickSortFunctor {
   QuickSortFunctor(const QuickSortFunctor&);
   QuickSortFunctor(const QuickSortFunctor&);
 };
 };
 
 
-}  // namespace internal
-
 template <typename RAI, typename ComparisonFunction>
 template <typename RAI, typename ComparisonFunction>
-void QuickSort(RAI first, RAI last, ComparisonFunction comparison,
-  const embb::mtapi::ExecutionPolicy& policy, size_t block_size) {
+void QuickSortIteratorCheck(RAI first, RAI last,
+  ComparisonFunction comparison,
+  const embb::mtapi::ExecutionPolicy& policy,
+  size_t block_size,
+  std::random_access_iterator_tag) {
   embb::mtapi::Node& node = embb::mtapi::Node::GetInstance();
   embb::mtapi::Node& node = embb::mtapi::Node::GetInstance();
   typedef typename std::iterator_traits<RAI>::difference_type difference_type;
   typedef typename std::iterator_traits<RAI>::difference_type difference_type;
   difference_type distance = std::distance(first, last);
   difference_type distance = std::distance(first, last);
@@ -212,13 +213,23 @@ void QuickSort(RAI first, RAI last, ComparisonFunction comparison,
     EMBB_THROW(embb::base::ErrorException,
     EMBB_THROW(embb::base::ErrorException,
                "Not enough MTAPI tasks available for performing quick sort");
                "Not enough MTAPI tasks available for performing quick sort");
   }
   }
-  internal::QuickSortFunctor<RAI, ComparisonFunction> functor(
+  QuickSortFunctor<RAI, ComparisonFunction> functor(
       first, last, comparison, policy, block_size);
       first, last, comparison, policy, block_size);
   mtapi::Task task = node.Spawn(mtapi::Action(base::MakeFunction(
   mtapi::Task task = node.Spawn(mtapi::Action(base::MakeFunction(
-      functor, &internal::QuickSortFunctor<RAI, ComparisonFunction>::Action)));
+      functor, &QuickSortFunctor<RAI, ComparisonFunction>::Action)));
   task.Wait(MTAPI_INFINITE);
   task.Wait(MTAPI_INFINITE);
 }
 }
 
 
+}  // namespace internal
+
+template <typename RAI, typename ComparisonFunction>
+void QuickSort(RAI first, RAI last, ComparisonFunction comparison,
+  const embb::mtapi::ExecutionPolicy& policy, size_t block_size) {
+  typedef typename std::iterator_traits<RAI>::iterator_category category;
+  internal::QuickSortIteratorCheck(first, last, comparison, 
+                                   policy, block_size, category());
+}
+
 }  // namespace algorithms
 }  // namespace algorithms
 }  // namespace embb
 }  // namespace embb