From 90b85db05b271bc432c39db2a64bd9c7fae7fd27 Mon Sep 17 00:00:00 2001
From: Chris Mikkelson <chris@mikk.net>
Date: Thu, 3 Apr 2025 16:23:16 -0500
Subject: [PATCH] Rename Iter -> SeekableIter

---
 src/dupsort_func.rs | 20 ++++++++++----------
 src/filter.rs       | 28 ++++++++++++++--------------
 src/iter.rs         | 20 ++++++++++----------
 src/lib.rs          |  2 +-
 src/merge_func.rs   | 14 +++++++-------
 src/merger.rs       | 28 ++++++++++++++--------------
 src/reader/block.rs |  6 +++---
 src/reader/mod.rs   |  6 +++---
 src/source.rs       | 22 +++++++++++-----------
 9 files changed, 73 insertions(+), 73 deletions(-)

diff --git a/src/dupsort_func.rs b/src/dupsort_func.rs
index c029c29..a9b8b92 100644
--- a/src/dupsort_func.rs
+++ b/src/dupsort_func.rs
@@ -1,5 +1,5 @@
 use crate::entry::HasPrefix;
-use crate::{Iter, Source};
+use crate::{SeekableIter, Source};
 use std::cmp::Ordering;
 
 pub struct DupsortFunc<S, F>
@@ -31,16 +31,16 @@ where
     F: Fn(&S::Item, &S::Item) -> Ordering,
 {
     type Item = S::Item;
-    fn iter(&self) -> impl Iter<Item = Self::Item> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         self.source.iter().dupsort_func(&self.dupsort_func)
     }
-    fn get(&self, key: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get(&self, key: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         S::Item: PartialOrd<[u8]>,
     {
         self.source.get(key).dupsort_func(&self.dupsort_func)
     }
-    fn get_prefix(&self, prefix: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get_prefix(&self, prefix: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         S::Item: HasPrefix,
     {
@@ -48,7 +48,7 @@ where
             .get_prefix(prefix)
             .dupsort_func(&self.dupsort_func)
     }
-    fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get_range(&self, start: &[u8], end: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         S::Item: PartialOrd<[u8]>,
     {
@@ -61,7 +61,7 @@ where
 #[derive(Debug)]
 pub struct DupsortFuncIter<'a, I, F>
 where
-    I: Iter,
+    I: SeekableIter,
     F: Fn(&I::Item, &I::Item) -> Ordering,
 {
     run: Vec<I::Item>,
@@ -72,7 +72,7 @@ where
 
 impl<'a, I, F> DupsortFuncIter<'a, I, F>
 where
-    I: Iter,
+    I: SeekableIter,
     F: Fn(&I::Item, &I::Item) -> Ordering,
 {
     pub fn new(iter: I, dupsort_func: &'a F) -> Self {
@@ -87,7 +87,7 @@ where
 
 impl<'a, I, F> Iterator for DupsortFuncIter<'a, I, F>
 where
-    I: Iter,
+    I: SeekableIter,
     I::Item: PartialEq,
     F: Fn(&I::Item, &I::Item) -> Ordering,
 {
@@ -115,9 +115,9 @@ where
     }
 }
 
-impl<'a, I, F> Iter for DupsortFuncIter<'a, I, F>
+impl<'a, I, F> SeekableIter for DupsortFuncIter<'a, I, F>
 where
-    I: Iter,
+    I: SeekableIter,
     I::Item: PartialEq,
     F: Fn(&I::Item, &I::Item) -> Ordering,
 {
diff --git a/src/filter.rs b/src/filter.rs
index eb31ee1..459c50f 100644
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -1,4 +1,4 @@
-use crate::{entry::HasPrefix, Iter, Source};
+use crate::{entry::HasPrefix, SeekableIter, Source};
 
 pub struct FilterIter<'a, I, F> {
     iter: I,
@@ -7,8 +7,8 @@ pub struct FilterIter<'a, I, F> {
 
 impl<'a, I, F> FilterIter<'a, I, F>
 where
-    I: Iter,
-    F: Fn(&I::Item, &mut dyn Iter<Item = I::Item>) -> bool,
+    I: SeekableIter,
+    F: Fn(&I::Item, &mut dyn SeekableIter<Item = I::Item>) -> bool,
 {
     pub fn new(iter: I, filter_func: &'a F) -> Self {
         Self { iter, filter_func }
@@ -17,8 +17,8 @@ where
 
 impl<'a, I, F> Iterator for FilterIter<'a, I, F>
 where
-    I: Iter,
-    F: Fn(&I::Item, &mut dyn Iter<Item = I::Item>) -> bool,
+    I: SeekableIter,
+    F: Fn(&I::Item, &mut dyn SeekableIter<Item = I::Item>) -> bool,
 {
     type Item = I::Item;
 
@@ -32,10 +32,10 @@ where
     }
 }
 
-impl<'a, I, F> Iter for FilterIter<'a, I, F>
+impl<'a, I, F> SeekableIter for FilterIter<'a, I, F>
 where
-    I: Iter,
-    F: Fn(&I::Item, &mut dyn Iter<Item = I::Item>) -> bool,
+    I: SeekableIter,
+    F: Fn(&I::Item, &mut dyn SeekableIter<Item = I::Item>) -> bool,
 {
     fn seek(&mut self, key: &[u8]) {
         self.iter.seek(key);
@@ -50,7 +50,7 @@ pub struct FilterSource<S, F> {
 impl<S, F> FilterSource<S, F>
 where
     S: Source,
-    F: Fn(&S::Item, &mut dyn Iter<Item = S::Item>) -> bool,
+    F: Fn(&S::Item, &mut dyn SeekableIter<Item = S::Item>) -> bool,
 {
     pub fn new(source: S, filter_func: F) -> Self {
         Self {
@@ -63,21 +63,21 @@ where
 impl<S, F> Source for FilterSource<S, F>
 where
     S: Source,
-    F: Fn(&S::Item, &mut dyn Iter<Item = S::Item>) -> bool,
+    F: Fn(&S::Item, &mut dyn SeekableIter<Item = S::Item>) -> bool,
 {
     type Item = S::Item;
-    fn iter(&self) -> impl Iter<Item = Self::Item> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         self.source.iter().filter_func(&self.filter_func)
     }
 
-    fn get(&self, key: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get(&self, key: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         Self::Item: PartialOrd<[u8]>,
     {
         self.source.get(key).filter_func(&self.filter_func)
     }
 
-    fn get_prefix(&self, prefix: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get_prefix(&self, prefix: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         Self::Item: HasPrefix,
     {
@@ -86,7 +86,7 @@ where
             .filter_func(&self.filter_func)
     }
 
-    fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get_range(&self, start: &[u8], end: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         Self::Item: PartialOrd<[u8]>,
     {
diff --git a/src/iter.rs b/src/iter.rs
index d47fa06..0a7209c 100644
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -6,7 +6,7 @@ use crate::Entry;
 use std::cmp::Ordering;
 use std::iter::Iterator;
 
-pub trait Iter: Iterator {
+pub trait SeekableIter: Iterator {
     fn seek(&mut self, key: &[u8]);
 
     fn merge_func<'a, F>(self, merge_func: &'a F) -> MergeFuncIter<'a, Self, F>
@@ -27,7 +27,7 @@ pub trait Iter: Iterator {
 
     fn filter_func<'a, F>(self, filter_func: &'a F) -> FilterIter<'a, Self, F>
     where
-        F: Fn(&Self::Item, &mut dyn Iter<Item = Self::Item>) -> bool,
+        F: Fn(&Self::Item, &mut dyn SeekableIter<Item = Self::Item>) -> bool,
         Self: Sized,
     {
         FilterIter::new(self, filter_func)
@@ -41,7 +41,7 @@ pub struct PrefixIter<I> {
 
 impl<E, I> PrefixIter<I>
 where
-    I: Iter<Item = E>,
+    I: SeekableIter<Item = E>,
     E: HasPrefix,
 {
     pub fn new(mut iter: I, prefix: impl AsRef<[u8]>) -> Self {
@@ -55,7 +55,7 @@ where
 
 impl<E, I> Iterator for PrefixIter<I>
 where
-    I: Iter<Item = E>,
+    I: SeekableIter<Item = E>,
     E: HasPrefix,
 {
     type Item = E;
@@ -69,9 +69,9 @@ where
     }
 }
 
-impl<E, I> Iter for PrefixIter<I>
+impl<E, I> SeekableIter for PrefixIter<I>
 where
-    I: Iter<Item = E>,
+    I: SeekableIter<Item = E>,
     E: HasPrefix,
 {
     fn seek(&mut self, key: &[u8]) {
@@ -85,7 +85,7 @@ pub struct RangeIter<I> {
     end: Vec<u8>,
 }
 
-impl<I: Iter> RangeIter<I> {
+impl<I: SeekableIter> RangeIter<I> {
     pub fn new(mut iter: I, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> Self {
         iter.seek(start.as_ref());
         Self {
@@ -98,7 +98,7 @@ impl<I: Iter> RangeIter<I> {
 
 impl<E, I> Iterator for RangeIter<I>
 where
-    I: Iter<Item = E>,
+    I: SeekableIter<Item = E>,
     E: PartialOrd<[u8]>,
 {
     type Item = E;
@@ -112,9 +112,9 @@ where
     }
 }
 
-impl<E, I> Iter for RangeIter<I>
+impl<E, I> SeekableIter for RangeIter<I>
 where
-    I: Iter<Item = E>,
+    I: SeekableIter<Item = E>,
     E: PartialOrd<[u8]>,
 {
     fn seek(&mut self, key: &[u8]) {
diff --git a/src/lib.rs b/src/lib.rs
index f9b4240..5a56711 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,7 +13,7 @@ mod writer;
 pub use compression::Compression;
 pub use entry::Entry;
 pub use fileset::Fileset;
-pub use iter::Iter;
+pub use iter::SeekableIter;
 pub use merger::Merger;
 pub use reader::Reader;
 pub use source::Source;
diff --git a/src/merge_func.rs b/src/merge_func.rs
index c0800ea..7f55bd6 100644
--- a/src/merge_func.rs
+++ b/src/merge_func.rs
@@ -1,4 +1,4 @@
-use crate::{Entry, Iter, Source};
+use crate::{Entry, SeekableIter, Source};
 
 pub struct MergeFunc<S: Source, F: Fn(&mut Vec<u8>, &Entry)> {
     source: S,
@@ -21,16 +21,16 @@ where
     F: Fn(&mut Vec<u8>, &Entry),
 {
     type Item = Entry;
-    fn iter(&self) -> impl Iter<Item = Self::Item> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         self.source.iter().merge_func(&self.merge_func)
     }
-    fn get(&self, key: &[u8]) -> impl Iter<Item = Self::Item> {
+    fn get(&self, key: &[u8]) -> impl SeekableIter<Item = Self::Item> {
         self.source.get(key).merge_func(&self.merge_func)
     }
-    fn get_prefix(&self, prefix: &[u8]) -> impl Iter<Item = Self::Item> {
+    fn get_prefix(&self, prefix: &[u8]) -> impl SeekableIter<Item = Self::Item> {
         self.source.get_prefix(prefix).merge_func(&self.merge_func)
     }
-    fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter<Item = Self::Item> {
+    fn get_range(&self, start: &[u8], end: &[u8]) -> impl SeekableIter<Item = Self::Item> {
         self.source
             .get_range(start, end)
             .merge_func(&self.merge_func)
@@ -76,9 +76,9 @@ where
     }
 }
 
-impl<'a, I, F> Iter for MergeFuncIter<'a, I, F>
+impl<'a, I, F> SeekableIter for MergeFuncIter<'a, I, F>
 where
-    I: Iter<Item = Entry>,
+    I: SeekableIter<Item = Entry>,
     F: Fn(&mut Vec<u8>, &Entry),
 {
     fn seek(&mut self, key: &[u8]) {
diff --git a/src/merger.rs b/src/merger.rs
index 8d54303..3c99c1a 100644
--- a/src/merger.rs
+++ b/src/merger.rs
@@ -1,4 +1,4 @@
-use crate::{Entry, Iter, Source};
+use crate::{Entry, SeekableIter, Source};
 use std::cmp::Ordering;
 use std::collections::BinaryHeap;
 
@@ -17,31 +17,31 @@ where
     }
 }
 
-struct MergeEntry<I: Iter> {
+struct MergeEntry<I: SeekableIter> {
     e: Entry,
     it: I,
 }
 
-impl<I: Iter> PartialEq for MergeEntry<I> {
+impl<I: SeekableIter> PartialEq for MergeEntry<I> {
     fn eq(&self, other: &Self) -> bool {
         self.e.key() == other.e.key()
     }
 }
-impl<I: Iter> Eq for MergeEntry<I> {}
+impl<I: SeekableIter> Eq for MergeEntry<I> {}
 
-impl<I: Iter> PartialOrd for MergeEntry<I> {
+impl<I: SeekableIter> PartialOrd for MergeEntry<I> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(other.e.key().cmp(&self.e.key()))
     }
 }
 
-impl<I: Iter> Ord for MergeEntry<I> {
+impl<I: SeekableIter> Ord for MergeEntry<I> {
     fn cmp(&self, other: &Self) -> Ordering {
         other.e.key().cmp(&self.e.key())
     }
 }
 
-pub struct MergeIter<I: Iter> {
+pub struct MergeIter<I: SeekableIter> {
     heap: BinaryHeap<MergeEntry<I>>,
     finished: Vec<I>,
     last_key: Vec<u8>,
@@ -50,7 +50,7 @@ pub struct MergeIter<I: Iter> {
 impl<I> From<I> for MergeIter<I::Item>
 where
     I: Iterator,
-    I::Item: Iter<Item = Entry>,
+    I::Item: SeekableIter<Item = Entry>,
 {
     fn from(iters: I) -> Self {
         let mut v: Vec<I::Item> = Vec::new();
@@ -69,7 +69,7 @@ where
     }
 }
 
-impl<I: Iter<Item = Entry>> Iterator for MergeIter<I> {
+impl<I: SeekableIter<Item = Entry>> Iterator for MergeIter<I> {
     type Item = Entry;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -89,7 +89,7 @@ impl<I: Iter<Item = Entry>> Iterator for MergeIter<I> {
     }
 }
 
-impl<I: Iter<Item = Entry>> Iter for MergeIter<I> {
+impl<I: SeekableIter<Item = Entry>> SeekableIter for MergeIter<I> {
     fn seek(&mut self, key: &[u8]) {
         if key > self.last_key.as_slice() {
             loop {
@@ -136,19 +136,19 @@ impl<I: Iter<Item = Entry>> Iter for MergeIter<I> {
 
 impl<S: Source<Item = Entry>> Source for Merger<S> {
     type Item = Entry;
-    fn iter(&self) -> impl Iter<Item = Self::Item> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         MergeIter::from(self.sources.iter().map(|s| s.iter()))
     }
 
-    fn get(&self, key: &[u8]) -> impl Iter<Item = Self::Item> {
+    fn get(&self, key: &[u8]) -> impl SeekableIter<Item = Self::Item> {
         MergeIter::from(self.sources.iter().map(|s| s.get(key)))
     }
 
-    fn get_prefix(&self, prefix: &[u8]) -> impl Iter<Item = Self::Item> {
+    fn get_prefix(&self, prefix: &[u8]) -> impl SeekableIter<Item = Self::Item> {
         MergeIter::from(self.sources.iter().map(|s| s.get_prefix(prefix)))
     }
 
-    fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter<Item = Self::Item> {
+    fn get_range(&self, start: &[u8], end: &[u8]) -> impl SeekableIter<Item = Self::Item> {
         MergeIter::from(self.sources.iter().map(|s| s.get_range(start, end)))
     }
 }
diff --git a/src/reader/block.rs b/src/reader/block.rs
index b6abaad..0563108 100644
--- a/src/reader/block.rs
+++ b/src/reader/block.rs
@@ -1,4 +1,4 @@
-use crate::{Entry, Iter, Result};
+use crate::{Entry, Result, SeekableIter};
 use integer_encoding::VarInt;
 use std::mem::size_of;
 
@@ -189,7 +189,7 @@ impl<D: AsRef<[u8]>> Iterator for BlockIter<D> {
     }
 }
 
-impl<D: AsRef<[u8]>> Iter for BlockIter<D> {
+impl<D: AsRef<[u8]>> SeekableIter for BlockIter<D> {
     fn seek(&mut self, key: &[u8]) {
         // TODO: "galloping search"
         if self.block.restart_count > 0 {
@@ -216,7 +216,7 @@ mod test {
     use crate::reader::block::Block;
     use crate::writer::block_builder::BlockBuilder;
     use crate::Entry;
-    use crate::Iter;
+    use crate::SeekableIter;
 
     fn build_block(n: u32, skip: u32, r: usize) -> Block<Vec<u8>> {
         let mut bb = BlockBuilder::default();
diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index 8a1568c..4ba0d7e 100644
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -1,6 +1,6 @@
 use crate::metadata::Metadata;
 use crate::Source;
-use crate::{Entry, Iter};
+use crate::{Entry, SeekableIter};
 use integer_encoding::VarInt;
 pub(crate) mod block;
 use crate::compression::CBuf;
@@ -155,7 +155,7 @@ impl<D: AsRef<[u8]>> Iterator for ReaderIter<D> {
     }
 }
 
-impl<D: AsRef<[u8]>> Iter for ReaderIter<D> {
+impl<D: AsRef<[u8]>> SeekableIter for ReaderIter<D> {
     fn seek(&mut self, key: &[u8]) {
         // TODO: detect and skip unneeded seek in iter.
         self.index_iter.seek(key);
@@ -179,7 +179,7 @@ impl<D: AsRef<[u8]>> Iter for ReaderIter<D> {
 impl<D: AsRef<[u8]>> Source for Reader<D> {
     type Item = Entry;
 
-    fn iter(&self) -> impl Iter<Item = Self::Item> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         ReaderIter {
             reader: self.clone(),
             next_offset: 0,
diff --git a/src/source.rs b/src/source.rs
index 55e0317..c7c6c00 100644
--- a/src/source.rs
+++ b/src/source.rs
@@ -3,25 +3,25 @@ use crate::entry::HasPrefix;
 use crate::filter::FilterSource;
 use crate::iter::{PrefixIter, RangeIter};
 use crate::merge_func::MergeFunc;
-use crate::{Entry, Iter};
+use crate::{Entry, SeekableIter};
 
 pub trait Source {
     type Item;
 
-    fn iter(&self) -> impl Iter<Item = Self::Item>;
-    fn get(&self, key: &[u8]) -> impl Iter<Item = Self::Item>
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item>;
+    fn get(&self, key: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         Self::Item: PartialOrd<[u8]>,
     {
         RangeIter::new(self.iter(), key, key)
     }
-    fn get_prefix(&self, prefix: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get_prefix(&self, prefix: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         Self::Item: HasPrefix,
     {
         PrefixIter::new(self.iter(), prefix)
     }
-    fn get_range(&self, start: &[u8], end: &[u8]) -> impl Iter<Item = Self::Item>
+    fn get_range(&self, start: &[u8], end: &[u8]) -> impl SeekableIter<Item = Self::Item>
     where
         Self::Item: PartialOrd<[u8]>,
     {
@@ -47,7 +47,7 @@ pub trait Source {
     fn filter<F>(self, filter_func: F) -> FilterSource<Self, F>
     where
         Self: Sized,
-        F: Fn(&Self::Item, &mut dyn Iter<Item = Self::Item>) -> bool,
+        F: Fn(&Self::Item, &mut dyn SeekableIter<Item = Self::Item>) -> bool,
     {
         FilterSource::new(self, filter_func)
     }
@@ -71,7 +71,7 @@ impl<'a> Iterator for VecIter<'a> {
     }
 }
 
-impl<'a> Iter for VecIter<'a> {
+impl<'a> SeekableIter for VecIter<'a> {
     fn seek(&mut self, key: &[u8]) {
         let mut left = 0;
         let mut right = self.vec.len() - 1;
@@ -89,7 +89,7 @@ impl<'a> Iter for VecIter<'a> {
 
 impl Source for Vec<Entry> {
     type Item = Entry;
-    fn iter(&self) -> impl Iter<Item = Self::Item> {
+    fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
         VecIter {
             index: 0,
             vec: self,
@@ -100,7 +100,7 @@ impl Source for Vec<Entry> {
 #[cfg(test)]
 pub mod test_source {
     use crate::Entry;
-    use crate::Iter;
+    use crate::SeekableIter;
     use crate::Source;
 
     pub struct TestSource(pub Vec<Entry>);
@@ -124,7 +124,7 @@ pub mod test_source {
         }
     }
 
-    impl<'a> Iter for TestIter<'a> {
+    impl<'a> SeekableIter for TestIter<'a> {
         fn seek(&mut self, key: &[u8]) {
             self.off = 0;
             while self.off < self.source.0.len() && self.source.0[self.off].key() < key {
@@ -135,7 +135,7 @@ pub mod test_source {
 
     impl Source for TestSource {
         type Item = Entry;
-        fn iter(&self) -> impl Iter<Item = Self::Item> {
+        fn iter(&self) -> impl SeekableIter<Item = Self::Item> {
             TestIter {
                 source: self,
                 off: 0,
-- 
2.50.1