wip: move smart_iter to its own module

Author: omarabid

src/core/mod.rs

@@ -4,6 +4,7 @@ pub(crate) mod common;
 pub mod owner_resolver;
 pub(crate) mod parse;
 pub mod parser;
+pub(crate) mod smart_iter;
 pub mod tag_resolver;
 pub mod types;
 

src/core/owner_resolver.rs

@@ -1,3 +1,4 @@
+use super::smart_iter::SmartIter;
 use crate::utils::error::{Error, Result};
 use ignore::overrides::{Override, OverrideBuilder};
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
@@ -401,51 +402,3 @@ mod tests {
         assert_eq!(result[0].identifier, "@rust-team");
     }
 }
-
-trait SmartIter<T: Send + Sync> {
-    fn smart_iter(&self, n: usize) -> SmartIterator<T>;
-}
-
-impl<'a, T: Send + Sync> SmartIter<T> for [T] {
-    fn smart_iter(&self, n: usize) -> SmartIterator<T> {
-        if self.len() <= n {
-            SmartIterator::Sequential(self.iter())
-        } else {
-            SmartIterator::Parallel(self.par_iter())
-        }
-    }
-}
-
-enum SmartIterator<'a, T: Send + Sync> {
-    Sequential(std::slice::Iter<'a, T>),
-    Parallel(rayon::slice::Iter<'a, T>),
-}
-
-enum SmartFilterMap<'a, T: Send + Sync, F> {
-    Parallel(rayon::iter::FilterMap<rayon::slice::Iter<'a, T>, F>),
-    Sequential(std::iter::FilterMap<std::slice::Iter<'a, T>, F>),
-}
-
-impl<'a, T: Send + Sync> SmartIterator<'a, T> {
-    fn filter_map<B: Send + Sync, F>(self, f: F) -> SmartFilterMap<'a, T, F>
-    where
-        F: Fn(&'a T) -> Option<B> + Send + Sync,
-    {
-        match self {
-            SmartIterator::Parallel(iter) => SmartFilterMap::Parallel(iter.filter_map(f)),
-            SmartIterator::Sequential(iter) => SmartFilterMap::Sequential(iter.filter_map(f)),
-        }
-    }
-}
-
-impl<'a, T: Send + Sync, B: Send + Sync, F> SmartFilterMap<'a, T, F>
-where
-    F: Fn(&'a T) -> Option<B> + Send + Sync,
-{
-    fn collect(self) -> Vec<B> {
-        match self {
-            SmartFilterMap::Parallel(iter) => iter.collect(),
-            SmartFilterMap::Sequential(iter) => iter.collect(),
-        }
-    }
-}

src/core/smart_iter.rs

@@ -0,0 +1,49 @@
+use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
+pub(crate) trait SmartIter<T: Send + Sync> {
+    fn smart_iter(&self, n: usize) -> SmartIterator<T>;
+}
+
+impl<T: Send + Sync> SmartIter<T> for [T] {
+    fn smart_iter(&self, n: usize) -> SmartIterator<T> {
+        if self.len() <= n {
+            SmartIterator::Sequential(self.iter())
+        } else {
+            SmartIterator::Parallel(self.par_iter())
+        }
+    }
+}
+
+pub(crate) enum SmartIterator<'a, T: Send + Sync> {
+    Sequential(std::slice::Iter<'a, T>),
+    Parallel(rayon::slice::Iter<'a, T>),
+}
+
+pub(crate) enum SmartFilterMap<'a, T: Send + Sync, F> {
+    Parallel(rayon::iter::FilterMap<rayon::slice::Iter<'a, T>, F>),
+    Sequential(std::iter::FilterMap<std::slice::Iter<'a, T>, F>),
+}
+
+impl<'a, T: Send + Sync> SmartIterator<'a, T> {
+    pub(crate) fn filter_map<B: Send + Sync, F>(self, f: F) -> SmartFilterMap<'a, T, F>
+    where
+        F: Fn(&'a T) -> Option<B> + Send + Sync,
+    {
+        match self {
+            SmartIterator::Parallel(iter) => SmartFilterMap::Parallel(iter.filter_map(f)),
+            SmartIterator::Sequential(iter) => SmartFilterMap::Sequential(iter.filter_map(f)),
+        }
+    }
+}
+
+impl<'a, T: Send + Sync, B: Send + Sync, F> SmartFilterMap<'a, T, F>
+where
+    F: Fn(&'a T) -> Option<B> + Send + Sync,
+{
+    pub(crate) fn collect(self) -> Vec<B> {
+        match self {
+            SmartFilterMap::Parallel(iter) => iter.collect(),
+            SmartFilterMap::Sequential(iter) => iter.collect(),
+        }
+    }
+}