WIP: attempt to refactor Source without object safety

diff --git a/src/dupsort_func.rs b/src/dupsort_func.rs
index b0f4ea4c8f3c51ae086c2b3111f490259884aa01..255053b8af73c44b041207e131b551106cfe0bec 100644 (file)
--- a/src/dupsort_func.rs
+++ b/src/dupsort_func.rs
@@ -28,36 +28,32 @@ where
     S: Source,
     F: Fn(&Entry, &Entry) -> Ordering,
 {
-    type It = DupsortFuncIter<'a, S::It, F>;
-    fn iter(&self) -> Self::It {
-        Self::It {
+    fn iter(&self) -> impl Iter {
+        DupsortFuncIter {
             run: Vec::new(),
             next: None,
             iter: self.source.iter(),
             dupsort_func: &self.dupsort_func,
         }
     }
-    type Get = DupsortFuncIter<'a, S::Get, F>;
-    fn get(&self, key: &[u8]) -> Self::Get {
-        Self::Get {
+    fn get(&self, key: impl AsRef<[u8]>) -> impl Iter {
+        DupsortFuncIter {
             run: Vec::new(),
             next: None,
             iter: self.source.get(key),
             dupsort_func: &self.dupsort_func,
         }
     }
-    type Prefix = DupsortFuncIter<'a, S::Prefix, F>;
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
-        Self::Prefix {
+    fn get_prefix(&self, prefix: impl AsRef<[u8]>) -> impl Iter {
+        DupsortFuncIter {
             run: Vec::new(),
             next: None,
             iter: self.source.get_prefix(prefix),
             dupsort_func: &self.dupsort_func,
         }
     }
-    type Range = DupsortFuncIter<'a, S::Range, F>;
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Range {
-        Self::Range {
+    fn get_range(&self, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> impl Iter {
+        DupsortFuncIter {
             run: Vec::new(),
             next: None,
             iter: self.source.get_range(start, end),

diff --git a/src/iter.rs b/src/iter.rs
index 8e110398721b8d0b1be5394237c95e5fc658d2da..7e062c35067cec7ed46b2ddb6dd85544ba3de37b 100644 (file)
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -19,11 +19,11 @@ pub struct PrefixIter<I: Iter> {
 }
 
 impl<I: Iter> PrefixIter<I> {
-    pub fn new(mut iter: I, prefix: &[u8]) -> Self {
-        iter.seek(prefix);
+    pub fn new(mut iter: I, prefix: impl AsRef<[u8]>) -> Self {
+        iter.seek(prefix.as_ref());
         Self {
             iter,
-            prefix: Vec::from(prefix),
+            prefix: Vec::from(prefix.as_ref()),
         }
     }
 }
@@ -53,12 +53,12 @@ pub struct RangeIter<I: Iter> {
 }
 
 impl<I: Iter> RangeIter<I> {
-    pub fn new(mut iter: I, start: &[u8], end: &[u8]) -> Self {
-        iter.seek(start);
+    pub fn new(mut iter: I, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> Self {
+        iter.seek(start.as_ref());
         Self {
             iter,
-            start: Vec::from(start),
-            end: Vec::from(end),
+            start: Vec::from(start.as_ref()),
+            end: Vec::from(end.as_ref()),
         }
     }
 }

diff --git a/src/merge_func.rs b/src/merge_func.rs
index 781ddb68f1d2d2565491e8c3951a0c031eac58b8..7738df3e434e31acae1a7e70df58f8c5d84e7167 100644 (file)
--- a/src/merge_func.rs
+++ b/src/merge_func.rs
@@ -20,32 +20,28 @@ where
     S: Source,
     F: Fn(&mut Entry, &Entry) + Clone,
 {
-    type It = MergeFuncIter<'a, S::It, F>;
-    fn iter(&self) -> Self::It {
-        Self::It {
+    fn iter(&self) -> impl Iter {
+        MergeFuncIter {
             prev: None,
             iter: self.source.iter(),
             merge_func: &self.merge_func,
         }
     }
-    type Get = MergeFuncIter<'a, S::Get, F>;
-    fn get(&self, key: &[u8]) -> Self::Get {
+    fn get(&self, key: impl AsRef<[u8]>) -> impl Iter {
         MergeFuncIter {
             prev: None,
             iter: self.source.get(key),
             merge_func: &self.merge_func,
         }
     }
-    type Prefix = MergeFuncIter<'a, S::Prefix, F>;
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
+    fn get_prefix(&self, prefix: impl AsRef<[u8]>) -> impl Iter {
         MergeFuncIter {
             prev: None,
             iter: self.source.get_prefix(prefix),
             merge_func: &self.merge_func,
         }
     }
-    type Range = MergeFuncIter<'a, S::Range, F>;
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Range {
+    fn get_range(&self, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> impl Iter {
         MergeFuncIter {
             prev: None,
             iter: self.source.get_range(start, end),

diff --git a/src/merger.rs b/src/merger.rs
index 8a726cbed364370dfd8efecc6feefeec5f4bfc30..449cff5f3557794b17ea0f6af4c1df4f0a48b99d 100644 (file)
--- a/src/merger.rs
+++ b/src/merger.rs
@@ -136,25 +136,28 @@ impl<I: Iter> Iter for MergeIter<I> {
 }
 
 impl<S: Source> Source for Merger<S> {
-    type It = MergeIter<S::It>;
-    type Get = MergeIter<S::Get>;
-    type Prefix = MergeIter<S::Prefix>;
-    type Range = MergeIter<S::Range>;
-
-    fn iter(&self) -> Self::It {
+    fn iter(&self) -> impl Iter {
         MergeIter::from(self.sources.iter().map(|s| s.iter()))
     }
 
-    fn get(&self, key: &[u8]) -> Self::Get {
-        MergeIter::from(self.sources.iter().map(|s| s.get(key)))
+    fn get(&self, key: impl AsRef<[u8]>) -> impl Iter {
+        let key = Vec::from(key.as_ref());
+        MergeIter::from(self.sources.iter().map(|s| s.get(key.clone())))
     }
 
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
-        MergeIter::from(self.sources.iter().map(|s| s.get_prefix(prefix)))
+    fn get_prefix(&self, prefix: impl AsRef<[u8]>) -> impl Iter {
+        let prefix = Vec::from(prefix.as_ref());
+        MergeIter::from(self.sources.iter().map(|s| s.get_prefix(prefix.clone())))
     }
 
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Range {
-        MergeIter::from(self.sources.iter().map(|s| s.get_range(start, end)))
+    fn get_range(&self, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> impl Iter {
+        let start = Vec::from(start.as_ref());
+        let end = Vec::from(end.as_ref());
+        MergeIter::from(
+            self.sources
+                .iter()
+                .map(|s| s.get_range(start.clone(), end.clone())),
+        )
     }
 }
 

diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index f98310eb284d91e8667a138ca7f9a6247f3fae26..1f31a3eb1a36706e2406e9c71609a5bf31bd23de 100644 (file)
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -1,5 +1,5 @@
 use crate::metadata::Metadata;
-use crate::source::IterSource;
+use crate::Source;
 use crate::{Entry, Iter};
 use integer_encoding::VarInt;
 pub(crate) mod block;
@@ -173,9 +173,8 @@ impl<D: AsRef<[u8]>> Iter for ReaderIter<D> {
     }
 }
 
-impl<D: AsRef<[u8]>> IterSource for Reader<D> {
-    type It = ReaderIter<D>;
-    fn iter(&self) -> Self::It {
+impl<D: AsRef<[u8]>> Source for Reader<D> {
+    fn iter(&self) -> impl Iter {
         ReaderIter {
             reader: self.clone(),
             next_offset: 0,

diff --git a/src/sorter.rs b/src/sorter.rs
index d1e8aac1403bc238c04077a9d4f32a126ac5a119..72e482311be77dc9fb60afd007be12b0641f5585 100644 (file)
--- a/src/sorter.rs
+++ b/src/sorter.rs
@@ -1,5 +1,5 @@
 use crate::merge_func::MergeFunc;
-use crate::{Entry, Merger, Reader, Source, Writer};
+use crate::{Entry, Merger, Reader, Source};
 use memmap::Mmap;
 
 /*

diff --git a/src/source.rs b/src/source.rs
index de0067527a827b2c7c0a19f1300ab11597ec418e..6aaee8b1f9f85a9944f707aee902ec1c5055df44 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -1,19 +1,20 @@
 use crate::dupsort_func::DupsortFunc;
-use crate::iter::{BoxedIter, PrefixIter, RangeIter};
+use crate::iter::{PrefixIter, RangeIter};
 use crate::merge_func::MergeFunc;
 use crate::{Entry, Iter};
-use std::marker::PhantomData;
 
 pub trait Source {
-    type It: Iter;
-    type Get: Iter;
-    type Prefix: Iter;
-    type Range: Iter;
-
-    fn iter(&self) -> Self::It;
-    fn get(&self, key: &[u8]) -> Self::Get;
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix;
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Range;
+    fn iter(&self) -> impl Iter;
+    fn get(&self, key: impl AsRef<[u8]>) -> impl Iter {
+        let key = Vec::from(key.as_ref());
+        RangeIter::new(self.iter(), key.clone(), key)
+    }
+    fn get_prefix(&self, prefix: impl AsRef<[u8]>) -> impl Iter {
+        PrefixIter::new(self.iter(), prefix)
+    }
+    fn get_range(&self, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> impl Iter {
+        RangeIter::new(self.iter(), start, end)
+    }
 
     fn merge_func<F>(self, merge_func: F) -> MergeFunc<Self, F>
     where
@@ -32,95 +33,85 @@ pub trait Source {
     }
 }
 
-pub trait IterSource {
-    type It: Iter;
-    fn iter(&self) -> Self::It;
+/*pub trait SourceObj<'a> {
+    fn iter(&'a self) -> BoxedIter<'a>;
+    fn get(&'a self, key: Vec<u8>) -> BoxedIter<'a>;
+    fn get_prefix(&'a self, prefix: Vec<u8>) -> BoxedIter<'a>;
+    fn get_range(&'a self, start: Vec<u8>, end: Vec<u8>) -> BoxedIter<'a>;
 }
 
-impl<I: IterSource> Source for I {
-    type It = <I as IterSource>::It;
-    type Get = RangeIter<Self::It>;
-    type Prefix = PrefixIter<Self::It>;
-    type Range = RangeIter<Self::It>;
-
-    fn iter(&self) -> Self::It {
-        (self as &I).iter()
+impl<'a> Source for &'a Box<dyn SourceObj<'a> + 'a> {
+    fn iter(&self) -> impl Iter {
+        (*self).as_ref().iter()
     }
-
-    fn get(&self, key: &[u8]) -> Self::Get {
-        RangeIter::new(self.iter(), key, key)
+    fn get(&self, key: impl AsRef<[u8]>) -> impl Iter {
+        (*self).as_ref().get(Vec::from(key.as_ref()))
     }
-
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
-        PrefixIter::new(self.iter(), prefix)
+    fn get_prefix(&self, prefix: impl AsRef<[u8]>) -> impl Iter {
+        (*self).as_ref().get_prefix(Vec::from(prefix.as_ref()))
     }
-
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Range {
-        RangeIter::new(self.iter(), start, end)
+    fn get_range(&self, start: impl AsRef<[u8]>, end: impl AsRef<[u8]>) -> impl Iter {
+        (*self)
+            .as_ref()
+            .get_range(Vec::from(start.as_ref()), Vec::from(end.as_ref()))
     }
 }
 
 struct BoxWrap<'a, S: Source + 'a>(S, PhantomData<&'a S>);
-impl<'a, S: Source + 'a> Source for BoxWrap<'a, S> {
-    type It = BoxedIter<'a>;
-    fn iter(&self) -> Self::It {
+impl<'a, S: Source + 'a> SourceObj<'a> for BoxWrap<'a, S> {
+    fn iter(&'a self) -> BoxedIter<'a> {
         Box::new(self.0.iter())
     }
-    type Get = BoxedIter<'a>;
-    fn get(&self, key: &[u8]) -> Self::Get {
+    fn get(&'a self, key: Vec<u8>) -> BoxedIter<'a> {
         Box::new(self.0.get(key))
     }
-    type Prefix = BoxedIter<'a>;
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Get {
+    fn get_prefix(&'a self, prefix: Vec<u8>) -> BoxedIter<'a> {
         Box::new(self.0.get_prefix(prefix))
     }
-    type Range = BoxedIter<'a>;
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Get {
+    fn get_range(&'a self, start: Vec<u8>, end: Vec<u8>) -> BoxedIter<'a> {
         Box::new(self.0.get_range(start, end))
     }
 }
 
-pub struct BoxedSource<'a>(
-    Box<
-        dyn Source<
-                It = BoxedIter<'a>,
-                Get = BoxedIter<'a>,
-                Prefix = BoxedIter<'a>,
-                Range = BoxedIter<'a>,
-            > + 'a,
-    >,
-);
-
-#[allow(dead_code)]
+pub struct BoxedSource<'a>(Box<dyn SourceObj<'a> + 'a>);
+
 impl<'a> BoxedSource<'a> {
-    fn from<S: Source + 'a>(source: S) -> Self {
-        Self(Box::new(BoxWrap(source, PhantomData)))
+    fn from<S: Source + 'a>(s: S) -> Self {
+        Self(Box::new(BoxWrap(s, PhantomData)))
     }
 }
-impl<'a> Source for BoxedSource<'a> {
-    type It = BoxedIter<'a>;
-    fn iter(&self) -> Self::It {
-        self.0.as_ref().iter()
-    }
-    type Get = BoxedIter<'a>;
-    fn get(&self, key: &[u8]) -> Self::Get {
-        self.0.get(key)
+
+impl<'a> Source for &'a BoxedSource<'a>
+where
+    Self: 'a,
+{
+    fn iter(&self) -> impl Iter {
+        (*self).0.as_ref().iter()
     }
-    type Prefix = BoxedIter<'a>;
-    fn get_prefix(&self, prefix: &[u8]) -> Self::Prefix {
-        self.0.get_prefix(prefix)
+
+    fn get(&self, key: impl AsRef<[u8]>) -> impl Iter {
+        (*self).0.as_ref().get(Vec::from(key.as_ref()))
     }
-    type Range = BoxedIter<'a>;
-    fn get_range(&self, start: &[u8], end: &[u8]) -> Self::Prefix {
-        self.0.get_range(start, end)
+}
+
+pub struct RefSource<S>(S);
+
+impl<S> Source for RefSource<S>
+where
+    for<'a> &'a S: Source + 'a,
+{
+    fn iter(&self) -> impl Iter {
+        let r = &(self.0);
+        r.iter()
     }
 }
+*/
 
 #[cfg(test)]
 pub mod test_source {
-    use super::IterSource;
     use crate::Entry;
     use crate::Iter;
+    use crate::Source;
 
     pub struct TestSource(pub Vec<Entry>);
 
@@ -152,10 +143,8 @@ pub mod test_source {
         }
     }
 
-    impl<'a> IterSource for &'a TestSource {
-        type It = TestIter<'a>;
-
-        fn iter(&self) -> TestIter<'a> {
+    impl<'a> Source for &'a TestSource {
+        fn iter(&self) -> impl Iter {
             TestIter {
                 source: self,
                 off: 0,
@@ -167,7 +156,7 @@ pub mod test_source {
 #[cfg(test)]
 pub mod test {
     use super::test_source::TestSource;
-    use super::{BoxedSource, Source};
+    use super::Source;
     use crate::Entry;
 
     fn test_source() -> TestSource {
@@ -205,26 +194,26 @@ pub mod test {
         );
     }
 
-    #[test]
+    /*#[test]
     fn test_generic_source_iter() {
         let ts = test_source();
-        let s = BoxedSource::from(&ts);
+        let s = BoxedSource::from_source(&ts);
 
         assert_eq!(
             Vec::from_iter(s.iter().map(|e| e.value[0])),
             vec![0, 1, 2, 3, 4]
         );
         assert_eq!(
-            Vec::from_iter(s.get(vec![0, 0, 1, 0].as_slice()).map(|e| e.value[0])),
+            Vec::from_iter(s.get(vec![0, 0, 1, 0]).map(|e| e.value[0])),
             vec![2]
         );
         assert_eq!(
-            Vec::from_iter(s.get_prefix(vec![0, 0].as_slice()).map(|e| e.value[0])),
+            Vec::from_iter(s.get_prefix(vec![0, 0]).map(|e| e.value[0])),
             vec![0, 1, 2]
         );
         assert_eq!(
             Vec::from_iter(
-                s.get_range(vec![0, 0, 0, 1].as_slice(), vec![0, 1, 0, 0].as_slice())
+                s.get_range(vec![0, 0, 0, 1], vec![0, 1, 0, 0])
                     .map(|e| e.value[0])
             ),
             vec![1, 2, 3]
@@ -235,12 +224,13 @@ pub mod test {
     fn test_dyn_source() {
         use crate::merger::Merger;
         let ts = test_source();
-        let mut v = Vec::<BoxedSource>::new();
-        v.push(BoxedSource::from(&ts));
-        v.push(BoxedSource::from(&ts));
+        let mut v = Vec::<Box<dyn SourceObj + '_>>::new();
+        v.push(BoxedSource::from_source(&ts));
+        v.push(BoxedSource::from_source(&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);
+        let gs = Merger::from(v.iter());
         assert_eq!(Vec::from_iter(gs.iter()), refv);
     }
+    */
 }

diff --git a/tests/rwtest.rs b/tests/rwtest.rs
index 6988191aa9e9b513f95b2989ea331f2a7fa25ef4..550270d11cd634a86dc7d263b49f763aa69def26 100644 (file)
--- a/tests/rwtest.rs
+++ b/tests/rwtest.rs
@@ -19,7 +19,7 @@ fn test_write_readback() {
     assert_eq!(ri.collect::<Vec<_>>(), reference);
 
     // test range
-    let rangei = r.get_range(&u32::to_be_bytes(192), &u32::to_be_bytes(256));
+    let rangei = r.get_range(u32::to_be_bytes(192), u32::to_be_bytes(256));
     assert_eq!(
         rangei.collect::<Vec<_>>(),
         reference