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
use std::{error::Error, fmt, io, str::Utf8Error};
#[derive(Debug, PartialEq, Clone)]
pub enum Matcher {
Parse(String),
}
impl Error for Matcher {}
impl fmt::Display for Matcher {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Parse(input) => write!(f, "Failed to parse matcher'{}", input),
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct Handler {
reason: String,
}
impl Handler {
pub fn new<T>(reason: T) -> Self
where
T: ToString,
{
Self {
reason: reason.to_string(),
}
}
}
impl Error for Handler {}
impl fmt::Display for Handler {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Handler failed - {}", self.reason)
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct IncorrectInput {
chr: char,
idx: usize,
}
impl IncorrectInput {
pub fn new(chr: char, idx: usize) -> Self {
Self { chr, idx }
}
}
impl Error for IncorrectInput {}
impl fmt::Display for IncorrectInput {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"Incorrect input (character '{}' on idx {})",
self.chr, self.idx
)
}
}
#[derive(Debug)]
pub enum General {
Handler(Handler),
Matcher(Matcher),
Utf8Error(Utf8Error),
IncorrectInput(IncorrectInput),
IOError(io::Error),
}
impl Error for General {}
impl fmt::Display for General {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Self::Handler(err) => err.fmt(f),
Self::Matcher(err) => err.fmt(f),
Self::Utf8Error(err) => err.fmt(f),
Self::IncorrectInput(err) => err.fmt(f),
Self::IOError(err) => err.fmt(f),
}
}
}
impl From<Handler> for General {
fn from(handler: Handler) -> Self {
Self::Handler(handler)
}
}
impl From<Matcher> for General {
fn from(matcher: Matcher) -> Self {
Self::Matcher(matcher)
}
}
impl From<Utf8Error> for General {
fn from(utf8: Utf8Error) -> Self {
Self::Utf8Error(utf8)
}
}
impl From<IncorrectInput> for General {
fn from(incorrect_input: IncorrectInput) -> Self {
Self::IncorrectInput(incorrect_input)
}
}
impl From<io::Error> for General {
fn from(io_error: io::Error) -> Self {
Self::IOError(io_error)
}
}