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
use {
crate::{
de::Deserializer,
error::{ErrorCode::*, Result},
},
serde::de::Visitor,
};
/// an intermediate representation of number which
/// are read into undefinite types
pub(crate) struct Number<'de> {
negative: bool,
s: &'de str,
has_float_chars: bool,
}
impl<'de> Number<'de> {
/// read the characters of the coming floating point number, without parsing.
/// The sign at the start is assumed to have been already read
pub fn read<'a>(
de: &'a mut Deserializer<'de>,
) -> Result<Self> {
de.eat_shit()?;
let mut negative = false;
let mut has_float_chars = false;
for (idx, ch) in de.input().char_indices() {
match ch {
'0'..='9' => { }
'-' if idx == 0 => {
negative = true;
}
'-' | '+' | '.' | 'e' | 'E' => {
has_float_chars = true;
}
_ => {
let s = de.start(idx);
de.advance(idx); // we keep the last char
return Ok(Self {
negative, s, has_float_chars
});
}
}
}
let s = de.take_all();
Ok(Self {
negative, s, has_float_chars
})
}
/// deserialize into a relevant number type
pub fn visit<'a, V>(
&self,
de: &'a mut Deserializer<'de>,
visitor: V,
) -> Result<V::Value>
where
V: Visitor<'de>,
{
if self.has_float_chars {
// this is a floating point number (or an error)
let v: f64 = self.s.parse()
.map_err(|_| de.err(ExpectedF64))?;
visitor.visit_f64(v)
} else if self.negative {
// this is a negative integer (or an error)
let v: i64 = self.s.parse()
.map_err(|_| de.err(ExpectedI64))?;
visitor.visit_i64(v)
} else {
// this is a positive integer (or a number)
let v: u64 = self.s.parse()
.map_err(|_| de.err(ExpectedU64))?;
visitor.visit_u64(v)
}
}
}