Skip to content

Commit 3bc95cc

Browse files
author
Markus Westerlind
committed
refactor: Factor out whitespace skipping into helpers
Should hopefully reduce the amount of code being generated
1 parent ae8d93d commit 3bc95cc

File tree

1 file changed

+71
-116
lines changed

1 file changed

+71
-116
lines changed

‎src/de.rs

+71-116
Original file line numberDiff line numberDiff line change
@@ -234,6 +234,28 @@ impl<'de, R: Read<'de>> Deserializer<R> {
234234
Error::syntax(reason, position.line, position.column)
235235
}
236236

237+
/// Returns the first non-whitespace byte without consuming it, or `Err` if
238+
/// EOF is encountered.
239+
fn parse_whitespace_in_value(&mut self) -> Result<u8> {
240+
match tri!(self.parse_whitespace()) {
241+
Some(b) => Ok(b),
242+
None => {
243+
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
244+
}
245+
}
246+
}
247+
248+
/// Returns the first non-whitespace byte without consuming it, or `Err` if
249+
/// EOF is encountered.
250+
fn parse_whitespace_in_object(&mut self) -> Result<u8> {
251+
match tri!(self.parse_whitespace()) {
252+
Some(b) => Ok(b),
253+
None => {
254+
return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
255+
}
256+
}
257+
}
258+
237259
/// Returns the first non-whitespace byte without consuming it, or `None` if
238260
/// EOF is encountered.
239261
fn parse_whitespace(&mut self) -> Result<Option<u8>> {
@@ -304,12 +326,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
304326
where
305327
V: de::Visitor<'de>,
306328
{
307-
let peek = match tri!(self.parse_whitespace()) {
308-
Some(b) => b,
309-
None => {
310-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
311-
}
312-
};
329+
let peek = tri!(self.parse_whitespace_in_value());
313330

314331
let value = match peek {
315332
b'-' => {
@@ -961,13 +978,12 @@ impl<'de, R: Read<'de>> Deserializer<R> {
961978
}
962979

963980
fn parse_object_colon(&mut self) -> Result<()> {
964-
match tri!(self.parse_whitespace()) {
965-
Some(b':') => {
981+
match tri!(self.parse_whitespace_in_object()) {
982+
b':' => {
966983
self.eat_char();
967984
Ok(())
968985
}
969-
Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
970-
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
986+
_ => Err(self.peek_error(ErrorCode::ExpectedColon)),
971987
}
972988
}
973989

@@ -990,14 +1006,13 @@ impl<'de, R: Read<'de>> Deserializer<R> {
9901006
}
9911007

9921008
fn end_map(&mut self) -> Result<()> {
993-
match tri!(self.parse_whitespace()) {
994-
Some(b'}') => {
1009+
match tri!(self.parse_whitespace_in_object()) {
1010+
b'}' => {
9951011
self.eat_char();
9961012
Ok(())
9971013
}
998-
Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
999-
Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
1000-
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1014+
b',' => Err(self.peek_error(ErrorCode::TrailingComma)),
1015+
_ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
10011016
}
10021017
}
10031018

@@ -1006,12 +1021,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
10061021
let mut enclosing = None;
10071022

10081023
loop {
1009-
let peek = match tri!(self.parse_whitespace()) {
1010-
Some(b) => b,
1011-
None => {
1012-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1013-
}
1014-
};
1024+
let peek = tri!(self.parse_whitespace_in_value());
10151025

10161026
let frame = match peek {
10171027
b'n' => {
@@ -1099,16 +1109,14 @@ impl<'de, R: Read<'de>> Deserializer<R> {
10991109
}
11001110

11011111
if frame == b'{' {
1102-
match tri!(self.parse_whitespace()) {
1103-
Some(b'"') => self.eat_char(),
1104-
Some(_) => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
1105-
None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1112+
match tri!(self.parse_whitespace_in_object()) {
1113+
b'"' => self.eat_char(),
1114+
_ => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
11061115
}
11071116
tri!(self.read.ignore_str());
1108-
match tri!(self.parse_whitespace()) {
1109-
Some(b':') => self.eat_char(),
1110-
Some(_) => return Err(self.peek_error(ErrorCode::ExpectedColon)),
1111-
None => return Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
1117+
match tri!(self.parse_whitespace_in_object()) {
1118+
b':' => self.eat_char(),
1119+
_ => return Err(self.peek_error(ErrorCode::ExpectedColon)),
11121120
}
11131121
}
11141122

@@ -1292,12 +1300,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
12921300
where
12931301
V: de::Visitor<'de>,
12941302
{
1295-
let peek = match tri!(self.parse_whitespace()) {
1296-
Some(b) => b,
1297-
None => {
1298-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1299-
}
1300-
};
1303+
let peek = tri!(self.parse_whitespace_in_value());
13011304

13021305
let value = match peek {
13031306
b'n' => {
@@ -1368,12 +1371,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
13681371
where
13691372
V: de::Visitor<'de>,
13701373
{
1371-
let peek = match tri!(self.parse_whitespace()) {
1372-
Some(b) => b,
1373-
None => {
1374-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1375-
}
1376-
};
1374+
let peek = tri!(self.parse_whitespace_in_value());
13771375

13781376
let value = match peek {
13791377
b't' => {
@@ -1425,15 +1423,12 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14251423
{
14261424
let mut buf = String::new();
14271425

1428-
match tri!(self.parse_whitespace()) {
1429-
Some(b'-') => {
1426+
match tri!(self.parse_whitespace_in_value()) {
1427+
b'-' => {
14301428
self.eat_char();
14311429
buf.push('-');
14321430
}
1433-
Some(_) => {}
1434-
None => {
1435-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1436-
}
1431+
_ => {}
14371432
};
14381433

14391434
tri!(self.scan_integer128(&mut buf));
@@ -1455,14 +1450,11 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14551450
where
14561451
V: de::Visitor<'de>,
14571452
{
1458-
match tri!(self.parse_whitespace()) {
1459-
Some(b'-') => {
1453+
match tri!(self.parse_whitespace_in_value()) {
1454+
b'-' => {
14601455
return Err(self.peek_error(ErrorCode::NumberOutOfRange));
14611456
}
1462-
Some(_) => {}
1463-
None => {
1464-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1465-
}
1457+
_ => {}
14661458
}
14671459

14681460
let mut buf = String::new();
@@ -1493,12 +1485,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14931485
where
14941486
V: de::Visitor<'de>,
14951487
{
1496-
let peek = match tri!(self.parse_whitespace()) {
1497-
Some(b) => b,
1498-
None => {
1499-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1500-
}
1501-
};
1488+
let peek = tri!(self.parse_whitespace_in_value());
15021489

15031490
let value = match peek {
15041491
b'"' => {
@@ -1600,12 +1587,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
16001587
where
16011588
V: de::Visitor<'de>,
16021589
{
1603-
let peek = match tri!(self.parse_whitespace()) {
1604-
Some(b) => b,
1605-
None => {
1606-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1607-
}
1608-
};
1590+
let peek = tri!(self.parse_whitespace_in_value());
16091591

16101592
let value = match peek {
16111593
b'"' => {
@@ -1654,12 +1636,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
16541636
where
16551637
V: de::Visitor<'de>,
16561638
{
1657-
let peek = match tri!(self.parse_whitespace()) {
1658-
Some(b) => b,
1659-
None => {
1660-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1661-
}
1662-
};
1639+
let peek = tri!(self.parse_whitespace_in_value());
16631640

16641641
let value = match peek {
16651642
b'n' => {
@@ -1704,12 +1681,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17041681
where
17051682
V: de::Visitor<'de>,
17061683
{
1707-
let peek = match tri!(self.parse_whitespace()) {
1708-
Some(b) => b,
1709-
None => {
1710-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1711-
}
1712-
};
1684+
let peek = tri!(self.parse_whitespace_in_value());
17131685

17141686
let value = match peek {
17151687
b'[' => {
@@ -1755,12 +1727,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17551727
where
17561728
V: de::Visitor<'de>,
17571729
{
1758-
let peek = match tri!(self.parse_whitespace()) {
1759-
Some(b) => b,
1760-
None => {
1761-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1762-
}
1763-
};
1730+
let peek = tri!(self.parse_whitespace_in_value());
17641731

17651732
let value = match peek {
17661733
b'{' => {
@@ -1792,12 +1759,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17921759
where
17931760
V: de::Visitor<'de>,
17941761
{
1795-
let peek = match tri!(self.parse_whitespace()) {
1796-
Some(b) => b,
1797-
None => {
1798-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1799-
}
1800-
};
1762+
let peek = tri!(self.parse_whitespace_in_value());
18011763

18021764
let value = match peek {
18031765
b'[' => {
@@ -1843,25 +1805,23 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
18431805
where
18441806
V: de::Visitor<'de>,
18451807
{
1846-
match tri!(self.parse_whitespace()) {
1847-
Some(b'{') => {
1808+
match tri!(self.parse_whitespace_in_value()) {
1809+
b'{' => {
18481810
check_recursion! {
18491811
self.eat_char();
18501812
let value = tri!(visitor.visit_enum(VariantAccess::new(self)));
18511813
}
18521814

1853-
match tri!(self.parse_whitespace()) {
1854-
Some(b'}') => {
1815+
match tri!(self.parse_whitespace_in_object()) {
1816+
b'}' => {
18551817
self.eat_char();
18561818
Ok(value)
18571819
}
1858-
Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
1859-
None => Err(self.error(ErrorCode::EofWhileParsingObject)),
1820+
_ => Err(self.error(ErrorCode::ExpectedSomeValue)),
18601821
}
18611822
}
1862-
Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
1863-
Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
1864-
None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
1823+
b'"' => visitor.visit_enum(UnitVariantAccess::new(self)),
1824+
_ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
18651825
}
18661826
}
18671827

@@ -1905,12 +1865,12 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
19051865
}
19061866
Some(b',') if !self.first => {
19071867
self.de.eat_char();
1908-
tri!(self.de.parse_whitespace())
1868+
tri!(self.de.parse_whitespace_in_value())
19091869
}
19101870
Some(b) => {
19111871
if self.first {
19121872
self.first = false;
1913-
Some(b)
1873+
b
19141874
} else {
19151875
return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
19161876
}
@@ -1921,9 +1881,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
19211881
};
19221882

19231883
match peek {
1924-
Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1925-
Some(_) => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
1926-
None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1884+
b']' => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1885+
_ => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
19271886
}
19281887
}
19291888
}
@@ -1946,32 +1905,28 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
19461905
where
19471906
K: de::DeserializeSeed<'de>,
19481907
{
1949-
let peek = match tri!(self.de.parse_whitespace()) {
1950-
Some(b'}') => {
1908+
let peek = match tri!(self.de.parse_whitespace_in_object()) {
1909+
b'}' => {
19511910
return Ok(None);
19521911
}
1953-
Some(b',') if !self.first => {
1912+
b',' if !self.first => {
19541913
self.de.eat_char();
1955-
tri!(self.de.parse_whitespace())
1914+
tri!(self.de.parse_whitespace_in_value())
19561915
}
1957-
Some(b) => {
1916+
b => {
19581917
if self.first {
19591918
self.first = false;
1960-
Some(b)
1919+
b
19611920
} else {
19621921
return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
19631922
}
19641923
}
1965-
None => {
1966-
return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
1967-
}
19681924
};
19691925

19701926
match peek {
1971-
Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1972-
Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1973-
Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
1974-
None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
1927+
b'"' => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1928+
b'}' => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1929+
_ => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
19751930
}
19761931
}
19771932

0 commit comments

Comments
 (0)