Break iter and source into separate modules.

diff --git a/src/iter.rs b/src/iter.rs
new file mode 100644 (file)
index 0000000..fd05950
--- /dev/null
+++ b/src/iter.rs
@@ -0,0 +1,89 @@
+use crate::Entry;
+use std::iter::Iterator;
+
+pub trait Iter: Iterator<Item = Entry> {
+    fn seek(&mut self, key: &[u8]);
+}
+
+pub type BoxedIter<'a> = Box<dyn Iter + 'a>;
+
+impl<'a> Iter for BoxedIter<'a> {
+    fn seek(&mut self, key: &[u8]) {
+        self.as_mut().seek(key);
+    }
+}
+
+pub struct PrefixIter<I: Iter> {
+    iter: I,
+    prefix: Vec<u8>,
+}
+
+impl<I: Iter> PrefixIter<I> {
+    pub fn new(mut iter: I, prefix: &[u8]) -> Self {
+       iter.seek(prefix);
+        Self {
+            iter,
+            prefix: Vec::from(prefix),
+        }
+    }
+}
+
+impl<I: Iter> Iterator for PrefixIter<I> {
+    type Item = Entry;
+    fn next(&mut self) -> Option<Self::Item> {
+        let item = self.iter.next()?;
+        if item.key.starts_with(self.prefix.as_slice()) {
+            Some(item)
+        } else {
+            None
+        }
+    }
+}
+
+impl<I: Iter> Iter for PrefixIter<I> {
+    fn seek(&mut self, key: &[u8]) {
+        self.iter.seek(key);
+    }
+}
+
+pub struct RangeIter<I: Iter> {
+    iter: I,
+    start: Vec<u8>,
+    end: Vec<u8>,
+}
+
+impl<I: Iter> RangeIter<I> {
+    pub fn new(mut iter: I, start: &[u8], end: &[u8]) -> Self {
+       iter.seek(start);
+        Self {
+            iter,
+            start: Vec::from(start),
+            end: Vec::from(end),
+        }
+    }
+}
+
+impl<I: Iter> Iterator for RangeIter<I> {
+    type Item = Entry;
+    fn next(&mut self) -> Option<Self::Item> {
+        let item = self.iter.next()?;
+        if item.key.as_slice() <= self.end.as_slice() {
+            Some(item)
+        } else {
+            None
+        }
+    }
+}
+
+impl<I: Iter> Iter for RangeIter<I> {
+    fn seek(&mut self, key: &[u8]) {
+        if key <= self.start.as_slice() {
+            self.iter.seek(self.start.as_slice());
+        } else if key > self.end.as_slice() {
+            self.iter.seek(self.end.as_slice());
+            self.iter.next();
+        } else {
+            self.iter.seek(key);
+        }
+    }
+}

diff --git a/src/lib.rs b/src/lib.rs
index 62ddf6bedcd01b2f079ee6f64b7e44892d7c2537..8304d7735d36d4e69e7d4b2f5758b23e431167f3 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,9 +2,11 @@ pub mod entry;
 use entry::Entry;
 
 pub mod source;
-use source::Iter;
 use source::Source;
 
+pub mod iter;
+use iter::Iter;
+
 pub mod merger;
 //use merger::Merger;
 

diff --git a/src/source.rs b/src/source.rs
index 6699f8e59e260bda6b4241dd9b946d1816aab3b5..535fe5a18fe72bae0c8294bde737877894778727 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -1,19 +1,7 @@
-use crate::Entry;
-use std::iter::Iterator;
+use crate::iter::{BoxedIter, PrefixIter, RangeIter};
+use crate::Iter;
 use std::marker::PhantomData;
 
-pub trait Iter: Iterator<Item = Entry> {
-    fn seek(&mut self, key: &[u8]);
-}
-
-type BoxedIter<'a> = Box<dyn Iter + 'a>;
-
-impl<'a> Iter for BoxedIter<'a> {
-    fn seek(&mut self, key: &[u8]) {
-        self.as_mut().seek(key);
-    }
-}
-
 pub trait IterSource {
     type It: Iter;
     fn iter(&self) -> Self::It;
@@ -36,86 +24,15 @@ impl<S: DefaultSource> Source for S {
     type Range = RangeIter<S::It>;
 
     fn get(&self, key: &[u8]) -> Self::Get {
-        let mut res = RangeIter {
-            iter: self.iter(),
-            start: Vec::from(key),
-            end: Vec::from(key),
-        };
-        res.seek(key);
-        res
+        RangeIter::new(self.iter(), key, key)
     }
 
     fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
-        let mut res = PrefixIter {
-            iter: self.iter(),
-            prefix: Vec::from(prefix),
-        };
-        res.seek(prefix);
-        res
+        PrefixIter::new(self.iter(), prefix)
     }
 
     fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Range {
-        let mut res = RangeIter {
-            iter: self.iter(),
-            start: Vec::from(start),
-            end: Vec::from(end),
-        };
-        res.seek(start);
-        res
-    }
-}
-
-pub struct PrefixIter<I: Iter> {
-    iter: I,
-    prefix: Vec<u8>,
-}
-
-impl<I: Iter> Iterator for PrefixIter<I> {
-    type Item = Entry;
-    fn next(&mut self) -> Option<Self::Item> {
-        let item = self.iter.next()?;
-        if item.key.starts_with(self.prefix.as_slice()) {
-            Some(item)
-        } else {
-            None
-        }
-    }
-}
-
-impl<I: Iter> Iter for PrefixIter<I> {
-    fn seek(&mut self, key: &[u8]) {
-        self.iter.seek(key);
-    }
-}
-
-pub struct RangeIter<I: Iter> {
-    iter: I,
-    start: Vec<u8>,
-    end: Vec<u8>,
-}
-
-impl<I: Iter> Iterator for RangeIter<I> {
-    type Item = Entry;
-    fn next(&mut self) -> Option<Self::Item> {
-        let item = self.iter.next()?;
-        if item.key.as_slice() <= self.end.as_slice() {
-            Some(item)
-        } else {
-            None
-        }
-    }
-}
-
-impl<I: Iter> Iter for RangeIter<I> {
-    fn seek(&mut self, key: &[u8]) {
-        if key <= self.start.as_slice() {
-            self.iter.seek(self.start.as_slice());
-        } else if key > self.end.as_slice() {
-            self.iter.seek(self.end.as_slice());
-            self.iter.next();
-        } else {
-            self.iter.seek(key);
-        }
+        RangeIter::new(self.iter(), start, end)
     }
 }
 
@@ -179,7 +96,10 @@ impl<'a> Source for BoxedSource<'a> {
 
 #[cfg(test)]
 pub mod test {
-    use super::{BoxedSource, DefaultSource, Entry, Iter, IterSource, Source};
+    use super::{BoxedSource, DefaultSource, IterSource};
+    use crate::Entry;
+    use crate::Iter;
+    use crate::Source;
 
     pub struct TestSource(pub Vec<Entry>);