group-varint-encoding 0.1.2

Fast algorithm to compress lists if integers in blocks of 4. Appends 0s to blocks, if length of input is not divisable by 4.
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


pub(crate) struct Chunk<I>
where
    I: Iterator<Item = u32>,
{
    pub iter: I,
}

impl<I> Iterator for Chunk<I>
where
    I: Iterator<Item = u32>,
{
    type Item = Vec<u32>;

    fn next(&mut self) -> Option<Self::Item> {
        let a = self.iter.next();
        let b = self.iter.next();
        let c = self.iter.next();
        let d = self.iter.next();

        match (a, b, c, d) {
            (None, _, _, _) => None,
            (Some(a), None, _, _) => Some(vec![a, 0, 0, 0]),
            (Some(a), Some(b), None, _) => Some(vec![a, b, 0, 0]),
            (Some(a), Some(b), Some(c), None) => Some(vec![a, b, c, 0]),
            (Some(a), Some(b), Some(c), Some(d)) => Some(vec![a, b, c, d]),
        }
    }
}


pub(crate) fn var_bits(v: u32) -> u8 {
    if v <= 0xffff {
        if v <= 0xff {
            0
        } else {
            1
        }
    } else if v <= 0xffffff {
        2
    } else {
        3
    }
}