From 994a818b271f13b889639e4b55ef03e258c077b1 Mon Sep 17 00:00:00 2001
From: chris mikkelson <chris@mikk.net>
Date: Mon, 29 Jul 2024 14:00:38 -0500
Subject: [PATCH] Break iter and source into separate modules.

---
 src/iter.rs   | 89 ++++++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs    |  4 ++-
 src/source.rs | 98 +++++----------------------------------------------
 3 files changed, 101 insertions(+), 90 deletions(-)
 create mode 100644 src/iter.rs

diff --git a/src/iter.rs b/src/iter.rs
new file mode 100644
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 62ddf6b..8304d77 100644
--- 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 6699f8e..535fe5a 100644
--- 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>);
 
-- 
2.50.1