rss 0.5.0

Library for serializing the RSS web content syndication format
Documentation 
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

// This file is part of rss.
//
// Copyright © 2015-2017 The rust-syndication Developers
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the MIT License and/or Apache 2.0 License.

use chrono::ParseError as DateParseError;
use quick_xml::error::Error as XmlError;
use std::error::Error as StdError;
use std::fmt;
use std::io::Error as IOError;
use std::num::ParseIntError;
use std::str::Utf8Error;
use std::string::FromUtf8Error;
use url::ParseError as UrlParseError;

#[derive(Debug)]
/// Types of errors that could occur while parsing an RSS feed.
pub enum Error {
    /// An error occured during validation
    Validation(String),
    /// An error occured while reading channel from url.
    FromUrl(String),
    /// An error occured while reading url to string.
    IO(IOError),
    /// An error occurred during the web request.
    #[cfg(feature = "from_url")]
    ReqParsing(::reqwest::Error),
    /// An error occured while parsing a str to i64.
    IntParsing(ParseIntError),
    /// An error occured during parsing dates from str.
    DateParsing(DateParseError),
    /// An error occurred while parsing a str to Url.
    UrlParsing(UrlParseError),
    /// An error occurred while converting bytes to UTF8.
    Utf8(Utf8Error),
    /// An XML parser error occurred at the specified byte offset.
    XmlParsing(XmlError, usize),
    /// An XML error occurred.
    Xml(XmlError),
    /// The end of the input was reached without finding a complete channel element.
    EOF,
}

impl StdError for Error {
    fn description(&self) -> &str {
        match *self {
            Error::Validation(ref err) => err,
            Error::FromUrl(ref err) => err,
            Error::IO(ref err) => err.description(),
            #[cfg(feature = "from_url")]
            Error::ReqParsing(ref err) => err.description(),
            Error::IntParsing(ref err) => err.description(),
            Error::DateParsing(ref err) => err.description(),
            Error::UrlParsing(ref err) => err.description(),
            Error::Utf8(ref err) => err.description(),
            Error::XmlParsing(ref err, _) => err.description(),
            Error::Xml(ref err) => err.description(),
            Error::EOF => "reached end of input without finding a complete channel",
        }
    }

    fn cause(&self) -> Option<&StdError> {
        match *self {
            Error::IO(ref err) => Some(err),
            #[cfg(feature = "from_url")]
            Error::ReqParsing(ref err) => Some(err),
            Error::IntParsing(ref err) => Some(err),
            Error::DateParsing(ref err) => Some(err),
            Error::UrlParsing(ref err) => Some(err),
            Error::Utf8(ref err) => Some(err),
            Error::XmlParsing(ref err, _) => Some(err),
            Error::Xml(ref err) => Some(err),
            _ => None,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::Validation(ref err) => fmt::Display::fmt(err, f),
            Error::FromUrl(ref err) => fmt::Display::fmt(err, f),
            Error::IO(ref err) => fmt::Display::fmt(err, f),
            #[cfg(feature = "from_url")]
            Error::ReqParsing(ref err) => fmt::Display::fmt(err, f),
            Error::IntParsing(ref err) => fmt::Display::fmt(err, f),
            Error::DateParsing(ref err) => fmt::Display::fmt(err, f),
            Error::UrlParsing(ref err) => fmt::Display::fmt(err, f),
            Error::Utf8(ref err) => fmt::Display::fmt(err, f),
            Error::XmlParsing(ref err, _) => fmt::Display::fmt(err, f),
            Error::Xml(ref err) => fmt::Display::fmt(err, f),
            Error::EOF => write!(f, "reached end of input without finding a complete channel"),
        }
    }
}

impl From<(XmlError, usize)> for Error {
    fn from(err: (XmlError, usize)) -> Error {
        Error::XmlParsing(err.0, err.1)
    }
}

impl From<XmlError> for Error {
    fn from(err: XmlError) -> Error {
        Error::Xml(err)
    }
}

impl From<Utf8Error> for Error {
    fn from(err: Utf8Error) -> Error {
        Error::Utf8(err)
    }
}

impl From<FromUtf8Error> for Error {
    fn from(err: FromUtf8Error) -> Error {
        Error::Utf8(err.utf8_error())
    }
}

impl From<UrlParseError> for Error {
    fn from(err: UrlParseError) -> Error {
        Error::UrlParsing(err)
    }
}

impl From<DateParseError> for Error {
    fn from(err: DateParseError) -> Error {
        Error::DateParsing(err)
    }
}

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

#[cfg(feature = "from_url")]
impl From<::reqwest::Error> for Error {
    fn from(err: ::reqwest::Error) -> Error {
        Error::ReqParsing(err)
    }
}


impl From<IOError> for Error {
    fn from(err: IOError) -> Error {
        Error::IO(err)
    }
}