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
use core::fmt;
use crate::input::Input;
use super::{
Context, ContextStack, Expected, ExpectedLength, ExpectedValid, ExpectedValue, FromContext,
RetryRequirement, ToRetryRequirement,
};
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct Invalid {
retry_requirement: Option<RetryRequirement>,
}
impl Invalid {
pub fn fatal() -> Self {
Self {
retry_requirement: None,
}
}
}
impl fmt::Display for Invalid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("invalid input")?;
if let Some(retry_requirement) = self.retry_requirement {
f.write_str(": needs ")?;
retry_requirement.fmt(f)?;
f.write_str(" to continue processing")?;
}
Ok(())
}
}
impl ToRetryRequirement for Invalid {
fn to_retry_requirement(&self) -> Option<RetryRequirement> {
self.retry_requirement
}
}
impl<'i> FromContext<'i> for Invalid {
fn from_context<C>(self, _input: &'i Input, _context: C) -> Self
where
C: Context,
{
self
}
}
impl<'i, S> From<Expected<'i, S>> for Invalid
where
S: ContextStack,
{
fn from(err: Expected<'i, S>) -> Self {
err.to_retry_requirement().into()
}
}
impl<'i> From<ExpectedValue<'i>> for Invalid {
fn from(err: ExpectedValue<'i>) -> Self {
err.to_retry_requirement().into()
}
}
impl<'i> From<ExpectedLength<'i>> for Invalid {
fn from(err: ExpectedLength<'i>) -> Self {
err.to_retry_requirement().into()
}
}
impl<'i> From<ExpectedValid<'i>> for Invalid {
fn from(err: ExpectedValid<'i>) -> Self {
err.to_retry_requirement().into()
}
}
impl From<Option<RetryRequirement>> for Invalid {
fn from(retry_requirement: Option<RetryRequirement>) -> Self {
Self { retry_requirement }
}
}
#[cfg(feature = "std")]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl std::error::Error for Invalid {}