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
use std::error::Error;
#[derive(Debug)]
pub enum ApplyError {
InvalidTransaction(String),
InternalError(String),
}
impl Error for ApplyError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
None
}
}
impl std::fmt::Display for ApplyError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match *self {
ApplyError::InvalidTransaction(ref s) => write!(f, "InvalidTransaction: {}", s),
ApplyError::InternalError(ref s) => write!(f, "InternalError: {}", s),
}
}
}
#[derive(Debug)]
pub enum ContextError {
AuthorizationError(String),
ResponseAttributeError(String),
TransactionReceiptError(String),
SerializationError(Box<dyn Error>),
SendError(Box<dyn Error>),
ReceiveError(Box<dyn Error>),
}
impl Error for ContextError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
ContextError::AuthorizationError(_) => None,
ContextError::ResponseAttributeError(_) => None,
ContextError::TransactionReceiptError(_) => None,
ContextError::SerializationError(err) => Some(&**err),
ContextError::SendError(err) => Some(&**err),
ContextError::ReceiveError(err) => Some(&**err),
}
}
}
impl std::fmt::Display for ContextError {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match *self {
ContextError::AuthorizationError(ref s) => write!(f, "AuthorizationError: {}", s),
ContextError::ResponseAttributeError(ref s) => {
write!(f, "ResponseAttributeError: {}", s)
}
ContextError::TransactionReceiptError(ref s) => {
write!(f, "TransactionReceiptError: {}", s)
}
ContextError::SerializationError(ref err) => {
write!(f, "SerializationError: {}", err.description())
}
ContextError::SendError(ref err) => write!(f, "SendError: {}", err.description()),
ContextError::ReceiveError(ref err) => write!(f, "ReceiveError: {}", err.description()),
}
}
}
impl From<ContextError> for ApplyError {
fn from(context_error: ContextError) -> Self {
match context_error {
ContextError::TransactionReceiptError(..) => {
ApplyError::InternalError(format!("{}", context_error))
}
_ => ApplyError::InvalidTransaction(format!("{}", context_error)),
}
}
}