Update API layout to use prelude

Add test for range iter, add missing linear search step to
BlockIter seek

diff --git a/src/lib.rs b/src/lib.rs
index 66d13553b8761e5fa3b2a34dc699ab1a222c9896..4a536c07ebe63937d10e47bd414734075affee6b 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,9 +1,10 @@
 #![allow(dead_code)]
 pub mod entry;
-use entry::Entry;
+pub use entry::Entry;
 
 pub mod source;
-use source::Source;
+pub use source::IterSource;
+pub use source::Source;
 
 pub mod iter;
 use iter::Iter;
@@ -18,3 +19,12 @@ mod metadata;
 
 type Error = Box<dyn std::error::Error>;
 type Result<T> = std::result::Result<T, Error>;
+
+pub mod prelude {
+    pub use super::entry::Entry;
+    pub use super::iter::Iter;
+    pub use super::reader::Reader;
+    pub use super::source::IterSource;
+    pub use super::source::Source;
+    pub use super::writer::Writer;
+}

diff --git a/src/reader/block.rs b/src/reader/block.rs
index 2695e2764b02639935382511e13d09172fdfeec9..be4327bb6e59a08ac9c3198b1c0c4e16bbab5c6d 100644 (file)
--- a/src/reader/block.rs
+++ b/src/reader/block.rs
@@ -45,14 +45,12 @@ pub(crate) struct Block<D: AsRef<[u8]>> {
 
 impl<D: AsRef<[u8]>> Block<D> {
     pub(crate) fn new(data: DataSlice<D>) -> Result<Self> {
-        println!("Block::new( {:?} )", data.as_ref());
         if data.as_ref().len() < size_of::<u32>() {
             return Err("block data too short".into());
         }
         let rc_off = data.as_ref().len() - size_of::<u32>();
 
         let restart_count = u32::from_be_bytes(data.as_ref()[rc_off..].try_into()?) as usize;
-        println!("restart_count = {}", restart_count);
 
         // try 32-bit restarts
         if (restart_count * size_of::<u32>()) > rc_off {
@@ -203,5 +201,14 @@ impl<D: AsRef<[u8]>> Iter for BlockIter<D> {
                     Some(())
                 });
         }
+        if self.cur_ent.is_none() && self.decode().is_none() {
+            // empty block?
+            return;
+        }
+        while self.cur_ent.as_ref().unwrap().key.as_slice() < key {
+            if self.decode().is_none() {
+                return;
+            }
+        }
     }
 }

diff --git a/src/writer/block_builder.rs b/src/writer/block_builder.rs
index 2f6c0efe6eb2ab136850f1ece1688dd47f2cffce..bbfc487ae8909da814c4bd9cb5317d48a66b966c 100644 (file)
--- a/src/writer/block_builder.rs
+++ b/src/writer/block_builder.rs
@@ -133,7 +133,6 @@ mod test {
         let block_len = bb.len();
         let block_data = bb.as_slice();
         assert_eq!(block_data.len(), block_len);
-        println!("Block: {:?}", block_data);
         let bi = Block::new(DataSlice::new(bb.as_slice()))
             .unwrap()
             .into_iter();

diff --git a/tests/rwtest.rs b/tests/rwtest.rs
index 6dde2ce0a7e681c83c3d5e98b4a59877c1c0d54a..5c6fa5eb24baa69cdf5bd3e6238fb2b493f305ee 100644 (file)
--- a/tests/rwtest.rs
+++ b/tests/rwtest.rs
@@ -1,7 +1,4 @@
-use mtbl::entry::Entry;
-use mtbl::reader::Reader;
-use mtbl::source::IterSource;
-use mtbl::writer::Writer;
+use mtbl::prelude::*;
 
 #[test]
 fn test_write_readback() {
@@ -17,6 +14,18 @@ fn test_write_readback() {
     }
 
     assert!(store.len() > 512);
-    let ri = Reader::new(&store).iter();
-    assert_eq!(ri.collect::<Vec<Entry>>(), reference);
+    let r = Reader::new(&store);
+    let ri = r.iter();
+    assert_eq!(ri.collect::<Vec<_>>(), reference);
+
+    // test range
+    let rangei = r.get_range(&u32::to_be_bytes(3), &u32::to_be_bytes(5));
+    assert_eq!(
+        rangei.collect::<Vec<_>>(),
+        reference
+            .into_iter()
+            .filter(|e| e.key.as_slice() >= &u32::to_be_bytes(3)
+                && e.key.as_slice() <= &u32::to_be_bytes(5))
+            .collect::<Vec<_>>()
+    )
 }