pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-24 22:47:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Eliminate Sep tokens in serde_test

Browse Source
This commit is contained in:
David Tolnay
2017-04-05 09:42:24 -07:00
parent 9b51be4ba6
commit 67ed7a0edd
9 changed files with 47 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_test/src/de.rs
+41 -54
View File
@@ -42,7 +42,6 @@ impl<'de> Deserializer<'de> {
fn visit_seq<V>(&mut self,
len: Option<usize>,
sep: Token,
end: Token,
visitor: V)
-> Result<V::Value, Error>
@@ -51,7 +50,6 @@ impl<'de> Deserializer<'de> {
let value = try!(visitor.visit_seq(DeserializerSeqVisitor {
de: self,
len: len,
sep: sep,
end: end.clone(),
}));
try!(self.expect_token(end));
@@ -60,7 +58,6 @@ impl<'de> Deserializer<'de> {
fn visit_map<V>(&mut self,
len: Option<usize>,
sep: Token,
end: Token,
visitor: V)
-> Result<V::Value, Error>
@@ -69,7 +66,6 @@ impl<'de> Deserializer<'de> {
let value = try!(visitor.visit_map(DeserializerMapVisitor {
de: self,
len: len,
sep: sep,
end: end.clone(),
}));
try!(self.expect_token(end));
@@ -113,25 +109,24 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Some(Token::UnitStruct(_name)) => visitor.visit_unit(),
Some(Token::StructNewType(_name)) => visitor.visit_newtype_struct(self),
Some(Token::SeqStart(len)) => {
self.visit_seq(len, Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(len, Token::SeqEnd, visitor)
}
Some(Token::SeqArrayStart(len)) => {
self.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(Some(len), Token::SeqEnd, visitor)
}
Some(Token::TupleStart(len)) => {
self.visit_seq(Some(len), Token::TupleSep, Token::TupleEnd, visitor)
self.visit_seq(Some(len), Token::TupleEnd, visitor)
}
Some(Token::TupleStructStart(_, len)) => {
self.visit_seq(Some(len),
Token::TupleStructSep,
Token::TupleStructEnd,
visitor)
}
Some(Token::MapStart(len)) => {
self.visit_map(len, Token::MapSep, Token::MapEnd, visitor)
self.visit_map(len, Token::MapEnd, visitor)
}
Some(Token::StructStart(_, len)) => {
self.visit_map(Some(len), Token::StructSep, Token::StructEnd, visitor)
self.visit_map(Some(len), Token::StructEnd, visitor)
}
Some(Token::EnumStart(_)) => {
let variant = self.next_token().ok_or(Error::EndOfTokens)?;
@@ -153,15 +148,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Err(Error::UnexpectedToken(variant))
}
(variant, _) => {
visitor.visit_map(EnumMapVisitor::new(self, variant))
visitor.visit_map(EnumMapVisitor::new(self, variant, EnumFormat::Any))
}
}
}
Some(Token::EnumUnit(_, variant)) => visitor.visit_str(variant),
Some(Token::EnumNewType(_, variant)) |
Some(Token::EnumSeqStart(_, variant, _)) |
Some(Token::EnumNewType(_, variant)) => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any))
}
Some(Token::EnumSeqStart(_, variant, _)) => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq))
}
Some(Token::EnumMapStart(_, variant, _)) => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant)))
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map))
}
Some(token) => Err(Error::UnexpectedToken(token)),
None => Err(Error::EndOfTokens),
@@ -255,7 +254,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
match self.tokens.first() {
Some(&Token::SeqArrayStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(Some(len), Token::SeqEnd, visitor)
}
Some(_) => self.deserialize(visitor),
None => Err(Error::EndOfTokens),
@@ -273,20 +272,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
Some(&Token::SeqStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(Some(len), Token::SeqEnd, visitor)
}
Some(&Token::SeqArrayStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(Some(len), Token::SeqEnd, visitor)
}
Some(&Token::TupleStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::TupleSep, Token::TupleEnd, visitor)
self.visit_seq(Some(len), Token::TupleEnd, visitor)
}
Some(&Token::TupleStructStart(_, _)) => {
self.next_token();
self.visit_seq(Some(len),
Token::TupleStructSep,
Token::TupleStructEnd,
visitor)
}
@@ -317,21 +315,20 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
Some(&Token::SeqStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(Some(len), Token::SeqEnd, visitor)
}
Some(&Token::SeqArrayStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.visit_seq(Some(len), Token::SeqEnd, visitor)
}
Some(&Token::TupleStart(_)) => {
self.next_token();
self.visit_seq(Some(len), Token::TupleSep, Token::TupleEnd, visitor)
self.visit_seq(Some(len), Token::TupleEnd, visitor)
}
Some(&Token::TupleStructStart(n, _)) => {
self.next_token();
if name == n {
self.visit_seq(Some(len),
Token::TupleStructSep,
Token::TupleStructEnd,
visitor)
} else {
@@ -355,7 +352,6 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
self.next_token();
if name == n {
self.visit_map(Some(fields.len()),
Token::StructSep,
Token::StructEnd,
visitor)
} else {
@@ -364,7 +360,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
}
Some(&Token::MapStart(_)) => {
self.next_token();
self.visit_map(Some(fields.len()), Token::MapSep, Token::MapEnd, visitor)
self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
}
Some(_) => self.deserialize(visitor),
None => Err(Error::EndOfTokens),
@@ -377,7 +373,6 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
struct DeserializerSeqVisitor<'a, 'de: 'a> {
de: &'a mut Deserializer<'de>,
len: Option<usize>,
sep: Token,
end: Token,
}
@@ -390,14 +385,8 @@ impl<'de, 'a> SeqVisitor<'de> for DeserializerSeqVisitor<'a, 'de> {
if self.de.tokens.first() == Some(&self.end) {
return Ok(None);
}
match self.de.next_token() {
Some(ref token) if *token == self.sep => {
self.len = self.len.map(|len| len.saturating_sub(1));
seed.deserialize(&mut *self.de).map(Some)
}
Some(other) => Err(Error::UnexpectedToken(other)),
None => Err(Error::EndOfTokens),
}
self.len = self.len.map(|len| len.saturating_sub(1));
seed.deserialize(&mut *self.de).map(Some)
}
fn size_hint(&self) -> (usize, Option<usize>) {
@@ -411,7 +400,6 @@ impl<'de, 'a> SeqVisitor<'de> for DeserializerSeqVisitor<'a, 'de> {
struct DeserializerMapVisitor<'a, 'de: 'a> {
de: &'a mut Deserializer<'de>,
len: Option<usize>,
sep: Token,
end: Token,
}
@@ -424,14 +412,8 @@ impl<'de, 'a> MapVisitor<'de> for DeserializerMapVisitor<'a, 'de> {
if self.de.tokens.first() == Some(&self.end) {
return Ok(None);
}
match self.de.next_token() {
Some(ref token) if *token == self.sep => {
self.len = self.len.map(|len| len.saturating_sub(1));
seed.deserialize(&mut *self.de).map(Some)
}
Some(other) => Err(Error::UnexpectedToken(other)),
None => Err(Error::EndOfTokens),
}
self.len = self.len.map(|len| len.saturating_sub(1));
seed.deserialize(&mut *self.de).map(Some)
}
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
@@ -512,7 +494,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
let token = self.de.next_token().unwrap();
if len == enum_len {
self.de.visit_seq(Some(len), Token::EnumSeqSep, Token::EnumSeqEnd, visitor)
self.de.visit_seq(Some(len), Token::EnumSeqEnd, visitor)
} else {
Err(Error::UnexpectedToken(token))
}
@@ -521,7 +503,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
let token = self.de.next_token().unwrap();
if len == enum_len {
self.de.visit_seq(Some(len), Token::SeqSep, Token::SeqEnd, visitor)
self.de.visit_seq(Some(len), Token::SeqEnd, visitor)
} else {
Err(Error::UnexpectedToken(token))
}
@@ -540,7 +522,6 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
if fields.len() == enum_len {
self.de.visit_map(Some(fields.len()),
Token::EnumMapSep,
Token::EnumMapEnd,
visitor)
} else {
@@ -551,7 +532,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
let token = self.de.next_token().unwrap();
if fields.len() == enum_len {
self.de.visit_map(Some(fields.len()), Token::MapSep, Token::MapEnd, visitor)
self.de.visit_map(Some(fields.len()), Token::MapEnd, visitor)
} else {
Err(Error::UnexpectedToken(token))
}
@@ -567,13 +548,21 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
struct EnumMapVisitor<'a, 'de: 'a> {
de: &'a mut Deserializer<'de>,
variant: Option<Token>,
format: EnumFormat,
}
enum EnumFormat {
Seq,
Map,
Any,
}
impl<'a, 'de> EnumMapVisitor<'a, 'de> {
fn new(de: &'a mut Deserializer<'de>, variant: Token) -> Self {
fn new(de: &'a mut Deserializer<'de>, variant: Token, format: EnumFormat) -> Self {
EnumMapVisitor {
de: de,
variant: Some(variant),
format: format,
}
}
}
@@ -604,13 +593,12 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
where V: DeserializeSeed<'de>
{
match self.de.tokens.first() {
Some(&Token::EnumSeqSep) => {
match self.format {
EnumFormat::Seq => {
let value = {
let visitor = DeserializerSeqVisitor {
de: self.de,
len: None,
sep: Token::EnumSeqSep,
end: Token::EnumSeqEnd,
};
try!(seed.deserialize(SeqVisitorDeserializer::new(visitor)))
@@ -618,12 +606,11 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
try!(self.de.expect_token(Token::EnumSeqEnd));
Ok(value)
}
Some(&Token::EnumMapSep) => {
EnumFormat::Map => {
let value = {
let visitor = DeserializerMapVisitor {
de: self.de,
len: None,
sep: Token::EnumMapSep,
end: Token::EnumMapEnd,
};
try!(seed.deserialize(MapVisitorDeserializer::new(visitor)))
@@ -631,7 +618,7 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
try!(self.de.expect_token(Token::EnumMapEnd));
Ok(value)
}
_ => seed.deserialize(&mut *self.de),
EnumFormat::Any => seed.deserialize(&mut *self.de),
}
}
}
serde_test/src/ser.rs
-7
View File
@@ -253,7 +253,6 @@ impl<'s, 'a> ser::SerializeSeq for &'s mut Serializer<'a> {
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: Serialize
{
assert_next_token!(self, SeqSep);
value.serialize(&mut **self)
}
@@ -270,7 +269,6 @@ impl<'s, 'a> ser::SerializeTuple for &'s mut Serializer<'a> {
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: Serialize
{
assert_next_token!(self, TupleSep);
value.serialize(&mut **self)
}
@@ -287,7 +285,6 @@ impl<'s, 'a> ser::SerializeTupleStruct for &'s mut Serializer<'a> {
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: Serialize
{
assert_next_token!(self, TupleStructSep);
value.serialize(&mut **self)
}
@@ -304,7 +301,6 @@ impl<'s, 'a> ser::SerializeTupleVariant for &'s mut Serializer<'a> {
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: Serialize
{
assert_next_token!(self, EnumSeqSep);
value.serialize(&mut **self)
}
@@ -321,7 +317,6 @@ impl<'s, 'a> ser::SerializeMap for &'s mut Serializer<'a> {
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
where T: Serialize
{
assert_next_token!(self, MapSep);
key.serialize(&mut **self)
}
@@ -347,7 +342,6 @@ impl<'s, 'a> ser::SerializeStruct for &'s mut Serializer<'a> {
-> Result<(), Self::Error>
where T: Serialize
{
assert_next_token!(self, StructSep);
try!(key.serialize(&mut **self));
value.serialize(&mut **self)
}
@@ -368,7 +362,6 @@ impl<'s, 'a> ser::SerializeStructVariant for &'s mut Serializer<'a> {
-> Result<(), Self::Error>
where T: Serialize
{
assert_next_token!(self, EnumMapSep);
try!(key.serialize(&mut **self));
value.serialize(&mut **self)
}
serde_test/src/token.rs
-26
View File
@@ -105,29 +105,18 @@ pub enum Token {
/// header is a list of elements, followed by `SeqEnd`.
SeqArrayStart(usize),
/// A separator, which occurs *before* every element in a sequence.
///
/// Elements in sequences are represented by a `SeqSep`, followed by the value of the element.
SeqSep,
/// An indicator of the end of a sequence.
SeqEnd,
/// The header to a tuple of the given length, similar to `SeqArrayStart`.
TupleStart(usize),
/// A separator, similar to `SeqSep`.
TupleSep,
/// An indicator of the end of a tuple, similar to `SeqEnd`.
TupleEnd,
/// The header to a tuple struct of the given name and length.
TupleStructStart(&'static str, usize),
/// A separator, similar to `TupleSep`.
TupleStructSep,
/// An indicator of the end of a tuple struct, similar to `TupleEnd`.
TupleStructEnd,
@@ -137,30 +126,18 @@ pub enum Token {
/// is a list of key-value pairs, followed by `MapEnd`.
MapStart(Option<usize>),
/// A separator, which occurs *before* every key-value pair in a map.
///
/// Elements in maps are represented by a `MapSep`, followed by a serialized key, followed
/// by a serialized value.
MapSep,
/// An indicator of the end of a map.
MapEnd,
/// The header of a struct of the given name and length, similar to `MapStart`.
StructStart(&'static str, usize),
/// A separator, similar to `MapSep`.
StructSep,
/// An indicator of the end of a struct, similar to `MapEnd`.
StructEnd,
/// The header to a tuple variant of an enum of the given name, of the given name and length.
EnumSeqStart(&'static str, &'static str, usize),
/// A separator, similar to `TupleSep`.
EnumSeqSep,
/// An indicator of the end of a tuple variant, similar to `TupleEnd`.
EnumSeqEnd,
@@ -168,9 +145,6 @@ pub enum Token {
/// similar to `StructStart`.
EnumMapStart(&'static str, &'static str, usize),
/// A separator, similar to `StructSep`.
EnumMapSep,
/// An indicator of the end of a struct, similar to `StructEnd`.
EnumMapEnd,
}