ax-codec-core 0.1.6

Core binary codec library with zero-copy decoding, varint encoding, and configurable decode limits
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

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EncodeError {
    InsufficientCapacity,
    LimitExceeded,
}

impl core::fmt::Display for EncodeError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            EncodeError::InsufficientCapacity => write!(f, "insufficient buffer capacity"),
            EncodeError::LimitExceeded => write!(f, "encoding limit exceeded"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DecodeError {
    UnexpectedEOF,
    InvalidVarint,
    InvalidUtf8,
    AllocationLimitExceeded,
    DepthLimitExceeded,
    InvalidBool,
    InvalidOptionTag,
    InvalidChecksum,
    InvalidVersion,
}

impl core::fmt::Display for DecodeError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            DecodeError::UnexpectedEOF => write!(f, "unexpected end of buffer"),
            DecodeError::InvalidVarint => write!(f, "invalid varint encoding"),
            DecodeError::InvalidUtf8 => write!(f, "invalid utf-8 sequence"),
            DecodeError::AllocationLimitExceeded => write!(f, "allocation limit exceeded"),
            DecodeError::DepthLimitExceeded => write!(f, "depth limit exceeded"),
            DecodeError::InvalidBool => write!(f, "invalid boolean value"),
            DecodeError::InvalidOptionTag => write!(f, "invalid option tag"),
            DecodeError::InvalidChecksum => write!(f, "checksum mismatch"),
            DecodeError::InvalidVersion => write!(f, "unsupported wire format version"),
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for EncodeError {}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ValidateError {
    UnexpectedEOF,
    InvalidVarint,
    InvalidUtf8,
    AllocationLimitExceeded,
    DepthLimitExceeded,
    InvalidBool,
    InvalidOptionTag,
    InvalidChecksum,
    InvalidVersion,
}

impl core::fmt::Display for ValidateError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            ValidateError::UnexpectedEOF => write!(f, "unexpected end of buffer"),
            ValidateError::InvalidVarint => write!(f, "invalid varint encoding"),
            ValidateError::InvalidUtf8 => write!(f, "invalid utf-8 sequence"),
            ValidateError::AllocationLimitExceeded => write!(f, "allocation limit exceeded"),
            ValidateError::DepthLimitExceeded => write!(f, "depth limit exceeded"),
            ValidateError::InvalidBool => write!(f, "invalid boolean value"),
            ValidateError::InvalidOptionTag => write!(f, "invalid option tag"),
            ValidateError::InvalidChecksum => write!(f, "checksum mismatch"),
            ValidateError::InvalidVersion => write!(f, "unsupported wire format version"),
        }
    }
}

impl From<DecodeError> for ValidateError {
    fn from(e: DecodeError) -> Self {
        match e {
            DecodeError::UnexpectedEOF => ValidateError::UnexpectedEOF,
            DecodeError::InvalidVarint => ValidateError::InvalidVarint,
            DecodeError::InvalidUtf8 => ValidateError::InvalidUtf8,
            DecodeError::AllocationLimitExceeded => ValidateError::AllocationLimitExceeded,
            DecodeError::DepthLimitExceeded => ValidateError::DepthLimitExceeded,
            DecodeError::InvalidBool => ValidateError::InvalidBool,
            DecodeError::InvalidOptionTag => ValidateError::InvalidOptionTag,
            DecodeError::InvalidChecksum => ValidateError::InvalidChecksum,
            DecodeError::InvalidVersion => ValidateError::InvalidVersion,
        }
    }
}

#[cfg(feature = "std")]
impl std::error::Error for ValidateError {}

#[cfg(feature = "std")]
impl std::error::Error for DecodeError {}