protobuf-lite 0.1.4

decode protobuf as hashmap
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

use crate::buffer::Reader;
use crate::error::DecodeError;
use anyhow::Result;

pub const MAX_VARINT_LENGTH: usize = 10;

#[inline]
pub fn write_uvarint(mut x: u64, buf: &mut Vec<u8>) {
    while x >= 0x80 {
        buf.push(x as u8 | 0x80);
        x >>= 7;
    }
    buf.push(x as u8);
}

#[inline]
pub fn write_varint(x: i64, buf: &mut Vec<u8>) {
    let mut ux = (x as u64) << 1;
    if x < 0 {
        ux = !ux;
    }
    write_uvarint(ux, buf);
}

#[inline]
pub fn encode_uvarint(x: u64) -> Vec<u8> {
    let mut buf = Vec::with_capacity(MAX_VARINT_LENGTH);
    write_uvarint(x, &mut buf);
    buf
}

#[inline]
pub fn encode_varint(x: i64) -> Vec<u8> {
    let mut buf = Vec::with_capacity(MAX_VARINT_LENGTH);
    write_varint(x, &mut buf);
    buf
}

#[inline]
pub fn read_uvarint<T>(buf: &mut Reader<T>) -> Result<u64>
where
    T: AsRef<[u8]>,
{
    let mut x: u64 = 0;
    let mut shift = 0;
    if buf.is_end() {
        return Err(DecodeError::EOF.into());
    }
    loop {
        match buf.read_byte() {
            Ok(v) => {
                let b = v as u64;
                x |= (b & 0x7F) << shift;
                shift += 7;
                if (b & 0x80) == 0 {
                    return Ok(x);
                }
                if shift >= 64 {
                    return Err(DecodeError::OverFlow64Bit.into());
                }
            }
            Err(_) => {
                return Err(DecodeError::UnexpectedEof.into());
            }
        }
    }
}

#[inline]
pub fn read_varint<T>(buf: &mut Reader<T>) -> Result<i64>
where
    T: AsRef<[u8]>,
{
    let ux = read_uvarint(buf)?;
    let mut x = (ux as i64) >> 1;
    if ux & 1 != 0 {
        x = !x;
    }
    Ok(x)
}