WIP experiment dyn source

Lifetime making it hard to test, possibly implement at all

diff --git a/src/lib.rs b/src/lib.rs
index d54ab8b9b13ede4b1a59a23454cbd7190237eb28..9a79bf064648d2bdaca65454f6cf829db3637933 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3 +1,4 @@
+#![allow(dead_code)]
 pub mod entry;
 use entry::Entry;
 

diff --git a/src/source.rs b/src/source.rs
index 556f1105dc9adea5710df6f32dab59888d4f0769..ee341bd7472d78923433bc122f36f20f16e7ef9c 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -172,9 +172,34 @@ pub mod test {
         ])
     }
 
+    fn chk<'a, S: Source<'a>>(s: S) -> S {
+        s
+    }
+
     #[test]
     fn test_source_iter() {
-        let s = test_source();
+        // works
+        //let s = test_source();
+
+        // works
+        //let w = Box::new(SourceWrapper(test_source(), PhantomData));
+        //let s: &dyn GenSource = w.as_ref();
+
+        // also works
+        // let w = SourceWrapper(test_source(), PhantomData);
+        // let s: &dyn GenSource = &w;
+
+        let s = GenSourceS::from(test_source());
+        //let s = test_source();
+
+        // borrowed value 's' doesn't live long enough'
+        // box.iter() consumes! Ding
+        // let s: Box<dyn GenSource> = test_source().into();
+        //
+        // same as above
+        // let b: Box<dyn GenSource> = test_source().into();
+        // let s = b.as_ref();
+        //
         assert_eq!(
             Vec::from_iter(s.iter().map(|e| e.value[0])),
             vec![0, 1, 2, 3, 4]
@@ -195,4 +220,69 @@ pub mod test {
             vec![1, 2, 3]
         );
     }
+
+    type GenIter<'a> = Box<dyn Iter + 'a>;
+    struct GenSourceS<'a> {
+        inner: Box<
+            dyn Source<'a, It = GenIter, Get = GenIter, Prefix = GenIter, Range = GenIter> + 'a,
+        >,
+    }
+    use std::marker::PhantomData;
+    struct SourceWrapper<'a, S: Source<'a>>(S, PhantomData<&'a u8>);
+    impl<'a, S: Source<'a>> IterSource<'a> for SourceWrapper<'a, S> {
+        type It = GenIter<'a>;
+        fn iter(&'a self) -> Self::It {
+            Box::new(self.0.iter())
+        }
+    }
+    impl<'a, S: Source<'a>> Source<'a> for SourceWrapper<'a, S> {
+        type Get = GenIter<'a>;
+        fn get(&'a self, key: &[u8]) -> Self::Get {
+            Box::new(self.0.get(key))
+        }
+        type Prefix = GenIter<'a>;
+        fn get_prefix(&'a self, prefix: &[u8]) -> Self::Prefix {
+            Box::new(self.0.get_prefix(prefix))
+        }
+        type Range = GenIter<'a>;
+        fn get_range(&'a self, start: &[u8], end: &[u8]) -> Self::Range {
+            Box::new(self.0.get_range(start, end))
+        }
+    }
+
+    impl<'a> GenSourceS<'a> {
+        fn from<S: Source<'a> + 'a>(source: S) -> Self {
+            GenSourceS {
+                inner: Box::new(SourceWrapper(source, PhantomData)),
+            }
+        }
+    }
+    impl<'a> IterSource<'a> for GenSourceS<'a> {
+        type It = GenIter<'a>;
+        fn iter(&'a self) -> Self::It {
+            Box::new(self.inner.iter())
+        }
+    }
+    impl<'a> Source<'a> for GenSourceS<'a> {
+        type Get = GenIter<'a>;
+        fn get(&'a self, key: &[u8]) -> Self::Get {
+            Box::new(self.inner.get(key))
+        }
+        type Prefix = GenIter<'a>;
+        fn get_prefix(&'a self, prefix: &[u8]) -> Self::Prefix {
+            Box::new(self.inner.get_prefix(prefix))
+        }
+        type Range = GenIter<'a>;
+        fn get_range(&'a self, start: &[u8], end: &[u8]) -> Self::Range {
+            Box::new(self.inner.get_range(start, end))
+        }
+    }
+
+    #[test]
+    fn test_dyn_source() {
+        let b = GenSourceS::from(test_source());
+        {
+            b.iter();
+        }
+    }
 }