zerompk 0.4.1

A zero-copy, zero-dependency, no_std-compatible, extremely fast MessagePack serializer 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

use core::fmt::Display;

#[derive(Debug)]
pub enum Error {
    InvalidMarker(u8),
    InvalidChar(u32),
    InvalidUtf8(core::str::Utf8Error),
    BufferTooSmall,
    CannotBorrow,
    ArrayLengthMismatch {
        expected: usize,
        actual: usize,
    },
    MapLengthMismatch {
        expected: usize,
        actual: usize,
    },
    UnknownKey(alloc::string::String),
    KeyNotFound(alloc::string::String),
    KeyDuplicated(alloc::string::String),
    InvalidTimestamp,
    DepthLimitExceeded {
        max: usize,
    },
    #[cfg(feature = "std")]
    IoError(std::io::Error),
}

pub type Result<T> = core::result::Result<T, Error>;

impl Display for Error {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Error::InvalidMarker(byte) => write!(f, "Invalid marker: {}", byte),
            Error::InvalidChar(code) => write!(f, "Invalid char code: {}", code),
            Error::BufferTooSmall => write!(f, "Buffer too small"),
            Error::InvalidUtf8(err) => write!(f, "Invalid UTF-8: {}", err),
            Error::CannotBorrow => write!(f, "Cannot borrow data from original buffer"),
            Error::ArrayLengthMismatch { expected, actual } => {
                write!(
                    f,
                    "Array length mismatch: expected {}, actual {}",
                    expected, actual
                )
            }
            Error::MapLengthMismatch { expected, actual } => {
                write!(
                    f,
                    "Map length mismatch: expected {}, actual {}",
                    expected, actual
                )
            }
            Error::UnknownKey(key) => {
                write!(f, "Unknown key '{}'", key)
            }
            Error::KeyNotFound(key) => {
                write!(f, "Key '{}' not found", key)
            }
            Error::KeyDuplicated(key) => {
                write!(f, "Key '{}' is duplicated", key)
            }
            Error::InvalidTimestamp => write!(f, "Invalid timestamp value"),
            Error::DepthLimitExceeded { max } => {
                write!(f, "Maximum deserialization depth exceeded (max: {})", max)
            }
            #[cfg(feature = "std")]
            Error::IoError(err) => err.fmt(f),
        }
    }
}

impl core::error::Error for Error {}