Weave CBuf into blocks for compression

diff --git a/src/reader/block.rs b/src/reader/block.rs
index b770b0501e8234af0cf01538421a8df630f28de3..5f5f1a0dff2c6670753fb9a323d796d084a5984b 100644 (file)
--- a/src/reader/block.rs
+++ b/src/reader/block.rs
@@ -1,4 +1,3 @@
-use crate::reader::DataSlice;
 use crate::{Entry, Iter, Result};
 use integer_encoding::VarInt;
 use std::mem::size_of;
@@ -37,14 +36,14 @@ impl RestartType {
 
 #[derive(Debug)]
 pub(crate) struct Block<D: AsRef<[u8]>> {
-    data: DataSlice<D>,
+    data: D,
     restart_count: usize,
     restart_off: usize,
     restart_type: RestartType,
 }
 
 impl<D: AsRef<[u8]>> Block<D> {
-    pub(crate) fn new(data: DataSlice<D>) -> Result<Self> {
+    pub(crate) fn new(data: D) -> Result<Self> {
         if data.as_ref().len() < size_of::<u32>() {
             return Err("block data too short".into());
         }
@@ -222,7 +221,6 @@ impl<D: AsRef<[u8]>> Iter for BlockIter<D> {
 mod test {
 
     use crate::reader::block::Block;
-    use crate::reader::DataSlice;
     use crate::writer::block_builder::BlockBuilder;
     use crate::Entry;
     use crate::Iter;
@@ -238,7 +236,7 @@ mod test {
         }
         let mut v = Vec::new();
         v.extend_from_slice(bb.as_slice());
-        Block::new(DataSlice::new(v)).unwrap()
+        Block::new(v).unwrap()
     }
 
     fn build_ref(n: u32, skip: u32) -> Vec<Entry> {

diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index a530aad265c21eb2c6a3c2ccc6f049de4c00c54a..3c10bb92bbf2197a83056c05db9e1b3586b9c9be 100644 (file)
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -3,6 +3,7 @@ use crate::source::{DefaultSource, IterSource};
 use crate::{Entry, Iter};
 use integer_encoding::VarInt;
 pub(crate) mod block;
+use crate::compression::CBuf;
 use memmap::{Mmap, MmapOptions};
 use std::fs::File;
 use std::io::Cursor;
@@ -92,14 +93,14 @@ impl<D: AsRef<[u8]>> Reader<D> {
         }
     }
 
-    fn index_iter(&self) -> block::BlockIter<D> {
+    fn index_iter(&self) -> block::BlockIter<CBuf<DataSlice<D>>> {
         let mut off = self.metadata.index_block_offset;
         let d = &self.data.as_ref()[off..];
         let (size, len_size) = usize::decode_var(d).unwrap();
         let prelude = len_size + std::mem::size_of::<u32>(); // TODO read and verify CRC
         assert!(size + prelude == self.metadata.bytes_index_block);
         off += prelude;
-        block::Block::new(self.data.clone_range(off, size))
+        block::Block::new(CBuf::Buf(self.data.clone_range(off, size)))
             .expect("bad block")
             .into_iter()
     }
@@ -108,8 +109,8 @@ impl<D: AsRef<[u8]>> Reader<D> {
 pub struct ReaderIter<D: AsRef<[u8]>> {
     reader: Reader<D>,
     next_offset: usize,
-    index_iter: block::BlockIter<D>,
-    data_iter: Option<block::BlockIter<D>>,
+    index_iter: block::BlockIter<CBuf<DataSlice<D>>>,
+    data_iter: Option<block::BlockIter<CBuf<DataSlice<D>>>>,
 }
 
 impl<D: AsRef<[u8]>> ReaderIter<D> {
@@ -124,7 +125,7 @@ impl<D: AsRef<[u8]>> ReaderIter<D> {
         let data_off = crc_off + std::mem::size_of::<u32>();
         self.next_offset = data_off + size;
         self.data_iter.replace(
-            block::Block::new(self.reader.data.clone_range(data_off, size))
+            block::Block::new(CBuf::Buf(self.reader.data.clone_range(data_off, size)))
                 .expect("bad block")
                 .into_iter(),
         );