msgpacker 0.7.1

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use alloc::{string::String, vec::Vec};
use core::str;

use crate::{
    format::Format,
    helpers::{take_buffer_iter, take_byte, take_byte_iter, take_num, take_num_iter},
    Error, Unpackable,
};

/// Unpacks msgpack nil as `None`, or binary data as `Some(&[u8])`.
pub fn unpack_bytes_option_ref(buf: &[u8]) -> Result<(usize, Option<&[u8]>), Error> {
    if buf.first() == Some(&Format::NIL) {
        Ok((1, None))
    } else {
        unpack_bytes(buf).map(|(n, t)| (n, Some(t)))
    }
}

/// Unpacks msgpack nil as `None`, or binary data as `Some(Vec<u8>)`.
pub fn unpack_bytes_option(buf: &[u8]) -> Result<(usize, Option<Vec<u8>>), Error> {
    unpack_bytes_option_ref(buf).map(|(n, t)| (n, t.map(<[u8]>::to_vec)))
}

/// Iterator-based version: unpacks nil as `None`, binary data as `Some(Vec<u8>)`.
pub fn unpack_bytes_option_iter<I>(bytes: I) -> Result<(usize, Option<Vec<u8>>), Error>
where
    I: IntoIterator<Item = u8>,
{
    let mut bytes = bytes.into_iter();
    let first = bytes.next().ok_or(Error::BufferTooShort)?;
    if first == Format::NIL {
        return Ok((1, None));
    }
    let (n, len) = match first {
        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 data = take_buffer_iter(bytes, len)?;
    Ok((n + len, Some(data)))
}

/// Unpack bytes on binary format
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]))
}

/// Unpack bytes on binary format using an iterator implementation.
pub fn unpack_bytes_iter<I>(bytes: I) -> Result<(usize, Vec<u8>), 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 data = take_buffer_iter(bytes, len)?;
    Ok((n + len, data))
}

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))
}

impl Unpackable for String {
    type Error = Error;

    fn unpack_with_ofs(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))
    }
}