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

// Copyright (c) 2017-2018 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use std::error::Error as StdError;
use std::fmt;

/// Contains one of the potential errors triggered while parsing an
/// [Element](../struct.Element.html) into a specialised struct.
#[derive(Debug)]
pub enum Error {
    /// The usual error when parsing something.
    ///
    /// TODO: use a structured error so the user can report it better, instead
    /// of a freeform string.
    ParseError(&'static str),

    /// Element local-name/namespace mismatch
    ///
    /// Returns the original element unaltered, as well as the expected ns and
    /// local-name.
    TypeMismatch(&'static str, &'static str, crate::Element),

    /// Generated when some base64 content fails to decode, usually due to
    /// extra characters.
    Base64Error(base64::DecodeError),

    /// Generated when text which should be an integer fails to parse.
    ParseIntError(std::num::ParseIntError),

    /// Generated when text which should be a string fails to parse.
    ParseStringError(std::string::ParseError),

    /// Generated when text which should be an IP address (IPv4 or IPv6) fails
    /// to parse.
    ParseAddrError(std::net::AddrParseError),

    /// Generated when text which should be a [JID](../../jid/struct.Jid.html)
    /// fails to parse.
    JidParseError(jid::Error),

    /// Generated when text which should be a
    /// [DateTime](../date/struct.DateTime.html) fails to parse.
    ChronoParseError(chrono::ParseError),
}

impl Error {
    /// Converts the TypeMismatch error to a generic ParseError
    ///
    /// This must be used when TryFrom is called on children to avoid confusing
    /// user code which assumes that TypeMismatch refers to the top level
    /// element only.
    pub(crate) fn hide_type_mismatch(self) -> Self {
        match self {
            Error::TypeMismatch(..) => Error::ParseError("Unexpected child element"),
            other => other,
        }
    }
}

impl StdError for Error {
    fn cause(&self) -> Option<&dyn StdError> {
        match self {
            Error::ParseError(_) | Error::TypeMismatch(..) => None,
            Error::Base64Error(e) => Some(e),
            Error::ParseIntError(e) => Some(e),
            Error::ParseStringError(e) => Some(e),
            Error::ParseAddrError(e) => Some(e),
            Error::JidParseError(e) => Some(e),
            Error::ChronoParseError(e) => Some(e),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Error::ParseError(s) => write!(fmt, "parse error: {}", s),
            Error::TypeMismatch(ns, localname, element) => write!(
                fmt,
                "element type mismatch: expected {{{}}}{}, got {{{}}}{}",
                ns,
                localname,
                element.ns(),
                element.name()
            ),
            Error::Base64Error(e) => write!(fmt, "base64 error: {}", e),
            Error::ParseIntError(e) => write!(fmt, "integer parsing error: {}", e),
            Error::ParseStringError(e) => write!(fmt, "string parsing error: {}", e),
            Error::ParseAddrError(e) => write!(fmt, "IP address parsing error: {}", e),
            Error::JidParseError(e) => write!(fmt, "JID parsing error: {}", e),
            Error::ChronoParseError(e) => write!(fmt, "time parsing error: {}", e),
        }
    }
}

impl From<base64::DecodeError> for Error {
    fn from(err: base64::DecodeError) -> Error {
        Error::Base64Error(err)
    }
}

impl From<std::num::ParseIntError> for Error {
    fn from(err: std::num::ParseIntError) -> Error {
        Error::ParseIntError(err)
    }
}

impl From<std::string::ParseError> for Error {
    fn from(err: std::string::ParseError) -> Error {
        Error::ParseStringError(err)
    }
}

impl From<std::net::AddrParseError> for Error {
    fn from(err: std::net::AddrParseError) -> Error {
        Error::ParseAddrError(err)
    }
}

impl From<jid::Error> for Error {
    fn from(err: jid::Error) -> Error {
        Error::JidParseError(err)
    }
}

impl From<chrono::ParseError> for Error {
    fn from(err: chrono::ParseError) -> Error {
        Error::ChronoParseError(err)
    }
}

impl From<Error> for xso::error::Error {
    fn from(other: Error) -> Self {
        match other {
            Error::ParseError(e) => Self::Other(e.to_string().into()),
            Error::TypeMismatch { .. } => Self::TypeMismatch,
            Error::Base64Error(e) => Self::TextParseError(Box::new(e)),
            Error::ParseIntError(e) => Self::TextParseError(Box::new(e)),
            Error::ParseStringError(e) => Self::TextParseError(Box::new(e)),
            Error::ParseAddrError(e) => Self::TextParseError(Box::new(e)),
            Error::JidParseError(e) => Self::TextParseError(Box::new(e)),
            Error::ChronoParseError(e) => Self::TextParseError(Box::new(e)),
        }
    }
}