Entries::filter_seek -> Entries::filter

No longer need separate name due to Iterator co-implementation

diff --git a/src/iter.rs b/src/iter.rs
index e4155afeb4e1cae6509906ef9d3744fac7a653a7..56b4ad492bbbcfbac19a4a2c78e3e91b908f5ef7 100644 (file)
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -21,11 +21,11 @@ pub trait Entries: IntoIterator<Item = Entry> + Sized {
     }
 
     // provided methods
-    fn filter_seek<F>(self, filter: F) -> impl Entries
+    fn filter<F>(self, filter: F) -> impl Entries
     where
-        F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult,
+        F: FnMut(&Entry, &mut Vec<u8>) -> FilterAction,
     {
-        FilterSeek {
+        Filter {
             inner: self,
             filter_func: filter,
             seek_key: Vec::new(),
@@ -109,37 +109,37 @@ impl<I: Entries, O: Iterator<Item = Entry>> Entries for WrapIter<I, O> {
     }
 }
 
-// FilterSeek
+// Filter
 
-pub enum FilterSeekResult {
+pub enum FilterAction {
     Keep,
     Skip,
     Seek,
 }
-pub use FilterSeekResult::*;
+pub use FilterAction::*;
 
-struct FilterSeek<I: Entries, F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult> {
+struct Filter<I: Entries, F: FnMut(&Entry, &mut Vec<u8>) -> FilterAction> {
     inner: I,
     filter_func: F,
     seek_key: Vec<u8>,
 }
 
-impl<I, F> IntoIterator for FilterSeek<I, F>
+impl<I, F> IntoIterator for Filter<I, F>
 where
-    F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult,
+    F: FnMut(&Entry, &mut Vec<u8>) -> FilterAction,
     I: Entries<Item = Entry>,
 {
     type Item = Entry;
-    type IntoIter = Iter<FilterSeek<I, F>>;
+    type IntoIter = Iter<Filter<I, F>>;
 
     fn into_iter(self) -> Self::IntoIter {
         Iter(self)
     }
 }
 
-impl<I, F> Entries for FilterSeek<I, F>
+impl<I, F> Entries for Filter<I, F>
 where
-    F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult,
+    F: FnMut(&Entry, &mut Vec<u8>) -> FilterAction,
     I: Entries<Item = Entry>,
 {
     fn seek<T: AsRef<[u8]>>(&mut self, key: T) {
@@ -194,16 +194,16 @@ mod test {
     fn test_iter_filter() {
         let ti = TestIter(0);
         let v: Vec<Entry> = ti
-            .filter_seek(|e, k| {
+            .filter(|e, k| {
                 let b = e.key[0];
                 if b % 2 > 0 {
                     if b < 60 {
                         k.push((b + 1) * 4);
-                        return FilterSeekResult::Seek;
+                        return Seek;
                     }
-                    return FilterSeekResult::Skip;
+                    return Skip;
                 }
-                FilterSeekResult::Keep
+                Keep
             })
             .into_iter()
             .filter(|e| e.key[0] % 5 == 0)