From ade9fbea7b761f3156ceb957084058b751e7606f Mon Sep 17 00:00:00 2001 From: Chris Mikkelson Date: Thu, 5 Sep 2024 19:24:59 -0500 Subject: [PATCH] WIP: attempt to refactor Source without object safety --- src/dupsort_func.rs | 20 +++--- src/iter.rs | 14 ++-- src/merge_func.rs | 14 ++-- src/merger.rs | 27 ++++---- src/reader/mod.rs | 7 +- src/sorter.rs | 2 +- src/source.rs | 156 +++++++++++++++++++++----------------------- tests/rwtest.rs | 2 +- 8 files changed, 113 insertions(+), 129 deletions(-) diff --git a/src/dupsort_func.rs b/src/dupsort_func.rs index b0f4ea4..255053b 100644 --- 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 8e11039..7e062c3 100644 --- a/src/iter.rs +++ b/src/iter.rs @@ -19,11 +19,11 @@ pub struct PrefixIter { } impl PrefixIter { - 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 { } impl RangeIter { - 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 781ddb6..7738df3 100644 --- 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 8a726cb..449cff5 100644 --- a/src/merger.rs +++ b/src/merger.rs @@ -136,25 +136,28 @@ impl Iter for MergeIter { } impl Source for Merger { - type It = MergeIter; - type Get = MergeIter; - type Prefix = MergeIter; - type Range = MergeIter; - - 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 f98310e..1f31a3e 100644 --- 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> Iter for ReaderIter { } } -impl> IterSource for Reader { - type It = ReaderIter; - fn iter(&self) -> Self::It { +impl> Source for Reader { + fn iter(&self) -> impl Iter { ReaderIter { reader: self.clone(), next_offset: 0, diff --git a/src/sorter.rs b/src/sorter.rs index d1e8aac..72e4823 100644 --- 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 de00675..6aaee8b 100644 --- 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(self, merge_func: F) -> MergeFunc 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) -> BoxedIter<'a>; + fn get_prefix(&'a self, prefix: Vec) -> BoxedIter<'a>; + fn get_range(&'a self, start: Vec, end: Vec) -> BoxedIter<'a>; } -impl Source for I { - type It = ::It; - type Get = RangeIter; - type Prefix = PrefixIter; - type Range = RangeIter; - - fn iter(&self) -> Self::It { - (self as &I).iter() +impl<'a> Source for &'a Box + '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) -> 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) -> 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, end: Vec) -> 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 + 'a>); + impl<'a> BoxedSource<'a> { - fn from(source: S) -> Self { - Self(Box::new(BoxWrap(source, PhantomData))) + fn from(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); + +impl Source for RefSource +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); @@ -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::::new(); - v.push(BoxedSource::from(&ts)); - v.push(BoxedSource::from(&ts)); + let mut v = Vec::>::new(); + v.push(BoxedSource::from_source(&ts)); + v.push(BoxedSource::from_source(&ts)); let mut refv = Vec::::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 6988191..550270d 100644 --- a/tests/rwtest.rs +++ b/tests/rwtest.rs @@ -19,7 +19,7 @@ fn test_write_readback() { assert_eq!(ri.collect::>(), 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::>(), reference -- 2.50.1