Simplify merge_func, dupsort helpers

Add the iterator wrapper methods to the Iter trait, allowing
the source implementations to apply them to the inner iterator
rather than constructing the implementation structs directly.

diff --git a/src/dupsort_func.rs b/src/dupsort_func.rs
index 40231066b5f3ca0a1da53ccc216fde4f357bc6ce..589e8edb1e38bd98198fa3654eddcf8b5ff396ef 100644 (file)
--- a/src/dupsort_func.rs
+++ b/src/dupsort_func.rs
@@ -29,43 +29,26 @@ where
     F: Fn(&Entry, &Entry) -> Ordering,
 {
     fn iter(&self) -> impl Iter {
-        DupsortFuncIter {
-            run: Vec::new(),
-            next: None,
-            iter: self.source.iter(),
-            dupsort_func: &self.dupsort_func,
-        }
+        self.source.iter().dupsort_func(&self.dupsort_func)
     }
     fn get(&self, key: &[u8]) -> impl Iter {
-        DupsortFuncIter {
-            run: Vec::new(),
-            next: None,
-            iter: self.source.get(key),
-            dupsort_func: &self.dupsort_func,
-        }
+        self.source.get(key).dupsort_func(&self.dupsort_func)
     }
     fn get_prefix(&self, prefix: &[u8]) -> impl Iter {
-        DupsortFuncIter {
-            run: Vec::new(),
-            next: None,
-            iter: self.source.get_prefix(prefix),
-            dupsort_func: &self.dupsort_func,
-        }
+        self.source
+            .get_prefix(prefix)
+            .dupsort_func(&self.dupsort_func)
     }
     fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter {
-        DupsortFuncIter {
-            run: Vec::new(),
-            next: None,
-            iter: self.source.get_range(start, end),
-            dupsort_func: &self.dupsort_func,
-        }
+        self.source
+            .get_range(start, end)
+            .dupsort_func(&self.dupsort_func)
     }
 }
 
 #[derive(Debug)]
-struct DupsortFuncIter<'a, I, F>
+pub struct DupsortFuncIter<'a, I, F>
 where
-    I: Iter,
     F: Fn(&Entry, &Entry) -> Ordering,
 {
     run: Vec<Entry>,
@@ -74,9 +57,23 @@ where
     dupsort_func: &'a F,
 }
 
+impl<'a, I, F> DupsortFuncIter<'a, I, F>
+where
+    F: Fn(&Entry, &Entry) -> Ordering,
+{
+    pub fn new(iter: I, dupsort_func: &'a F) -> Self {
+        Self {
+            run: Vec::new(),
+            next: None,
+            iter,
+            dupsort_func,
+        }
+    }
+}
+
 impl<'a, I, F> Iterator for DupsortFuncIter<'a, I, F>
 where
-    I: Iter,
+    I: Iterator<Item = Entry>,
     F: Fn(&Entry, &Entry) -> Ordering,
 {
     type Item = Entry;

diff --git a/src/iter.rs b/src/iter.rs
index f92f301e44d188b2c9ceb0c95c58c2a93ee596c9..eeaececeb712117b80d26ba98ba5f24de89563bb 100644 (file)
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -1,8 +1,36 @@
+use crate::dupsort_func::DupsortFuncIter;
+use crate::filter::FilterIter;
+use crate::merge_func::MergeFuncIter;
 use crate::Entry;
+use std::cmp::Ordering;
 use std::iter::Iterator;
 
 pub trait Iter: Iterator<Item = Entry> {
     fn seek(&mut self, key: &[u8]);
+
+    fn merge_func<'a, F>(self, merge_func: &'a F) -> MergeFuncIter<'a, Self, F>
+    where
+        F: Fn(&mut Vec<u8>, &Entry),
+        Self: Sized,
+    {
+        MergeFuncIter::new(self, merge_func)
+    }
+
+    fn dupsort_func<'a, F>(self, dupsort_func: &'a F) -> DupsortFuncIter<'a, Self, F>
+    where
+        F: Fn(&Entry, &Entry) -> Ordering,
+        Self: Sized,
+    {
+        DupsortFuncIter::new(self, dupsort_func)
+    }
+
+    fn filter_func<'a, F>(self, filter_func: &'a F) -> FilterIter<'a, Self, F>
+    where
+        F: Fn(&Entry, &mut dyn Iter) -> bool,
+        Self: Sized,
+    {
+        FilterIter::new(self, filter_func)
+    }
 }
 
 pub type BoxedIter<'a> = Box<dyn Iter + 'a>;

diff --git a/src/lib.rs b/src/lib.rs
index 6d58274c4142f8a877420cd25561b78ebb9eb4e3..7d61f5b004f1f4898713c3f7afc0331f37529f6c 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,6 +1,7 @@
 mod compression;
 mod dupsort_func;
 mod entry;
+mod filter;
 mod iter;
 mod merge_func;
 mod merger;

diff --git a/src/merge_func.rs b/src/merge_func.rs
index 6fa1f01b9cb9cce820e4a003e34a2c34d52e0741..b8d847f7c536f2a2555434a306be7ee00e32ccb8 100644 (file)
--- a/src/merge_func.rs
+++ b/src/merge_func.rs
@@ -21,44 +21,43 @@ where
     F: Fn(&mut Vec<u8>, &Entry),
 {
     fn iter(&self) -> impl Iter {
-        MergeFuncIter {
-            prev: None,
-            iter: self.source.iter(),
-            merge_func: &self.merge_func,
-        }
+        self.source.iter().merge_func(&self.merge_func)
     }
     fn get(&self, key: &[u8]) -> impl Iter {
-        MergeFuncIter {
-            prev: None,
-            iter: self.source.get(key),
-            merge_func: &self.merge_func,
-        }
+        self.source.get(key).merge_func(&self.merge_func)
     }
     fn get_prefix(&self, prefix: &[u8]) -> impl Iter {
-        MergeFuncIter {
-            prev: None,
-            iter: self.source.get_prefix(prefix),
-            merge_func: &self.merge_func,
-        }
+        self.source.get_prefix(prefix).merge_func(&self.merge_func)
     }
     fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter {
-        MergeFuncIter {
-            prev: None,
-            iter: self.source.get_range(start, end),
-            merge_func: &self.merge_func,
-        }
+        self.source
+            .get_range(start, end)
+            .merge_func(&self.merge_func)
     }
 }
 
-struct MergeFuncIter<'a, I: Iter, F: Fn(&mut Vec<u8>, &Entry)> {
+pub struct MergeFuncIter<'a, I, F: Fn(&mut Vec<u8>, &Entry)> {
     prev: Option<Entry>,
     iter: I,
     merge_func: &'a F,
 }
 
+impl<'a, I, F> MergeFuncIter<'a, I, F>
+where
+    F: Fn(&mut Vec<u8>, &Entry),
+{
+    pub fn new(iter: I, merge_func: &'a F) -> Self {
+        Self {
+            prev: None,
+            iter,
+            merge_func,
+        }
+    }
+}
+
 impl<'a, I, F> Iterator for MergeFuncIter<'a, I, F>
 where
-    I: Iter,
+    I: Iterator<Item = Entry>,
     F: Fn(&mut Vec<u8>, &Entry),
 {
     type Item = Entry;

diff --git a/src/source.rs b/src/source.rs
index a9f73476cc19e2c9a38c521988c2b607339d2934..6d590b5f117bd69021bf6e05597252072eca2d89 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -1,4 +1,5 @@
 use crate::dupsort_func::DupsortFunc;
+use crate::filter::FilterSource;
 use crate::iter::{PrefixIter, RangeIter};
 use crate::merge_func::MergeFunc;
 use crate::{Entry, Iter};
@@ -30,6 +31,14 @@ pub trait Source {
     {
         DupsortFunc::new(self, dupsort_func)
     }
+
+    fn filter<F>(self, filter_func: F) -> FilterSource<Self, F>
+    where
+        Self: Sized,
+        F: Fn(&Entry, &mut dyn Iter) -> bool,
+    {
+        FilterSource::new(self, filter_func)
+    }
 }
 
 struct VecIter<'a> {