libribzip2 0.5.0

a bzip2 library written in pure rust
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#[derive(Clone, PartialEq, Debug)]
pub enum DeltaEncoded {
    Empty,
    NonEmpty(DeltaEncodedSome),
}
#[derive(Clone, PartialEq, Debug)]

pub struct DeltaEncodedSome {
    pub start_value: u8,
    pub deltas: Vec<DeltaSymbol>,
}
#[derive(Clone, PartialEq, Debug)]

pub enum DeltaSymbol {
    Decrease,
    Increase,
    Stop,
}

pub fn encode_delta(input: Vec<u8>) -> DeltaEncoded {
    let mut delta_codes = Vec::<DeltaSymbol>::new();
    let start_value = input.get(0);
    delta_codes.push(DeltaSymbol::Stop);

    match start_value {
        Some(value) => {
            let mut last_value = value;

            for current_value in input.iter().skip(1) {
                let diff = (*last_value as isize) - (*current_value as isize);
                match diff.cmp(&0) {
                    std::cmp::Ordering::Greater => {
                        for _ in 0..diff.abs() {
                            delta_codes.push(DeltaSymbol::Decrease);
                        }
                    }
                    std::cmp::Ordering::Less => {
                        for _ in 0..diff.abs() {
                            delta_codes.push(DeltaSymbol::Increase);
                        }
                    }

                    std::cmp::Ordering::Equal => (),
                }

                delta_codes.push(DeltaSymbol::Stop);

                last_value = current_value;
            }
            DeltaEncoded::NonEmpty(DeltaEncodedSome {
                start_value: *value,
                deltas: delta_codes,
            })
        }
        None => DeltaEncoded::Empty,
    }
}
#[cfg(test)]
mod test {
    use super::*;

    #[test]
    pub fn encodes() {
        let res = encode_delta(vec![1, 2, 2, 1, 3, 1]);
        assert_eq!(
            res,
            DeltaEncoded::NonEmpty(DeltaEncodedSome {
                start_value: 1,
                deltas: vec![
                    DeltaSymbol::Stop,
                    DeltaSymbol::Increase,
                    DeltaSymbol::Stop,
                    DeltaSymbol::Stop,
                    DeltaSymbol::Decrease,
                    DeltaSymbol::Stop,
                    DeltaSymbol::Increase,
                    DeltaSymbol::Increase,
                    DeltaSymbol::Stop,
                    DeltaSymbol::Decrease,
                    DeltaSymbol::Decrease,
                    DeltaSymbol::Stop
                ]
            })
        )
    }
}