worterbuch_codec/
error.rs

1use crate::{
2    ErrorCode, KeyLength, MessageType, MetaDataLength, NumGraveGoods, NumKeyValuePairs, PathLength,
3    RequestPatternLength, ValueLength,
4};
5use std::{fmt, io, string::FromUtf8Error};
6
7#[derive(Debug)]
8pub enum DecodeError {
9    UndefinedType(MessageType),
10    IoError(io::Error),
11    FromUtf8Error(FromUtf8Error),
12    UndefinedErrorCode(ErrorCode),
13    SerDeError(serde_json::Error),
14}
15
16impl std::error::Error for DecodeError {}
17
18impl fmt::Display for DecodeError {
19    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20        match self {
21            DecodeError::UndefinedType(mtype) => write!(f, "undefined message type: {mtype})",),
22            DecodeError::IoError(e) => e.fmt(f),
23            DecodeError::FromUtf8Error(e) => e.fmt(f),
24            DecodeError::SerDeError(e) => e.fmt(f),
25            DecodeError::UndefinedErrorCode(error_code) => {
26                write!(f, "undefined error code: {error_code})",)
27            }
28        }
29    }
30}
31
32impl From<io::Error> for DecodeError {
33    fn from(e: io::Error) -> Self {
34        DecodeError::IoError(e)
35    }
36}
37
38impl From<FromUtf8Error> for DecodeError {
39    fn from(e: FromUtf8Error) -> Self {
40        DecodeError::FromUtf8Error(e)
41    }
42}
43
44impl From<serde_json::Error> for DecodeError {
45    fn from(e: serde_json::Error) -> Self {
46        DecodeError::SerDeError(e)
47    }
48}
49
50pub type DecodeResult<T> = std::result::Result<T, DecodeError>;
51
52#[derive(Debug)]
53pub enum EncodeError {
54    RequestPatternTooLong(usize),
55    KeyTooLong(usize),
56    ValueTooLong(usize),
57    MetaDataTooLong(usize),
58    PathTooLong(usize),
59    TooManyKeyValuePairs(usize),
60    TooManyProtocolVersions(usize),
61    TooManyLastWills(usize),
62    TooManyGraveGoods(usize),
63    IoError(io::Error),
64    MessageTooLarge(u64),
65}
66
67impl std::error::Error for EncodeError {}
68
69impl fmt::Display for EncodeError {
70    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
71        match self {
72            EncodeError::RequestPatternTooLong(len) => write!(
73                f,
74                "request pattern is too long : {} bytes (max {} bytes allowed)",
75                len,
76                RequestPatternLength::MAX
77            ),
78            EncodeError::KeyTooLong(len) => write!(
79                f,
80                "key is too long : {} bytes (max {} bytes allowed)",
81                len,
82                KeyLength::MAX
83            ),
84            EncodeError::ValueTooLong(len) => write!(
85                f,
86                "value is too long : {} bytes (max {} bytes allowed)",
87                len,
88                ValueLength::MAX
89            ),
90            EncodeError::MetaDataTooLong(len) => write!(
91                f,
92                "meta data is too long : {} bytes (max {} bytes allowed)",
93                len,
94                MetaDataLength::MAX
95            ),
96            EncodeError::PathTooLong(len) => write!(
97                f,
98                "path is too long : {} bytes (max {} bytes allowed)",
99                len,
100                PathLength::MAX
101            ),
102            EncodeError::TooManyKeyValuePairs(len) => write!(
103                f,
104                "too many key/value pairs: {} (max {} allowed)",
105                len,
106                NumKeyValuePairs::MAX
107            ),
108            EncodeError::TooManyProtocolVersions(len) => write!(
109                f,
110                "too many supported protocol versions pairs: {} (max {} allowed)",
111                len,
112                NumKeyValuePairs::MAX
113            ),
114            EncodeError::TooManyLastWills(len) => write!(
115                f,
116                "too many last will key/value pairs: {} (max {} allowed)",
117                len,
118                NumGraveGoods::MAX
119            ),
120            EncodeError::TooManyGraveGoods(len) => write!(
121                f,
122                "too many grave goods: {} (max {} allowed)",
123                len,
124                NumGraveGoods::MAX
125            ),
126            EncodeError::MessageTooLarge(len) => write!(
127                f,
128                "message is too large: {} (max {} allowed)",
129                len,
130                MetaDataLength::MAX
131            ),
132            EncodeError::IoError(ioe) => ioe.fmt(f),
133        }
134    }
135}
136
137impl From<io::Error> for EncodeError {
138    fn from(e: io::Error) -> Self {
139        EncodeError::IoError(e)
140    }
141}
142
143pub type EncodeResult<T> = std::result::Result<T, EncodeError>;
worterbuch_codec/error.rs

worterbuch_codec/
error.rs
