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
#![allow(dead_code)]
use std::error;
use std::io;
use std::fmt;
use std::num;
use std::result;
use std::str;
use std::string;
pub type Result<T> = result::Result<T, Error>;
#[derive(Debug)]
pub enum Error {
ConfigFileIO(io::Error),
ConfigFileSyntax(String),
ConfigInvalidArray(&'static str),
ConfigInvalidIpv4Addr(&'static str),
ConfigInvalidSocketAddrV4(&'static str),
ConfigInvalidString(&'static str),
FileNotFound(String),
IO(io::Error),
ParseIntError(num::ParseIntError),
StringFromUtf8Error(string::FromUtf8Error),
Utf8Error(str::Utf8Error),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let msg = match *self {
Error::ConfigFileIO(ref e) => format!("Error reading configuration file: {}", e),
Error::ConfigFileSyntax(ref e) => {
format!("Syntax errors while parsing TOML configuration file:\n\n{}",
e)
}
Error::ConfigInvalidArray(ref f) => {
format!("Invalid array of values in config, field={}", f)
}
Error::ConfigInvalidIpv4Addr(ref f) => {
format!("Invalid Ipv4 address in config, field={}. (example: \"127.0.0.0\")",
f)
}
Error::ConfigInvalidSocketAddrV4(ref f) => {
format!("Invalid Ipv4 network address pair in config, field={}. (example: \
\"127.0.0.0:8080\")",
f)
}
Error::ConfigInvalidString(ref f) => {
format!("Invalid string value in config, field={}.", f)
}
Error::FileNotFound(ref e) => format!("File not found at: {}", e),
Error::IO(ref err) => format!("{}", err),
Error::ParseIntError(ref e) => format!("{}", e),
Error::StringFromUtf8Error(ref e) => format!("{}", e),
Error::Utf8Error(ref e) => format!("{}", e),
};
write!(f, "{}", msg)
}
}
impl error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::ConfigFileIO(_) => "Unable to read the raw contents of a configuration file",
Error::ConfigFileSyntax(_) => "Error parsing contents of configuration file",
Error::ConfigInvalidArray(_) => {
"Invalid array of values encountered while parsing a configuration file"
}
Error::ConfigInvalidIpv4Addr(_) => {
"Invalid Ipv4 network address encountered while parsing a configuration file"
}
Error::ConfigInvalidSocketAddrV4(_) => {
"Invalid Ipv4 network address pair encountered while parsing a configuration file"
}
Error::ConfigInvalidString(_) => {
"Invalid string value encountered while parsing a configuration file"
}
Error::FileNotFound(_) => "File not found",
Error::IO(ref err) => err.description(),
Error::ParseIntError(_) => "Failed to parse an integer from a string!",
Error::StringFromUtf8Error(_) => "Failed to convert a string from a Vec<u8> as UTF-8",
Error::Utf8Error(_) => "Failed to interpret a sequence of bytes as a string",
}
}
}
impl From<string::FromUtf8Error> for Error {
fn from(err: string::FromUtf8Error) -> Self {
Error::StringFromUtf8Error(err)
}
}
impl From<str::Utf8Error> for Error {
fn from(err: str::Utf8Error) -> Self {
Error::Utf8Error(err)
}
}
impl From<io::Error> for Error {
fn from(err: io::Error) -> Self {
Error::IO(err)
}
}
impl From<num::ParseIntError> for Error {
fn from(err: num::ParseIntError) -> Self {
Error::ParseIntError(err)
}
}