Iter -> Entries, prep for Iter: IntoIterator

diff --git a/src/iter.rs b/src/iter.rs
index c774aa8dc957407ef03504cde325455f844ff447..c95f8445c1784ab8fded79df94975bd399aea765 100644 (file)
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -3,13 +3,13 @@ use std::cell::RefCell;
 use std::iter::Iterator;
 use std::rc::Rc;
 
-pub trait Iter: Iterator<Item = Entry> + Sized {
+pub trait Entries: Iterator<Item = Entry> + Sized {
     fn seek<T: AsRef<[u8]>>(&mut self, key: T);
 
     fn wrap_iter<F: FnOnce(IterCell<Self>) -> O, O: Iterator<Item = Entry>>(
         self,
         f: F,
-    ) -> impl Iter {
+    ) -> impl Entries {
         let it = IterCell::new(self);
         WrapIter {
             inner: it.clone(),
@@ -18,7 +18,7 @@ pub trait Iter: Iterator<Item = Entry> + Sized {
     }
 
     // provided methods
-    fn filter_seek<F>(self, filter: F) -> impl Iter
+    fn filter_seek<F>(self, filter: F) -> impl Entries
     where
         F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult,
     {
@@ -32,23 +32,23 @@ pub trait Iter: Iterator<Item = Entry> + Sized {
 
 // WrapIter
 
-pub struct IterCell<I: Iter> {
+pub struct IterCell<I: Entries> {
     ic: Rc<RefCell<I>>
 }
 
-impl<I: Iter> Clone for IterCell<I> {
+impl<I: Entries> Clone for IterCell<I> {
     fn clone(&self) -> Self {
         IterCell{ic: self.ic.clone()}
     }
 }
 
-impl<I: Iter> IterCell<I> {
+impl<I: Entries> IterCell<I> {
     fn new(i: I) -> IterCell<I> {
         IterCell{ic: Rc::new(RefCell::new(i))}
     }
 }
 
-impl<I: Iter> Iterator for IterCell<I> {
+impl<I: Entries> Iterator for IterCell<I> {
     type Item = Entry;
 
     fn next(&mut self) -> Option<Entry> {
@@ -56,19 +56,19 @@ impl<I: Iter> Iterator for IterCell<I> {
     }
 }
 
-impl<I: Iter> Iter for IterCell<I> {
+impl<I: Entries> Entries for IterCell<I> {
     fn seek<T: AsRef<[u8]>>(&mut self, key: T) {
         self.ic.borrow_mut().seek(key);
     }
 }
 
 
-struct WrapIter<I: Iter, O: Iterator<Item = Entry>> {
+struct WrapIter<I: Entries, O: Iterator<Item = Entry>> {
     inner: IterCell<I>,
     outer: O,
 }
 
-impl<I: Iter, O: Iterator<Item = Entry>> Iterator for WrapIter<I, O> {
+impl<I: Entries, O: Iterator<Item = Entry>> Iterator for WrapIter<I, O> {
     type Item = Entry;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -76,7 +76,7 @@ impl<I: Iter, O: Iterator<Item = Entry>> Iterator for WrapIter<I, O> {
     }
 }
 
-impl<I: Iter, O: Iterator<Item = Entry>> Iter for WrapIter<I, O> {
+impl<I: Entries, O: Iterator<Item = Entry>> Entries for WrapIter<I, O> {
     fn seek<T: AsRef<[u8]>>(&mut self, key: T) {
         self.inner.seek(key)
     }
@@ -100,7 +100,7 @@ struct FilterSeek<I: Iterator<Item = Entry>, F: FnMut(&Entry, &mut Vec<u8>) -> F
 impl<I, F> Iterator for FilterSeek<I, F>
 where
     F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult,
-    I: Iter<Item = Entry>,
+    I: Entries<Item = Entry>,
 {
     type Item = Entry;
 
@@ -117,10 +117,10 @@ where
     }
 }
 
-impl<I, F> Iter for FilterSeek<I, F>
+impl<I, F> Entries for FilterSeek<I, F>
 where
     F: FnMut(&Entry, &mut Vec<u8>) -> FilterSeekResult,
-    I: Iter<Item = Entry>,
+    I: Entries<Item = Entry>,
 {
     fn seek<T: AsRef<[u8]>>(&mut self, key: T) {
         self.inner.seek(key.as_ref());
@@ -148,7 +148,7 @@ mod test {
         }
     }
 
-    impl Iter for TestIter {
+    impl Entries for TestIter {
         fn seek<T: AsRef<[u8]>>(&mut self, kr: T) {
             self.0 = kr.as_ref()[0];
         }