Skip to main content

ax_codec_core/
error.rs

1#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2pub enum EncodeError {
3    InsufficientCapacity,
4    LimitExceeded,
5}
6
7impl core::fmt::Display for EncodeError {
8    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9        match self {
10            EncodeError::InsufficientCapacity => write!(f, "insufficient buffer capacity"),
11            EncodeError::LimitExceeded => write!(f, "encoding limit exceeded"),
12        }
13    }
14}
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17pub enum DecodeError {
18    UnexpectedEOF,
19    InvalidVarint,
20    InvalidUtf8,
21    AllocationLimitExceeded,
22    DepthLimitExceeded,
23    InvalidBool,
24    InvalidOptionTag,
25    InvalidChecksum,
26    InvalidVersion,
27}
28
29impl core::fmt::Display for DecodeError {
30    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
31        match self {
32            DecodeError::UnexpectedEOF => write!(f, "unexpected end of buffer"),
33            DecodeError::InvalidVarint => write!(f, "invalid varint encoding"),
34            DecodeError::InvalidUtf8 => write!(f, "invalid utf-8 sequence"),
35            DecodeError::AllocationLimitExceeded => write!(f, "allocation limit exceeded"),
36            DecodeError::DepthLimitExceeded => write!(f, "depth limit exceeded"),
37            DecodeError::InvalidBool => write!(f, "invalid boolean value"),
38            DecodeError::InvalidOptionTag => write!(f, "invalid option tag"),
39            DecodeError::InvalidChecksum => write!(f, "checksum mismatch"),
40            DecodeError::InvalidVersion => write!(f, "unsupported wire format version"),
41        }
42    }
43}
44
45#[cfg(feature = "std")]
46impl std::error::Error for EncodeError {}
47
48#[derive(Debug, Clone, Copy, PartialEq, Eq)]
49pub enum ValidateError {
50    UnexpectedEOF,
51    InvalidVarint,
52    InvalidUtf8,
53    AllocationLimitExceeded,
54    DepthLimitExceeded,
55    InvalidBool,
56    InvalidOptionTag,
57    InvalidChecksum,
58    InvalidVersion,
59}
60
61impl core::fmt::Display for ValidateError {
62    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
63        match self {
64            ValidateError::UnexpectedEOF => write!(f, "unexpected end of buffer"),
65            ValidateError::InvalidVarint => write!(f, "invalid varint encoding"),
66            ValidateError::InvalidUtf8 => write!(f, "invalid utf-8 sequence"),
67            ValidateError::AllocationLimitExceeded => write!(f, "allocation limit exceeded"),
68            ValidateError::DepthLimitExceeded => write!(f, "depth limit exceeded"),
69            ValidateError::InvalidBool => write!(f, "invalid boolean value"),
70            ValidateError::InvalidOptionTag => write!(f, "invalid option tag"),
71            ValidateError::InvalidChecksum => write!(f, "checksum mismatch"),
72            ValidateError::InvalidVersion => write!(f, "unsupported wire format version"),
73        }
74    }
75}
76
77impl From<DecodeError> for ValidateError {
78    fn from(e: DecodeError) -> Self {
79        match e {
80            DecodeError::UnexpectedEOF => ValidateError::UnexpectedEOF,
81            DecodeError::InvalidVarint => ValidateError::InvalidVarint,
82            DecodeError::InvalidUtf8 => ValidateError::InvalidUtf8,
83            DecodeError::AllocationLimitExceeded => ValidateError::AllocationLimitExceeded,
84            DecodeError::DepthLimitExceeded => ValidateError::DepthLimitExceeded,
85            DecodeError::InvalidBool => ValidateError::InvalidBool,
86            DecodeError::InvalidOptionTag => ValidateError::InvalidOptionTag,
87            DecodeError::InvalidChecksum => ValidateError::InvalidChecksum,
88            DecodeError::InvalidVersion => ValidateError::InvalidVersion,
89        }
90    }
91}
92
93#[cfg(feature = "std")]
94impl std::error::Error for ValidateError {}
95
96#[cfg(feature = "std")]
97impl std::error::Error for DecodeError {}