WIP #2 - Remove Item associated type from Source

diff --git a/src/dupsort.rs b/src/dupsort.rs
index 7905ce3410d673cf28b1385cb514842d50b0f0c2..f0a53ef1658c5cf0641fb3f4dda4f1720b7f3055 100644 (file)
--- a/src/dupsort.rs
+++ b/src/dupsort.rs
@@ -5,7 +5,7 @@ use std::marker::PhantomData;
 pub struct DupsortSource<'a, S, F>
 where
     S: Source<'a>,
-    F: Fn(&S::Item, &S::Item) -> Ordering,
+    F: Fn(&<S::Iter as Iterator>::Item, &<S::Iter as Iterator>::Item) -> Ordering,
 {
     source: S,
     dupsort_func: F,
@@ -15,7 +15,7 @@ where
 impl<'a, S, F> DupsortSource<'a, S, F>
 where
     S: Source<'a>,
-    F: Fn(&S::Item, &S::Item) -> Ordering,
+    F: Fn(&<S::Iter as Iterator>::Item, &<S::Iter as Iterator>::Item) -> Ordering,
 {
     pub fn new(source: S, dupsort_func: F) -> Self {
         Self {
@@ -29,11 +29,10 @@ where
 impl<'a, S, F> Source<'a> for DupsortSource<'a, S, F>
 where
     S: Source<'a>,
-    S::Item: PartialEq,
-    F: Fn(&S::Item, &S::Item) -> Ordering + 'a,
+    <S::Iter as Iterator>::Item: PartialEq,
+    F: Fn(&<S::Iter as Iterator>::Item, &<S::Iter as Iterator>::Item) -> Ordering + 'a,
 {
     type Iter = DupsortIter<S::Iter, &'a F>;
-    type Item = S::Item;
 
     fn iter(&'a self) -> Self::Iter {
         self.source.iter().dupsort_func(&self.dupsort_func)

diff --git a/src/filter.rs b/src/filter.rs
index 8f02f8c2075857ccd38286e17ecf53d7ab3536b6..f0ccd5eae94dc47813bc18f55719c5d8d47b7975 100644 (file)
--- a/src/filter.rs
+++ b/src/filter.rs
@@ -62,7 +62,7 @@ pub struct FilterSource<'a, S, F> {
 impl<'a, S, F> FilterSource<'a, S, F>
 where
     S: Source<'a>,
-    F: Fn(&S::Item, &mut Vec<u8>) -> bool,
+    F: Fn(&<S::Iter as Iterator>::Item, &mut Vec<u8>) -> bool,
 {
     pub fn new(source: S, filter_func: F) -> Self {
         Self {
@@ -76,10 +76,9 @@ where
 impl<'a, S, F> Source<'a> for FilterSource<'a, S, F>
 where
     S: Source<'a>,
-    F: Fn(&S::Item, &mut Vec<u8>) -> bool + 'a,
+    F: Fn(&<S::Iter as Iterator>::Item, &mut Vec<u8>) -> bool + 'a,
 {
     type Iter = FilterIter<S::Iter, &'a F>;
-    type Item = S::Item;
     fn iter(&'a self) -> Self::Iter {
         self.source.iter().filter_func(&self.filter_func)
     }

diff --git a/src/iter.rs b/src/iter.rs
index 9152683bab3e4511b54be2979596f9c9bfe25fbe..080e9c2c2689edee9a2958e1028156b1c5355f58 100644 (file)
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -95,7 +95,6 @@ pub struct RangeIter<I> {
 impl<I> RangeIter<I>
 where
     I: SeekableIter,
-    I::Item: AsRef<[u8]>,
 {
     pub fn new(mut iter: I, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> Self {
         iter.seek(start.as_ref());

diff --git a/src/merge.rs b/src/merge.rs
index 3abcb3d4322267d3fe5fb59d9b1c769ee57ea4b7..567c2d99160315b50af7090397a6c96a3a8bd8b2 100644 (file)
--- a/src/merge.rs
+++ b/src/merge.rs
@@ -23,11 +23,11 @@ where
 
 impl<'a, S, F> Source<'a> for MergeSource<'a, S, F>
 where
-    S: Source<'a, Item = Entry>,
+    S: Source<'a>,
+    S::Iter: Iterator<Item = Entry>,
     F: Fn(&mut Vec<u8>, &Entry) + 'a,
 {
     type Iter = MergeIter<S::Iter, &'a F>;
-    type Item = Entry;
     fn iter(&'a self) -> Self::Iter {
         self.source.iter().merge_func(&self.merge_func)
     }

diff --git a/src/merger.rs b/src/merger.rs
index 4b65716205db17a74960f15964f59c15caef553a..7fb405fb26ec28d3e3782b3d4ffd352215201280 100644 (file)
--- a/src/merger.rs
+++ b/src/merger.rs
@@ -136,9 +136,9 @@ impl<I: SeekableIter<Item = Entry>> SeekableIter for MergeIter<I> {
 
 impl<'a, S> Source<'a> for Merger<S>
 where
-    S: Source<'a, Item = Entry>,
+    S: Source<'a>,
+    S::Iter: Iterator<Item = Entry>,
 {
-    type Item = Entry;
     type Iter = MergeIter<S::Iter>;
     fn iter(&'a self) -> Self::Iter {
         MergeIter::from(self.sources.iter().map(|s| s.iter()))
@@ -168,7 +168,7 @@ mod test {
         let iters: Vec<_> = range
             .clone()
             .map(test_source)
-            .map(|s| s.into_boxed())
+            //.map(|s| s.into_boxed())
             .collect();
         let s = Merger::from(iters);
         let mut v = Vec::<u8>::new();

diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index e5659a31d3aa9ff0a6a3438e9a726ea8e6de29ec..0b5ad43059c658fb1005f6b7465f28b0d96ecbf5 100644 (file)
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -177,7 +177,6 @@ impl<D: AsRef<[u8]>> SeekableIter for ReaderIter<D> {
 }
 
 impl<'a, D: AsRef<[u8]>> Source<'a> for Reader<D> {
-    type Item = Entry;
     type Iter = ReaderIter<D>;
 
     fn iter(&'a self) -> Self::Iter {

diff --git a/src/source.rs b/src/source.rs
index da59f93a940b60a5011c7dcc3727a5438076f622..a785fceb27a28c8964e05b265710c1a9055c317b 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -5,17 +5,25 @@ use crate::merge::MergeSource;
 use crate::{Entry, SeekableIter};
 
 pub trait Source<'a> {
-    type Iter: SeekableIter<Item = Self::Item>;
-    type Item: AsRef<[u8]>;
+    type Iter: SeekableIter;
 
     fn iter(&'a self) -> Self::Iter;
-    fn get(&'a self, key: &[u8]) -> RangeIter<Self::Iter> {
+    fn get(&'a self, key: &[u8]) -> RangeIter<Self::Iter>
+    where
+        <Self::Iter as Iterator>::Item: PartialOrd<[u8]>,
+    {
         RangeIter::new(self.iter(), key, key)
     }
-    fn get_prefix(&'a self, prefix: &[u8]) -> PrefixIter<Self::Iter> {
+    fn get_prefix(&'a self, prefix: &[u8]) -> PrefixIter<Self::Iter>
+    where
+        <Self::Iter as Iterator>::Item: AsRef<[u8]>,
+    {
         PrefixIter::new(self.iter(), prefix)
     }
-    fn get_range(&'a self, start: &[u8], end: &[u8]) -> RangeIter<Self::Iter> {
+    fn get_range(&'a self, start: &[u8], end: &[u8]) -> RangeIter<Self::Iter>
+    where
+        <Self::Iter as Iterator>::Item: PartialOrd<[u8]>,
+    {
         RangeIter::new(self.iter(), start, end)
     }
 
@@ -30,7 +38,10 @@ pub trait Source<'a> {
     fn dupsort_func<F>(self, dupsort_func: F) -> DupsortSource<'a, Self, F>
     where
         Self: Sized,
-        F: Fn(&Self::Item, &Self::Item) -> std::cmp::Ordering,
+        F: Fn(
+            &<Self::Iter as Iterator>::Item,
+            &<Self::Iter as Iterator>::Item,
+        ) -> std::cmp::Ordering,
     {
         DupsortSource::new(self, dupsort_func)
     }
@@ -38,7 +49,7 @@ pub trait Source<'a> {
     fn filter<F>(self, filter_func: F) -> FilterSource<'a, Self, F>
     where
         Self: Sized,
-        F: Fn(&Self::Item, &mut Vec<u8>) -> bool,
+        F: Fn(&<Self::Iter as Iterator>::Item, &mut Vec<u8>) -> bool,
     {
         FilterSource::new(self, filter_func)
     }
@@ -46,7 +57,7 @@ pub trait Source<'a> {
     fn into_boxed(
         self,
     ) -> Box<
-        dyn Source<'a, Item = Self::Item, Iter = Box<dyn 'a + SeekableIter<Item = Self::Item>>>
+        dyn Source<'a, Iter = Box<dyn 'a + SeekableIter<Item = <Self::Iter as Iterator>::Item>>>
             + 'a,
     >
     where
@@ -56,9 +67,8 @@ pub trait Source<'a> {
     }
 }
 
-impl<'a, S: Source<'a> + ?Sized + 'a> Source<'a> for Box<S> {
-    type Item = S::Item;
-    type Iter = Box<dyn SeekableIter<Item = Self::Item> + 'a>;
+impl<'a, S: Source<'a> + ?Sized> Source<'a> for Box<S> {
+    type Iter = Box<dyn SeekableIter<Item = <S::Iter as Iterator>::Item> + 'a>;
     fn iter(&'a self) -> Self::Iter {
         Box::new(self.as_ref().iter())
     }
@@ -66,8 +76,7 @@ impl<'a, S: Source<'a> + ?Sized + 'a> Source<'a> for Box<S> {
 
 struct BoxedSource<'a, S: Source<'a>>(S, std::marker::PhantomData<&'a S>);
 impl<'a, S: Source<'a>> Source<'a> for BoxedSource<'a, S> {
-    type Item = S::Item;
-    type Iter = Box<dyn SeekableIter<Item = S::Item> + 'a>;
+    type Iter = Box<dyn SeekableIter<Item = <S::Iter as Iterator>::Item> + 'a>;
 
     fn iter(&'a self) -> Self::Iter {
         Box::new(self.0.iter())
@@ -109,7 +118,6 @@ impl SeekableIter for VecIter<'_> {
 }
 
 impl<'a> Source<'a> for Vec<Entry> {
-    type Item = Entry;
     type Iter = VecIter<'a>;
     fn iter(&'a self) -> Self::Iter {
         VecIter {
@@ -155,7 +163,6 @@ pub mod test_source {
     }
 
     impl<'a> Source<'a> for TestSource {
-        type Item = Entry;
         type Iter = TestIter<'a>;
         fn iter(&'a self) -> Self::Iter {
             TestIter {