irtt-proto 0.4.0

IRTT protocol encoding and decoding primitives
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::{ProtoError, Result};

pub fn encode_uvarint(mut value: u64, out: &mut Vec<u8>) {
    while value >= 0x80 {
        out.push((value as u8) | 0x80);
        value >>= 7;
    }
    out.push(value as u8);
}

pub fn decode_uvarint(input: &[u8]) -> Result<(u64, usize)> {
    let mut value = 0u64;
    for (idx, byte) in input.iter().copied().enumerate() {
        if idx == 10 {
            return Err(ProtoError::VarintOverflow);
        }
        let low = u64::from(byte & 0x7f);
        let shift = idx * 7;
        if shift == 63 && low > 1 {
            return Err(ProtoError::VarintOverflow);
        }
        value |= low << shift;
        if byte < 0x80 {
            return Ok((value, idx + 1));
        }
    }
    Err(ProtoError::TruncatedVarint)
}

pub fn zigzag_encode(value: i64) -> u64 {
    ((value << 1) ^ (value >> 63)) as u64
}

pub fn zigzag_decode(value: u64) -> i64 {
    ((value >> 1) as i64) ^ (-((value & 1) as i64))
}

pub fn encode_varint(value: i64, out: &mut Vec<u8>) {
    encode_uvarint(zigzag_encode(value), out);
}

pub fn decode_varint(input: &[u8]) -> Result<(i64, usize)> {
    let (value, used) = decode_uvarint(input)?;
    Ok((zigzag_decode(value), used))
}

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

    #[test]
    fn uvarint_round_trips() {
        for value in [
            0,
            1,
            2,
            127,
            128,
            255,
            16_384,
            u32::MAX as u64,
            i64::MAX as u64,
            u64::MAX,
        ] {
            let mut encoded = Vec::new();
            encode_uvarint(value, &mut encoded);
            assert_eq!(decode_uvarint(&encoded), Ok((value, encoded.len())));
        }
    }

    #[test]
    fn signed_varint_round_trips() {
        for value in [
            i64::MIN,
            -9_223_372_036,
            -2,
            -1,
            0,
            1,
            2,
            1_000_000_000,
            3_000_000_000,
            i64::MAX,
        ] {
            let mut encoded = Vec::new();
            encode_varint(value, &mut encoded);
            assert_eq!(decode_varint(&encoded), Ok((value, encoded.len())));
        }
    }

    #[test]
    fn verified_byte_examples() {
        let cases: &[(i64, &[u8])] = &[
            (1, &[0x02]),
            (3_000_000_000, &[0x80, 0xf8, 0x82, 0xad, 0x16]),
            (1_000_000_000, &[0x80, 0xa8, 0xd6, 0xb9, 0x07]),
            (1472, &[0x80, 0x17]),
            (3, &[0x06]),
            (184, &[0xf0, 0x02]),
        ];
        for (value, expected) in cases {
            let mut encoded = Vec::new();
            encode_varint(*value, &mut encoded);
            assert_eq!(&encoded, expected);
            assert_eq!(decode_varint(expected), Ok((*value, expected.len())));
        }

        let mut tag = Vec::new();
        encode_uvarint(9, &mut tag);
        assert_eq!(tag, [0x09]);
        tag.clear();
        encode_uvarint(24, &mut tag);
        assert_eq!(tag, [0x18]);
    }
}