src/compression_scheme.rs

@@ -10,14 +10,14 @@ pub trait CompressionScheme {
     /// Encode some bytes into `buf`, returning a [`Header`][Self::Header].
     ///
     /// This does not necessarily have to be deterministic,
-    /// but it **must** be decodable by [`decode`](Self::decode).
+    /// but it **must** always be decodable by [`decode`](Self::decode).
     /// That is, [`decode`](Self::decode) ∘ [`encode`](Self::encode) = `id`.
     fn encode(src: &[u8], buf: &mut BitVec) -> Self::Header;
 
     /// Decode the given bits and header into `buf`.
     ///
     /// This may panic on arbitrary input,
-    /// but it **must** successfully decode outputs of [`encode`](Self::encode).
+    /// but it **must** always decode outputs of [`encode`](Self::encode).
     /// That is, [`decode`](Self::decode) ∘ [`encode`](Self::encode) = `id`.
     fn decode(src: &BitSlice, header: &Self::Header, buf: &mut Vec<u8>);
 

src/main.rs

@@ -6,10 +6,8 @@ mod rle;
 #[cfg(test)]
 mod test;
 
-use bitvec::vec::BitVec;
 pub use compression_scheme::CompressionScheme;
 pub use freq::Freq;
-pub use rle::Rle;
 
 fn main() -> Result<(), io::Error> {
     let mut buf = Vec::new();
@@ -17,16 +15,11 @@ fn main() -> Result<(), io::Error> {
 
     println!("Original: {len_src}");
 
-    let mut bitbuf = BitVec::new();
+    // let len_rle = rle::Encoder::new(&buf).count() * 2;
+    // println!("   Rle'd: {len_rle}");
 
-    let () = Rle::encode(&buf, &mut bitbuf);
-    let len_rle = bitbuf.len().div_ceil(8);
-    println!("   Rle'd: {len_rle}");
-
-    bitbuf.clear();
-    let header = Freq::encode(&buf, &mut bitbuf);
-    let len_freq = Freq::header_size(&header) + bitbuf.len().div_ceil(8);
-    println!("  Freq'd: {len_freq}");
+    // let len_freq = len_freq_table + len_freq_bits;
+    // println!("  Freq'd: {len_freq}");
 
     Ok(())
 }