From: Chris Mikkelson <cmikk@fsi.io>
Date: Sun, 28 Jul 2024 18:23:12 +0000 (-0500)
Subject: Rename GenericSource -> BoxedSource
X-Git-Url: https://git.mikk.net/?a=commitdiff_plain;h=a7e5e85f9de0306af31fc27de7e97d310d098cc9;p=mtbl-rs

Rename GenericSource -> BoxedSource
---

diff --git a/src/source.rs b/src/source.rs
index 0c76f64..4e25abc 100644
--- a/src/source.rs
+++ b/src/source.rs
@@ -6,7 +6,9 @@ pub trait Iter: Iterator<Item = Entry> {
     fn seek(&mut self, key: &[u8]);
 }
 
-impl<'a> Iter for Box<dyn Iter + 'a> {
+type BoxedIter<'a> = Box<dyn Iter + 'a>;
+
+impl<'a> Iter for BoxedIter<'a> {
     fn seek(&mut self, key: &[u8]) {
         self.as_mut().seek(key);
     }
@@ -117,57 +119,56 @@ impl<I: Iter> Iter for RangeIter<I> {
     }
 }
 
-pub type GenIter<'a> = Box<dyn Iter + 'a>;
 trait GenSource<'a>:
-    Source<It = GenIter<'a>, Get = GenIter<'a>, Prefix = GenIter<'a>, Range = GenIter<'a>> + 'a
+    Source<It = BoxedIter<'a>, Get = BoxedIter<'a>, Prefix = BoxedIter<'a>, Range = BoxedIter<'a>> + 'a
 {
 }
 
 struct GenWrap<'a, S: Source + 'a>(S, PhantomData<&'a S>);
 impl<'a, S: Source + 'a> IterSource for GenWrap<'a, S> {
-    type It = GenIter<'a>;
+    type It = BoxedIter<'a>;
     fn iter(&self) -> Self::It {
         Box::new(self.0.iter())
     }
 }
 impl<'a, S: Source + 'a> Source for GenWrap<'a, S> {
-    type Get = GenIter<'a>;
+    type Get = BoxedIter<'a>;
     fn get(&self, key: &[u8]) -> Self::Get {
         Box::new(self.0.get(key))
     }
-    type Prefix = GenIter<'a>;
+    type Prefix = BoxedIter<'a>;
     fn get_prefix(&self, prefix: &[u8]) -> Self::Get {
         Box::new(self.0.get_prefix(prefix))
     }
-    type Range = GenIter<'a>;
+    type Range = BoxedIter<'a>;
     fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Get {
         Box::new(self.0.get_range(start, end))
     }
 }
 impl<'a, S: Source + 'a> GenSource<'a> for GenWrap<'a, S> {}
 
-pub struct GenericSource<'a>(Box<dyn GenSource<'a>>);
-impl<'a> GenericSource<'a> {
+pub struct BoxedSource<'a>(Box<dyn GenSource<'a>>);
+impl<'a> BoxedSource<'a> {
     fn from<S: Source + 'a>(source: S) -> Self {
         Self(Box::new(GenWrap(source, PhantomData)))
     }
 }
-impl<'a> IterSource for GenericSource<'a> {
-    type It = GenIter<'a>;
+impl<'a> IterSource for BoxedSource<'a> {
+    type It = BoxedIter<'a>;
     fn iter(&self) -> Self::It {
         self.0.as_ref().iter()
     }
 }
-impl<'a> Source for GenericSource<'a> {
-    type Get = GenIter<'a>;
+impl<'a> Source for BoxedSource<'a> {
+    type Get = BoxedIter<'a>;
     fn get(&self, key: &[u8]) -> Self::Get {
         self.0.get(key)
     }
-    type Prefix = GenIter<'a>;
+    type Prefix = BoxedIter<'a>;
     fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
         self.0.get_prefix(prefix)
     }
-    type Range = GenIter<'a>;
+    type Range = BoxedIter<'a>;
     fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Prefix {
         self.0.get_range(start, end)
     }
@@ -175,7 +176,7 @@ impl<'a> Source for GenericSource<'a> {
 
 #[cfg(test)]
 pub mod test {
-    use super::{DefaultSource, Entry, GenericSource, Iter, IterSource, Source};
+    use super::{BoxedSource, DefaultSource, Entry, Iter, IterSource, Source};
 
     pub struct TestSource(pub Vec<Entry>);
 
@@ -257,7 +258,7 @@ pub mod test {
     #[test]
     fn test_generic_source_iter() {
         let ts = test_source();
-        let s = GenericSource::from(&ts);
+        let s = BoxedSource::from(&ts);
 
         assert_eq!(
             Vec::from_iter(s.iter().map(|e| e.value[0])),
@@ -284,9 +285,9 @@ pub mod test {
     fn test_dyn_source() {
         use crate::merger::Merger;
         let ts = test_source();
-        let mut v = Vec::<GenericSource>::new();
-        v.push(GenericSource::from(&ts));
-        v.push(GenericSource::from(&ts));
+        let mut v = Vec::<BoxedSource>::new();
+        v.push(BoxedSource::from(&ts));
+        v.push(BoxedSource::from(&ts));
         let mut refv = Vec::<Entry>::from_iter((&ts).iter().chain((&ts).iter()));
         refv.sort_by(|a, b| a.key.as_ref().cmp(b.key.as_ref()));
         let gs = Merger::from(v);