io integration

Cargo.toml

@@ -1,4 +1,11 @@
 [package]
 name = "search-rs"
 version = "0.1.0"
-edition = "2021"
+edition = "2021"
+
+[lib]
+name = "search"
+path = "src/lib.rs"
+
+[dependencies]
+rand = "0.8"

src/io/reader.rs → src/bits/reader.rs

@@ -29,7 +29,7 @@ impl Reader {
 
     pub fn read_gamma(&mut self) -> u32 {
         let len = self.read_unary() - 1;
-        (self.read_len(len) as u32 | (1 << len)) - 1
+        (self.read_internal(len) as u32 | (1 << len)) - 1
     }
 
     fn read_unary(&mut self) -> u32 {
@@ -48,7 +48,24 @@ impl Reader {
         zeros + 1
     }
 
-    fn read_len(&mut self, len: u32) -> u128 {
+    pub fn read_vbyte(&mut self) -> u32 {
+        let mut res = 0;
+
+        let mask = (1 << 7) - 1;
+        let mut byte_num = 0;
+
+        let mut exit = false;
+        while !exit {
+            let byte = self.read_internal(8);
+            res |= (byte & mask) << (7 * byte_num);
+
+            byte_num += 1;
+            exit = byte & (1 << 7) != 0;
+        }
+        res as u32 - 1
+    }
+
+    fn read_internal(&mut self, len: u32) -> u128 {
         let mask = (1 << len) - 1;
 
         let remaining = BUFFER_SIZE - self.read;
@@ -60,7 +77,7 @@ impl Reader {
             self.fill_buffer();
 
             let delta = len - remaining;
-            res |= self.read_len(delta) << remaining;
+            res |= self.read_internal(delta) << remaining;
 
             return res;
         }
@@ -85,23 +102,30 @@ mod test {
     use std::fs::create_dir_all;
 
     use super::*;
-    use crate::io::writer::Writer;
+    use crate::bits::writer::Writer;
 
     #[test]
     fn test_read_gamma() {
         create_dir_all("data/test/").expect("error while creating test dir");
 
-        let mut w = Writer::new("data/test/writer.bin");
+        let mut w = Writer::new("data/test/writer_unit.bin");
         for i in 1..100 {
             w.write_gamma(i);
         }
+        for i in 1..100 {
+            w.write_vbyte(i);
+        }
         w.flush();
 
-        let mut r = Reader::new("data/test/writer.bin");
+        let mut r = Reader::new("data/test/writer_unit.bin");
 
         for i in 1..100 {
             let a = r.read_gamma();
             assert_eq!(i, a);
         }
+        for i in 1..100 {
+            let a = r.read_vbyte();
+            assert_eq!(i, a);
+        }
     }
 }

src/io/writer.rs → src/bits/writer.rs

@@ -40,20 +40,20 @@ impl Writer {
     }
 
     fn int_to_vbyte(n: u32) -> (u128, u32) {
-        let mut vbyte: u32 = 0;
+        let mut vbyte: u128 = 0;
 
         let mut n = n;
         let mut byte_num = 0;
         let mask = (1 << 7) - 1;
 
         while n > 0 {
-            vbyte |= (n & mask) << (8 * byte_num);
+            vbyte |= ((n & mask) as u128) << (8 * byte_num);
             n >>= 7;
             byte_num += 1;
         }
         vbyte |= 1 << (8 * byte_num - 1);
 
-        (vbyte as u128, 8 * byte_num)
+        (vbyte, 8 * byte_num)
     }
 
     fn write_internal(&mut self, payload: u128, len: u32) {
@@ -95,6 +95,8 @@ impl Writer {
 #[cfg(test)]
 mod test {
 
+    use std::fs::create_dir_all;
+
     use super::*;
 
     #[test]
@@ -121,6 +123,8 @@ mod test {
 
     #[test]
     fn test_buffer_overflow() {
+        create_dir_all("data/test/").expect("error while creating test dir");
+
         let word = (1 << 10) - 1;
         let len = 10;
 

src/lib.rs

@@ -0,0 +1 @@
+pub mod bits;

tests/read_write_integration_test.rs

@@ -0,0 +1,40 @@
+use rand::Rng;
+use search::bits::{reader::Reader, writer::Writer};
+use std::fs::create_dir_all;
+
+#[test]
+fn test_read_write() {
+    create_dir_all("data/test/").expect("error while creating test dir");
+
+    let path = "data/test/writer_io_integration.bin";
+
+    let n = 100_000;
+    let mut rng = rand::thread_rng();
+    let values: Vec<u32> = (0..n).map(|_| rng.gen_range(0..u32::MAX - 1)).collect();
+    let mut coding: Vec<u32> = (0..n).map(|_| rng.gen()).collect();
+
+    let mut writer = Writer::new(path);
+
+    writer.write_vbyte(n);
+
+    values.iter().zip(coding.iter_mut()).for_each(|(v, c)| {
+        if *c % 2 == 0 {
+            writer.write_vbyte(*v)
+        } else {
+            writer.write_gamma(*v)
+        }
+    });
+    writer.flush();
+
+    let mut reader = Reader::new(path);
+    assert_eq!(n, reader.read_vbyte());
+
+    values.iter().zip(coding.iter_mut()).for_each(|(v, c)| {
+        let r = if *c % 2 == 0 {
+            reader.read_vbyte()
+        } else {
+            reader.read_gamma()
+        };
+        assert_eq!(r, *v)
+    });
+}