tree-buf 0.10.0

A prototype binary serialization protocol for data
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

use crate::prelude::*;

#[cfg(feature = "encode")]
pub fn encode_packed_bool(items: &[bool], bytes: &mut Vec<u8>) {
    profile_fn!(encode_packed_bool);

    let mut offset = 0;
    while offset + 7 < items.len() {
        let b = (items[offset + 0] as u8) << 0
            | (items[offset + 1] as u8) << 1
            | (items[offset + 2] as u8) << 2
            | (items[offset + 3] as u8) << 3
            | (items[offset + 4] as u8) << 4
            | (items[offset + 5] as u8) << 5
            | (items[offset + 6] as u8) << 6
            | (items[offset + 7] as u8) << 7;
        bytes.push(b);
        offset += 8;
    }

    if offset < items.len() {
        let mut b = 0;
        for i in 0..items.len() - offset {
            b |= (items[offset + i] as u8) << i;
        }
        bytes.push(b);
    }
}

#[cfg(feature = "decode")]
pub fn decode_packed_bool(bytes: &[u8]) -> Vec<bool> {
    profile_fn!(decode_packed_bool);

    let capacity = bytes.len() * 8;
    let mut result = Vec::with_capacity(capacity);
    for byte in bytes {
        result.extend_from_slice(&[
            (byte & 1 << 0) != 0,
            (byte & 1 << 1) != 0,
            (byte & 1 << 2) != 0,
            (byte & 1 << 3) != 0,
            (byte & 1 << 4) != 0,
            (byte & 1 << 5) != 0,
            (byte & 1 << 6) != 0,
            (byte & 1 << 7) != 0,
        ]);
    }
    debug_assert!(result.len() == capacity);
    result
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg(all(feature = "decode", feature = "encode"))]
    #[test]
    fn round_trip_packed_bool() {
        let cases = vec![
            vec![],
            vec![true],
            vec![false],
            vec![true, true, true, true, true, true, true],
            vec![true, true, true, true, true, true, true, true],
            vec![true, true, true, true, true, true, true, true, true],
            vec![true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false],
            vec![false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true],
            vec![true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, true, true],
            vec![
                false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, false, false,
            ],
        ];

        for case in cases {
            let mut bytes = Vec::new();
            encode_packed_bool(&case, &mut bytes);
            let result = decode_packed_bool(&bytes);

            // Can't simply assert_eq, because the decoder will pad with false at the end.
            for i in 0..case.len() {
                assert_eq!(case[i], result[i]);
            }
        }
    }
}