msgpacker 0.4.3

MessagePack protocol implementation for 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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use super::{
    helpers::{take_byte, take_num},
    Error, Format, Unpackable,
};
use core::str;

pub fn unpack_bytes(mut buf: &[u8]) -> Result<(usize, &[u8]), Error> {
    let format = take_byte(&mut buf)?;
    let (n, len) = match format {
        Format::BIN8 => (2, take_byte(&mut buf)? as usize),
        Format::BIN16 => (3, take_num(&mut buf, u16::from_be_bytes)? as usize),
        Format::BIN32 => (5, take_num(&mut buf, u32::from_be_bytes)? as usize),
        _ => return Err(Error::UnexpectedFormatTag),
    };
    if buf.len() < len {
        return Err(Error::BufferTooShort);
    }
    Ok((n + len, &buf[..len]))
}

pub fn unpack_str(mut buf: &[u8]) -> Result<(usize, &str), Error> {
    let format = take_byte(&mut buf)?;
    let (n, len) = match format {
        0xa0..=0xbf => (1, format as usize & 0x1f),
        Format::STR8 => (2, take_byte(&mut buf)? as usize),
        Format::STR16 => (3, take_num(&mut buf, u16::from_be_bytes)? as usize),
        Format::STR32 => (5, take_num(&mut buf, u32::from_be_bytes)? as usize),
        _ => return Err(Error::UnexpectedFormatTag),
    };
    if buf.len() < len {
        return Err(Error::BufferTooShort);
    }
    let str = str::from_utf8(&buf[..len]).map_err(|_| Error::InvalidUtf8)?;
    Ok((n + len, str))
}

#[cfg(feature = "alloc")]
mod alloc {
    use super::*;
    use crate::helpers::{take_byte_iter, take_num_iter};
    use ::alloc::{string::String, vec::Vec};

    impl Unpackable for Vec<u8> {
        type Error = Error;

        fn unpack(buf: &[u8]) -> Result<(usize, Self), Self::Error> {
            unpack_bytes(buf).map(|(n, b)| (n, b.to_vec()))
        }

        fn unpack_iter<I>(bytes: I) -> Result<(usize, Self), Self::Error>
        where
            I: IntoIterator<Item = u8>,
        {
            let mut bytes = bytes.into_iter();
            let format = take_byte_iter(bytes.by_ref())?;
            let (n, len) = match format {
                Format::BIN8 => (2, take_byte_iter(bytes.by_ref())? as usize),
                Format::BIN16 => (
                    3,
                    take_num_iter(bytes.by_ref(), u16::from_be_bytes)? as usize,
                ),
                Format::BIN32 => (
                    5,
                    take_num_iter(bytes.by_ref(), u32::from_be_bytes)? as usize,
                ),
                _ => return Err(Error::UnexpectedFormatTag),
            };
            let v: Vec<_> = bytes.take(len).collect();
            if v.len() < len {
                return Err(Error::BufferTooShort);
            }
            Ok((n + len, v))
        }
    }

    impl Unpackable for String {
        type Error = Error;

        fn unpack(buf: &[u8]) -> Result<(usize, Self), Self::Error> {
            unpack_str(buf).map(|(n, s)| (n, s.into()))
        }

        fn unpack_iter<I>(bytes: I) -> Result<(usize, Self), Self::Error>
        where
            I: IntoIterator<Item = u8>,
        {
            let mut bytes = bytes.into_iter();
            let format = take_byte_iter(bytes.by_ref())?;
            let (n, len) = match format {
                0xa0..=0xbf => (1, format as usize & 0x1f),
                Format::STR8 => (2, take_byte_iter(bytes.by_ref())? as usize),
                Format::STR16 => (
                    3,
                    take_num_iter(bytes.by_ref(), u16::from_be_bytes)? as usize,
                ),
                Format::STR32 => (
                    5,
                    take_num_iter(bytes.by_ref(), u32::from_be_bytes)? as usize,
                ),
                _ => return Err(Error::UnexpectedFormatTag),
            };
            let v: Vec<_> = bytes.take(len).collect();
            if v.len() < len {
                return Err(Error::BufferTooShort);
            }
            let s = String::from_utf8(v).map_err(|_| Error::InvalidUtf8)?;
            Ok((n + len, s))
        }
    }
}