wacore_binary/
error.rs

1use std::fmt;
2
3use crate::jid::JidError;
4
5#[derive(Debug)]
6pub enum BinaryError {
7    Io(std::io::Error),
8    InvalidToken(u8),
9    InvalidNode,
10    NonStringKey,
11    AttrParse(String),
12    InvalidUtf8(std::str::Utf8Error),
13    Zlib(String),
14    Jid(JidError),
15    Eof,
16    LeftoverData(usize),
17    AttrList(Vec<BinaryError>),
18}
19
20impl fmt::Display for BinaryError {
21    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
22        match self {
23            BinaryError::Io(e) => write!(f, "I/O error: {e}"),
24            BinaryError::InvalidToken(t) => write!(f, "Invalid token read from stream: {t}"),
25            BinaryError::InvalidNode => write!(f, "Invalid node format"),
26            BinaryError::NonStringKey => write!(f, "Attribute key was not a string"),
27            BinaryError::AttrParse(s) => write!(f, "Attribute parsing failed: {s}"),
28            BinaryError::InvalidUtf8(e) => write!(f, "Data is not valid UTF-8: {e}"),
29            BinaryError::Zlib(s) => write!(f, "Zlib decompression error: {s}"),
30            BinaryError::Jid(e) => write!(f, "JID parsing error: {e}"),
31            BinaryError::Eof => write!(f, "Reached end of file unexpectedly"),
32            BinaryError::LeftoverData(n) => write!(f, "Leftover data after decoding: {n} bytes"),
33            BinaryError::AttrList(list) => write!(f, "Multiple attribute parsing errors: {list:?}"),
34        }
35    }
36}
37
38impl std::error::Error for BinaryError {
39    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
40        match self {
41            BinaryError::Io(e) => Some(e),
42            BinaryError::InvalidUtf8(e) => Some(e),
43            BinaryError::Jid(e) => Some(e),
44            _ => None,
45        }
46    }
47}
48
49impl From<std::io::Error> for BinaryError {
50    fn from(err: std::io::Error) -> Self {
51        BinaryError::Io(err)
52    }
53}
54impl From<std::str::Utf8Error> for BinaryError {
55    fn from(err: std::str::Utf8Error) -> Self {
56        BinaryError::InvalidUtf8(err)
57    }
58}
59impl From<JidError> for BinaryError {
60    fn from(err: JidError) -> Self {
61        BinaryError::Jid(err)
62    }
63}
64impl Clone for BinaryError {
65    fn clone(&self) -> Self {
66        match self {
67            BinaryError::Io(e) => BinaryError::Io(std::io::Error::new(e.kind(), e.to_string())),
68            BinaryError::InvalidToken(u) => BinaryError::InvalidToken(*u),
69            BinaryError::InvalidNode => BinaryError::InvalidNode,
70            BinaryError::NonStringKey => BinaryError::NonStringKey,
71            BinaryError::AttrParse(s) => BinaryError::AttrParse(s.clone()),
72            BinaryError::InvalidUtf8(e) => BinaryError::InvalidUtf8(*e),
73            BinaryError::Zlib(s) => BinaryError::Zlib(s.clone()),
74            BinaryError::Jid(e) => BinaryError::Jid(JidError::InvalidFormat(e.to_string())),
75            BinaryError::Eof => BinaryError::Eof,
76            BinaryError::LeftoverData(n) => BinaryError::LeftoverData(*n),
77            BinaryError::AttrList(list) => BinaryError::AttrList(list.clone()),
78        }
79    }
80}
81
82pub type Result<T> = std::result::Result<T, BinaryError>;