Skip to content

Commit 5937594

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 5937594

File tree

1 file changed

+67
-116
lines changed

1 file changed

+67
-116
lines changed

‎src/de.rs

Lines changed: 67 additions & 116 deletions
Original file line numberDiff line numberDiff line change
@@ -234,6 +234,24 @@ 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 => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
243+
}
244+
}
245+
246+
/// Returns the first non-whitespace byte without consuming it, or `Err` if
247+
/// EOF is encountered.
248+
fn parse_whitespace_in_object(&mut self) -> Result<u8> {
249+
match tri!(self.parse_whitespace()) {
250+
Some(b) => Ok(b),
251+
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
252+
}
253+
}
254+
237255
/// Returns the first non-whitespace byte without consuming it, or `None` if
238256
/// EOF is encountered.
239257
fn parse_whitespace(&mut self) -> Result<Option<u8>> {
@@ -304,12 +322,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
304322
where
305323
V: de::Visitor<'de>,
306324
{
307-
let peek = match tri!(self.parse_whitespace()) {
308-
Some(b) => b,
309-
None => {
310-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
311-
}
312-
};
325+
let peek = tri!(self.parse_whitespace_in_value());
313326

314327
let value = match peek {
315328
b'-' => {
@@ -961,13 +974,12 @@ impl<'de, R: Read<'de>> Deserializer<R> {
961974
}
962975

963976
fn parse_object_colon(&mut self) -> Result<()> {
964-
match tri!(self.parse_whitespace()) {
965-
Some(b':') => {
977+
match tri!(self.parse_whitespace_in_object()) {
978+
b':' => {
966979
self.eat_char();
967980
Ok(())
968981
}
969-
Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
970-
None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
982+
_ => Err(self.peek_error(ErrorCode::ExpectedColon)),
971983
}
972984
}
973985

@@ -990,14 +1002,13 @@ impl<'de, R: Read<'de>> Deserializer<R> {
9901002
}
9911003

9921004
fn end_map(&mut self) -> Result<()> {
993-
match tri!(self.parse_whitespace()) {
994-
Some(b'}') => {
1005+
match tri!(self.parse_whitespace_in_object()) {
1006+
b'}' => {
9951007
self.eat_char();
9961008
Ok(())
9971009
}
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)),
1010+
b',' => Err(self.peek_error(ErrorCode::TrailingComma)),
1011+
_ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
10011012
}
10021013
}
10031014

@@ -1006,12 +1017,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
10061017
let mut enclosing = None;
10071018

10081019
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-
};
1020+
let peek = tri!(self.parse_whitespace_in_value());
10151021

10161022
let frame = match peek {
10171023
b'n' => {
@@ -1099,16 +1105,14 @@ impl<'de, R: Read<'de>> Deserializer<R> {
10991105
}
11001106

11011107
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)),
1108+
match tri!(self.parse_whitespace_in_object()) {
1109+
b'"' => self.eat_char(),
1110+
_ => return Err(self.peek_error(ErrorCode::KeyMustBeAString)),
11061111
}
11071112
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)),
1113+
match tri!(self.parse_whitespace_in_object()) {
1114+
b':' => self.eat_char(),
1115+
_ => return Err(self.peek_error(ErrorCode::ExpectedColon)),
11121116
}
11131117
}
11141118

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

13021301
let value = match peek {
13031302
b'n' => {
@@ -1368,12 +1367,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
13681367
where
13691368
V: de::Visitor<'de>,
13701369
{
1371-
let peek = match tri!(self.parse_whitespace()) {
1372-
Some(b) => b,
1373-
None => {
1374-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1375-
}
1376-
};
1370+
let peek = tri!(self.parse_whitespace_in_value());
13771371

13781372
let value = match peek {
13791373
b't' => {
@@ -1425,15 +1419,12 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14251419
{
14261420
let mut buf = String::new();
14271421

1428-
match tri!(self.parse_whitespace()) {
1429-
Some(b'-') => {
1422+
match tri!(self.parse_whitespace_in_value()) {
1423+
b'-' => {
14301424
self.eat_char();
14311425
buf.push('-');
14321426
}
1433-
Some(_) => {}
1434-
None => {
1435-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1436-
}
1427+
_ => {}
14371428
};
14381429

14391430
tri!(self.scan_integer128(&mut buf));
@@ -1455,14 +1446,11 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14551446
where
14561447
V: de::Visitor<'de>,
14571448
{
1458-
match tri!(self.parse_whitespace()) {
1459-
Some(b'-') => {
1449+
match tri!(self.parse_whitespace_in_value()) {
1450+
b'-' => {
14601451
return Err(self.peek_error(ErrorCode::NumberOutOfRange));
14611452
}
1462-
Some(_) => {}
1463-
None => {
1464-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1465-
}
1453+
_ => {}
14661454
}
14671455

14681456
let mut buf = String::new();
@@ -1493,12 +1481,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
14931481
where
14941482
V: de::Visitor<'de>,
14951483
{
1496-
let peek = match tri!(self.parse_whitespace()) {
1497-
Some(b) => b,
1498-
None => {
1499-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1500-
}
1501-
};
1484+
let peek = tri!(self.parse_whitespace_in_value());
15021485

15031486
let value = match peek {
15041487
b'"' => {
@@ -1600,12 +1583,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
16001583
where
16011584
V: de::Visitor<'de>,
16021585
{
1603-
let peek = match tri!(self.parse_whitespace()) {
1604-
Some(b) => b,
1605-
None => {
1606-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1607-
}
1608-
};
1586+
let peek = tri!(self.parse_whitespace_in_value());
16091587

16101588
let value = match peek {
16111589
b'"' => {
@@ -1654,12 +1632,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
16541632
where
16551633
V: de::Visitor<'de>,
16561634
{
1657-
let peek = match tri!(self.parse_whitespace()) {
1658-
Some(b) => b,
1659-
None => {
1660-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1661-
}
1662-
};
1635+
let peek = tri!(self.parse_whitespace_in_value());
16631636

16641637
let value = match peek {
16651638
b'n' => {
@@ -1704,12 +1677,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17041677
where
17051678
V: de::Visitor<'de>,
17061679
{
1707-
let peek = match tri!(self.parse_whitespace()) {
1708-
Some(b) => b,
1709-
None => {
1710-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1711-
}
1712-
};
1680+
let peek = tri!(self.parse_whitespace_in_value());
17131681

17141682
let value = match peek {
17151683
b'[' => {
@@ -1755,12 +1723,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17551723
where
17561724
V: de::Visitor<'de>,
17571725
{
1758-
let peek = match tri!(self.parse_whitespace()) {
1759-
Some(b) => b,
1760-
None => {
1761-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1762-
}
1763-
};
1726+
let peek = tri!(self.parse_whitespace_in_value());
17641727

17651728
let value = match peek {
17661729
b'{' => {
@@ -1792,12 +1755,7 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
17921755
where
17931756
V: de::Visitor<'de>,
17941757
{
1795-
let peek = match tri!(self.parse_whitespace()) {
1796-
Some(b) => b,
1797-
None => {
1798-
return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
1799-
}
1800-
};
1758+
let peek = tri!(self.parse_whitespace_in_value());
18011759

18021760
let value = match peek {
18031761
b'[' => {
@@ -1843,25 +1801,23 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
18431801
where
18441802
V: de::Visitor<'de>,
18451803
{
1846-
match tri!(self.parse_whitespace()) {
1847-
Some(b'{') => {
1804+
match tri!(self.parse_whitespace_in_value()) {
1805+
b'{' => {
18481806
check_recursion! {
18491807
self.eat_char();
18501808
let value = tri!(visitor.visit_enum(VariantAccess::new(self)));
18511809
}
18521810

1853-
match tri!(self.parse_whitespace()) {
1854-
Some(b'}') => {
1811+
match tri!(self.parse_whitespace_in_object()) {
1812+
b'}' => {
18551813
self.eat_char();
18561814
Ok(value)
18571815
}
1858-
Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
1859-
None => Err(self.error(ErrorCode::EofWhileParsingObject)),
1816+
_ => Err(self.error(ErrorCode::ExpectedSomeValue)),
18601817
}
18611818
}
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)),
1819+
b'"' => visitor.visit_enum(UnitVariantAccess::new(self)),
1820+
_ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
18651821
}
18661822
}
18671823

@@ -1905,12 +1861,12 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
19051861
}
19061862
Some(b',') if !self.first => {
19071863
self.de.eat_char();
1908-
tri!(self.de.parse_whitespace())
1864+
tri!(self.de.parse_whitespace_in_value())
19091865
}
19101866
Some(b) => {
19111867
if self.first {
19121868
self.first = false;
1913-
Some(b)
1869+
b
19141870
} else {
19151871
return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
19161872
}
@@ -1921,9 +1877,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
19211877
};
19221878

19231879
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)),
1880+
b']' => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1881+
_ => Ok(Some(tri!(seed.deserialize(&mut *self.de)))),
19271882
}
19281883
}
19291884
}
@@ -1946,32 +1901,28 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
19461901
where
19471902
K: de::DeserializeSeed<'de>,
19481903
{
1949-
let peek = match tri!(self.de.parse_whitespace()) {
1950-
Some(b'}') => {
1904+
let peek = match tri!(self.de.parse_whitespace_in_object()) {
1905+
b'}' => {
19511906
return Ok(None);
19521907
}
1953-
Some(b',') if !self.first => {
1908+
b',' if !self.first => {
19541909
self.de.eat_char();
1955-
tri!(self.de.parse_whitespace())
1910+
tri!(self.de.parse_whitespace_in_value())
19561911
}
1957-
Some(b) => {
1912+
b => {
19581913
if self.first {
19591914
self.first = false;
1960-
Some(b)
1915+
b
19611916
} else {
19621917
return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
19631918
}
19641919
}
1965-
None => {
1966-
return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
1967-
}
19681920
};
19691921

19701922
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)),
1923+
b'"' => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
1924+
b'}' => Err(self.de.peek_error(ErrorCode::TrailingComma)),
1925+
_ => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
19751926
}
19761927
}
19771928

0 commit comments

Comments
 (0)