archivelib 0.2.0

An implementaton of the Greenleaf ArchiveLib compression/decompression algorithm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use super::base::LookAheadBitwiseRead;
use super::correct::CorrectLookAheadBitwiseReader;
use crate::support::bit_iter::ToBits;

pub struct ExpectedCallLookAheadBitwiseReader {
  data: Vec<bool>,
  index: usize,
  consume_calls: Vec<usize>,
  consume_call_index: usize,
}

impl ExpectedCallLookAheadBitwiseReader {
  pub fn new_correct(
    data: impl ToBits,
    consume_calls: &[usize],
  ) -> CorrectLookAheadBitwiseReader<Self> {
    CorrectLookAheadBitwiseReader::new(Self {
      data: data.to_bits().into_vec(),
      index: 0,
      consume_calls: consume_calls.to_vec(),
      consume_call_index: 0,
    })
  }
}

impl LookAheadBitwiseRead for ExpectedCallLookAheadBitwiseReader {
  fn consume_bits(&mut self, bits: usize) -> std::io::Result<Vec<bool>> {
    assert!(
      self.consume_call_index < self.consume_calls.len(),
      "Unexpected consume call for {} bits; Too many calls",
      bits
    );
    let expected = self.consume_calls[self.consume_call_index];
    assert_eq!(
      bits, expected,
      "Unexpected consume call(#{}) for {} bits; was expecting a call for {} bits",
      self.consume_call_index, bits, expected
    );

    let items = self.look_ahead_bits(bits)?;
    self.index += bits;
    self.consume_call_index += 1;
    Ok(items)
  }
  fn look_ahead_bits(&mut self, bits: usize) -> std::io::Result<Vec<bool>> {
    let data = self
      .data
      .iter()
      .skip(self.index)
      .take(bits)
      .cloned()
      .collect();
    Ok(data)
  }
}