weakauras_codec/
error.rs

1// Copyright 2025 Velithris
2// SPDX-License-Identifier: MIT
3
4use core::fmt;
5use std::{error, io::Error as IoError};
6
7use weakauras_codec_ace_serialize::error::{
8    DeserializationError as AceSerializeDeserializationError,
9    SerializationError as AceSerializeSerializationError,
10};
11use weakauras_codec_base64::error::{
12    DecodeError as Base64DecodeError, EncodeError as Base64EncodeError,
13};
14#[cfg(feature = "legacy-strings-decoding")]
15use weakauras_codec_lib_compress::error::DecompressionError as LibCompressDecompressionError;
16use weakauras_codec_lib_serialize::error::{
17    DeserializationError as LibSerializeDeserializationError,
18    SerializationError as LibSerializeSerializationError,
19};
20
21/// Errors than can occur while decoding.
22#[derive(Debug)]
23#[non_exhaustive]
24pub enum DecodeError {
25    #[cfg(not(feature = "legacy-strings-decoding"))]
26    /// The input does not start with a valid prefix.
27    InvalidPrefix,
28    /// The input is not a valid base64-string.
29    Base64DecodeError(Base64DecodeError),
30    #[cfg(feature = "legacy-strings-decoding")]
31    /// The input is not valid data compressed by LibCompress.
32    LibCompressDecompressionError(LibCompressDecompressionError),
33    /// An [io::Error](std::io::Error) occurred while decompressing supposedly DEFLATE-compressed data.
34    IoError(IoError),
35    /// The compressed data exceeds provided maximum size.
36    DataExceedsMaxSize,
37    /// The input is not valid data serialized by AceSerialize.
38    AceSerializeDeserializationError(AceSerializeDeserializationError),
39    /// The input is not valid data serialized by LibSerialize.
40    LibSerializeDeserializationError(LibSerializeDeserializationError),
41}
42
43impl From<Base64DecodeError> for DecodeError {
44    fn from(value: Base64DecodeError) -> Self {
45        Self::Base64DecodeError(value)
46    }
47}
48
49#[cfg(feature = "legacy-strings-decoding")]
50impl From<LibCompressDecompressionError> for DecodeError {
51    fn from(value: LibCompressDecompressionError) -> Self {
52        match value {
53            LibCompressDecompressionError::DataExceedsMaxSize => Self::DataExceedsMaxSize,
54            _ => Self::LibCompressDecompressionError(value),
55        }
56    }
57}
58
59impl From<IoError> for DecodeError {
60    fn from(value: IoError) -> Self {
61        Self::IoError(value)
62    }
63}
64
65impl From<AceSerializeDeserializationError> for DecodeError {
66    fn from(value: AceSerializeDeserializationError) -> Self {
67        Self::AceSerializeDeserializationError(value)
68    }
69}
70
71impl From<LibSerializeDeserializationError> for DecodeError {
72    fn from(value: LibSerializeDeserializationError) -> Self {
73        Self::LibSerializeDeserializationError(value)
74    }
75}
76
77impl fmt::Display for DecodeError {
78    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
79        match self {
80            #[cfg(not(feature = "legacy-strings-decoding"))]
81            Self::InvalidPrefix => write!(f, "Invalid prefix"),
82            Self::Base64DecodeError(inner) => write!(f, "Failed to decode base64: {}", inner),
83            #[cfg(feature = "legacy-strings-decoding")]
84            Self::LibCompressDecompressionError(inner) => {
85                write!(f, "Failed to decompress data: {}", inner)
86            }
87            Self::IoError(inner) => write!(f, "Failed to decompress data: {}", inner),
88            Self::DataExceedsMaxSize => write!(f, "Compressed data exceeds max size"),
89            Self::AceSerializeDeserializationError(inner) => {
90                write!(f, "Failed to deserialize data: {}", inner)
91            }
92            Self::LibSerializeDeserializationError(inner) => {
93                write!(f, "Failed to deserialize data: {}", inner)
94            }
95        }
96    }
97}
98
99impl error::Error for DecodeError {
100    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
101        match self {
102            #[cfg(not(feature = "legacy-strings-decoding"))]
103            Self::InvalidPrefix => None,
104            Self::Base64DecodeError(inner) => Some(inner),
105            #[cfg(feature = "legacy-strings-decoding")]
106            Self::LibCompressDecompressionError(inner) => Some(inner),
107            Self::IoError(inner) => Some(inner),
108            Self::DataExceedsMaxSize => None,
109            Self::AceSerializeDeserializationError(inner) => Some(inner),
110            Self::LibSerializeDeserializationError(inner) => Some(inner),
111        }
112    }
113}
114
115/// Errors than can occur while encoding.
116#[derive(Debug)]
117#[non_exhaustive]
118pub enum EncodeError {
119    /// The input cannot be base64-encoded.
120    Base64EncodeError(Base64EncodeError),
121    /// An [io::Error](std::io::Error) occurred while compressing using DEFLATE.
122    IoError(IoError),
123    /// The input cannot be serialized using AceSerialize.
124    AceSerializeSerializationError(AceSerializeSerializationError),
125    /// The input cannot be serialized using LibSerialize.
126    LibSerializeSerializationError(LibSerializeSerializationError),
127}
128
129impl From<Base64EncodeError> for EncodeError {
130    fn from(value: Base64EncodeError) -> Self {
131        Self::Base64EncodeError(value)
132    }
133}
134
135impl From<IoError> for EncodeError {
136    fn from(value: IoError) -> Self {
137        Self::IoError(value)
138    }
139}
140
141impl From<AceSerializeSerializationError> for EncodeError {
142    fn from(value: AceSerializeSerializationError) -> Self {
143        Self::AceSerializeSerializationError(value)
144    }
145}
146
147impl From<LibSerializeSerializationError> for EncodeError {
148    fn from(value: LibSerializeSerializationError) -> Self {
149        Self::LibSerializeSerializationError(value)
150    }
151}
152
153impl fmt::Display for EncodeError {
154    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
155        match self {
156            Self::Base64EncodeError(inner) => {
157                write!(f, "Failed to encode data as base64: {}", inner)
158            }
159            Self::IoError(inner) => write!(f, "Failed to compress data: {}", inner),
160            Self::AceSerializeSerializationError(inner) => {
161                write!(f, "Failed to serialize data: {}", inner)
162            }
163            Self::LibSerializeSerializationError(inner) => {
164                write!(f, "Failed to serialize data: {}", inner)
165            }
166        }
167    }
168}
169
170impl error::Error for EncodeError {
171    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
172        match self {
173            Self::Base64EncodeError(inner) => Some(inner),
174            Self::IoError(inner) => Some(inner),
175            Self::AceSerializeSerializationError(inner) => Some(inner),
176            Self::LibSerializeSerializationError(inner) => Some(inner),
177        }
178    }
179}
weakauras_codec/error.rs

weakauras_codec/
error.rs
