forked from tafia/quick-xml
/
errors.rs
286 lines (262 loc) · 9.68 KB
/
errors.rs
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
//! Error management module
use crate::escape::EscapeError;
use crate::events::attributes::AttrError;
use crate::utils::write_byte_string;
use std::str::Utf8Error;
use std::string::FromUtf8Error;
/// The error type used by this crate.
#[derive(Debug)]
pub enum Error {
/// IO error
Io(::std::io::Error),
/// Input decoding error. If `encoding` feature is disabled, contains `None`,
/// otherwise contains the UTF-8 decoding error
NonDecodable(Option<Utf8Error>),
/// Unexpected End of File
UnexpectedEof(String),
/// End event mismatch
EndEventMismatch {
/// Expected end event
expected: String,
/// Found end event
found: String,
},
/// Unexpected token
UnexpectedToken(String),
/// Unexpected <!>
UnexpectedBang(u8),
/// Text not found, expected `Event::Text`
TextNotFound,
/// `Event::XmlDecl` must start with *version* attribute
XmlDeclWithoutVersion(Option<String>),
/// Attribute parsing error
InvalidAttr(AttrError),
/// Escape error
EscapeError(EscapeError),
/// Specified namespace prefix is unknown, cannot resolve namespace for it
UnknownPrefix(Vec<u8>),
}
impl From<::std::io::Error> for Error {
/// Creates a new `Error::Io` from the given error
#[inline]
fn from(error: ::std::io::Error) -> Error {
Error::Io(error)
}
}
impl From<Utf8Error> for Error {
/// Creates a new `Error::NonDecodable` from the given error
#[inline]
fn from(error: Utf8Error) -> Error {
Error::NonDecodable(Some(error))
}
}
impl From<FromUtf8Error> for Error {
/// Creates a new `Error::Utf8` from the given error
#[inline]
fn from(error: FromUtf8Error) -> Error {
error.utf8_error().into()
}
}
impl From<EscapeError> for Error {
/// Creates a new `Error::EscapeError` from the given error
#[inline]
fn from(error: EscapeError) -> Error {
Error::EscapeError(error)
}
}
impl From<AttrError> for Error {
#[inline]
fn from(error: AttrError) -> Self {
Error::InvalidAttr(error)
}
}
/// A specialized `Result` type where the error is hard-wired to [`Error`].
pub type Result<T> = std::result::Result<T, Error>;
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Error::Io(e) => write!(f, "I/O error: {}", e),
Error::NonDecodable(None) => write!(f, "Malformed input, decoding impossible"),
Error::NonDecodable(Some(e)) => write!(f, "Malformed UTF-8 input: {}", e),
Error::UnexpectedEof(e) => write!(f, "Unexpected EOF during reading {}", e),
Error::EndEventMismatch { expected, found } => {
write!(f, "Expecting </{}> found </{}>", expected, found)
}
Error::UnexpectedToken(e) => write!(f, "Unexpected token '{}'", e),
Error::UnexpectedBang(b) => write!(
f,
"Only Comment (`--`), CDATA (`[CDATA[`) and DOCTYPE (`DOCTYPE`) nodes can start with a '!', but symbol `{}` found",
*b as char
),
Error::TextNotFound => write!(f, "Cannot read text, expecting Event::Text"),
Error::XmlDeclWithoutVersion(e) => write!(
f,
"XmlDecl must start with 'version' attribute, found {:?}",
e
),
Error::InvalidAttr(e) => write!(f, "error while parsing attribute: {}", e),
Error::EscapeError(e) => write!(f, "{}", e),
Error::UnknownPrefix(prefix) => {
f.write_str("Unknown namespace prefix '")?;
write_byte_string(f, &prefix)?;
f.write_str("'")
}
}
}
}
impl std::error::Error for Error {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
Error::Io(e) => Some(e),
Error::NonDecodable(Some(e)) => Some(e),
Error::InvalidAttr(e) => Some(e),
Error::EscapeError(e) => Some(e),
_ => None,
}
}
}
#[cfg(feature = "serialize")]
pub mod serialize {
//! A module to handle serde (de)serialization errors
use super::*;
use crate::utils::write_byte_string;
use std::fmt;
#[cfg(feature = "overlapped-lists")]
use std::num::NonZeroUsize;
use std::num::{ParseFloatError, ParseIntError};
/// (De)serialization error
#[derive(Debug)]
pub enum DeError {
/// Serde custom error
Custom(String),
/// Xml parsing error
InvalidXml(Error),
/// Cannot parse to integer
InvalidInt(ParseIntError),
/// Cannot parse to float
InvalidFloat(ParseFloatError),
/// Cannot parse specified value to boolean
InvalidBoolean(String),
/// This error indicates an error in the [`Deserialize`](serde::Deserialize)
/// implementation when read a map or a struct: `MapAccess::next_value[_seed]`
/// was called before `MapAccess::next_key[_seed]`.
///
/// You should check your types, that implements corresponding trait.
KeyNotRead,
/// Deserializer encounter a start tag with a specified name when it is
/// not expecting. This happens when you try to deserialize a primitive
/// value (numbers, strings, booleans) from an XML element.
UnexpectedStart(Vec<u8>),
/// Deserializer encounter an end tag with a specified name when it is
/// not expecting. Usually that should not be possible, because XML reader
/// is not able to produce such stream of events that lead to this error.
///
/// If you get this error this likely indicates and error in the `quick_xml`.
/// Please open an issue at <https://github.com/tafia/quick-xml>, provide
/// your Rust code and XML input.
UnexpectedEnd(Vec<u8>),
/// Unexpected end of file
UnexpectedEof,
/// This error indicates that [`deserialize_struct`] was called, but there
/// is no any XML element in the input. That means that you try to deserialize
/// a struct not from an XML element.
///
/// [`deserialize_struct`]: serde::de::Deserializer::deserialize_struct
ExpectedStart,
/// Unsupported operation
Unsupported(&'static str),
/// Too many events were skipped while deserializing a sequence, event limit
/// exceeded. The limit was provided as an argument
#[cfg(feature = "overlapped-lists")]
TooManyEvents(NonZeroUsize),
}
impl fmt::Display for DeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
DeError::Custom(s) => write!(f, "{}", s),
DeError::InvalidXml(e) => write!(f, "{}", e),
DeError::InvalidInt(e) => write!(f, "{}", e),
DeError::InvalidFloat(e) => write!(f, "{}", e),
DeError::InvalidBoolean(v) => write!(f, "Invalid boolean value '{}'", v),
DeError::KeyNotRead => write!(f, "Invalid `Deserialize` implementation: `MapAccess::next_value[_seed]` was called before `MapAccess::next_key[_seed]`"),
DeError::UnexpectedStart(e) => {
f.write_str("Unexpected `Event::Start(")?;
write_byte_string(f, &e)?;
f.write_str(")`")
}
DeError::UnexpectedEnd(e) => {
f.write_str("Unexpected `Event::End(")?;
write_byte_string(f, &e)?;
f.write_str(")`")
}
DeError::UnexpectedEof => write!(f, "Unexpected `Event::Eof`"),
DeError::ExpectedStart => write!(f, "Expecting `Event::Start`"),
DeError::Unsupported(s) => write!(f, "Unsupported operation {}", s),
#[cfg(feature = "overlapped-lists")]
DeError::TooManyEvents(s) => write!(f, "Deserializer buffers {} events, limit exceeded", s),
}
}
}
impl ::std::error::Error for DeError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
match self {
DeError::InvalidXml(e) => Some(e),
DeError::InvalidInt(e) => Some(e),
DeError::InvalidFloat(e) => Some(e),
_ => None,
}
}
}
impl serde::de::Error for DeError {
fn custom<T: fmt::Display>(msg: T) -> Self {
DeError::Custom(msg.to_string())
}
}
impl serde::ser::Error for DeError {
fn custom<T: fmt::Display>(msg: T) -> Self {
DeError::Custom(msg.to_string())
}
}
impl From<Error> for DeError {
#[inline]
fn from(e: Error) -> Self {
Self::InvalidXml(e)
}
}
impl From<EscapeError> for DeError {
#[inline]
fn from(e: EscapeError) -> Self {
Self::InvalidXml(e.into())
}
}
impl From<Utf8Error> for DeError {
#[inline]
fn from(e: Utf8Error) -> Self {
Self::InvalidXml(e.into())
}
}
impl From<FromUtf8Error> for DeError {
#[inline]
fn from(e: FromUtf8Error) -> Self {
Self::InvalidXml(e.into())
}
}
impl From<AttrError> for DeError {
#[inline]
fn from(e: AttrError) -> Self {
Self::InvalidXml(e.into())
}
}
impl From<ParseIntError> for DeError {
#[inline]
fn from(e: ParseIntError) -> Self {
Self::InvalidInt(e)
}
}
impl From<ParseFloatError> for DeError {
#[inline]
fn from(e: ParseFloatError) -> Self {
Self::InvalidFloat(e)
}
}
}