pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-13 10:11:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update token names in serde_test

Browse Source
This commit is contained in:
David Tolnay
2017-04-05 10:30:46 -07:00
parent b6605b57e0
commit 826b53f691
2 changed files with 68 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_test/src/de.rs
+51 -51
View File
@@ -104,32 +104,32 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Token::Bytes(v) => visitor.visit_bytes(v), Token::Bytes(v) => visitor.visit_bytes(v),
Token::BorrowedBytes(v) => visitor.visit_borrowed_bytes(v), Token::BorrowedBytes(v) => visitor.visit_borrowed_bytes(v),
Token::ByteBuf(v) => visitor.visit_byte_buf(v.to_vec()), Token::ByteBuf(v) => visitor.visit_byte_buf(v.to_vec()),
Token::Option(false) => visitor.visit_none(), Token::None => visitor.visit_none(),
Token::Option(true) => visitor.visit_some(self), Token::Some => visitor.visit_some(self),
Token::Unit => visitor.visit_unit(), Token::Unit => visitor.visit_unit(),
Token::UnitStruct(_name) => visitor.visit_unit(), Token::UnitStruct(_name) => visitor.visit_unit(),
Token::StructNewType(_name) => visitor.visit_newtype_struct(self), Token::NewtypeStruct(_name) => visitor.visit_newtype_struct(self),
Token::SeqStart(len) => { Token::Seq(len) => {
self.visit_seq(len, Token::SeqEnd, visitor) self.visit_seq(len, Token::SeqEnd, visitor)
} }
Token::SeqArrayStart(len) => { Token::SeqFixedSize(len) => {
self.visit_seq(Some(len), Token::SeqEnd, visitor) self.visit_seq(Some(len), Token::SeqEnd, visitor)
} }
Token::TupleStart(len) => { Token::Tuple(len) => {
self.visit_seq(Some(len), Token::TupleEnd, visitor) self.visit_seq(Some(len), Token::TupleEnd, visitor)
} }
Token::TupleStructStart(_, len) => { Token::TupleStruct(_, len) => {
self.visit_seq(Some(len), self.visit_seq(Some(len),
Token::TupleStructEnd, Token::TupleStructEnd,
visitor) visitor)
} }
Token::MapStart(len) => { Token::Map(len) => {
self.visit_map(len, Token::MapEnd, visitor) self.visit_map(len, Token::MapEnd, visitor)
} }
Token::StructStart(_, len) => { Token::Struct(_, len) => {
self.visit_map(Some(len), Token::StructEnd, visitor) self.visit_map(Some(len), Token::StructEnd, visitor)
} }
Token::EnumStart(_) => { Token::Enum(_) => {
let variant = self.next_token().ok_or(Error::EndOfTokens)?; let variant = self.next_token().ok_or(Error::EndOfTokens)?;
let next = *self.tokens.first().ok_or(Error::EndOfTokens)?; let next = *self.tokens.first().ok_or(Error::EndOfTokens)?;
match (variant, next) { match (variant, next) {
@@ -153,14 +153,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
} }
} }
} }
Token::EnumUnit(_, variant) => visitor.visit_str(variant), Token::UnitVariant(_, variant) => visitor.visit_str(variant),
Token::EnumNewType(_, variant) => { Token::NewtypeVariant(_, variant) => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any)) visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any))
} }
Token::EnumSeqStart(_, variant, _) => { Token::TupleVariant(_, variant, _) => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq)) visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq))
} }
Token::EnumMapStart(_, variant, _) => { Token::StructVariant(_, variant, _) => {
visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map)) visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map))
} }
Token::SeqEnd | Token::SeqEnd |
@@ -168,8 +168,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Token::TupleStructEnd | Token::TupleStructEnd |
Token::MapEnd | Token::MapEnd |
Token::StructEnd | Token::StructEnd |
Token::EnumSeqEnd | Token::TupleVariantEnd |
Token::EnumMapEnd => Err(Error::UnexpectedToken(token)), Token::StructVariantEnd => Err(Error::UnexpectedToken(token)),
} }
} }
@@ -180,11 +180,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
{ {
match self.tokens.first() { match self.tokens.first() {
Some(&Token::Unit) | Some(&Token::Unit) |
Some(&Token::Option(false)) => { Some(&Token::None) => {
self.next_token(); self.next_token();
visitor.visit_none() visitor.visit_none()
} }
Some(&Token::Option(true)) => { Some(&Token::Some) => {
self.next_token(); self.next_token();
visitor.visit_some(self) visitor.visit_some(self)
} }
@@ -201,15 +201,15 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
where V: Visitor<'de> where V: Visitor<'de>
{ {
match self.tokens.first() { match self.tokens.first() {
Some(&Token::EnumStart(n)) if name == n => { Some(&Token::Enum(n)) if name == n => {
self.next_token(); self.next_token();
visitor.visit_enum(DeserializerEnumVisitor { de: self }) visitor.visit_enum(DeserializerEnumVisitor { de: self })
} }
Some(&Token::EnumUnit(n, _)) | Some(&Token::UnitVariant(n, _)) |
Some(&Token::EnumNewType(n, _)) | Some(&Token::NewtypeVariant(n, _)) |
Some(&Token::EnumSeqStart(n, _, _)) | Some(&Token::TupleVariant(n, _, _)) |
Some(&Token::EnumMapStart(n, _, _)) if name == n => { Some(&Token::StructVariant(n, _, _)) if name == n => {
visitor.visit_enum(DeserializerEnumVisitor { de: self }) visitor.visit_enum(DeserializerEnumVisitor { de: self })
} }
Some(_) => { Some(_) => {
@@ -241,7 +241,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
where V: Visitor<'de> where V: Visitor<'de>
{ {
match self.tokens.first() { match self.tokens.first() {
Some(&Token::StructNewType(n)) => { Some(&Token::NewtypeStruct(n)) => {
self.next_token(); self.next_token();
if name == n { if name == n {
visitor.visit_newtype_struct(self) visitor.visit_newtype_struct(self)
@@ -258,7 +258,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
where V: Visitor<'de> where V: Visitor<'de>
{ {
match self.tokens.first() { match self.tokens.first() {
Some(&Token::SeqArrayStart(_)) => { Some(&Token::SeqFixedSize(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::SeqEnd, visitor) self.visit_seq(Some(len), Token::SeqEnd, visitor)
} }
@@ -276,19 +276,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
self.next_token(); self.next_token();
visitor.visit_unit() visitor.visit_unit()
} }
Some(&Token::SeqStart(_)) => { Some(&Token::Seq(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::SeqEnd, visitor) self.visit_seq(Some(len), Token::SeqEnd, visitor)
} }
Some(&Token::SeqArrayStart(_)) => { Some(&Token::SeqFixedSize(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::SeqEnd, visitor) self.visit_seq(Some(len), Token::SeqEnd, visitor)
} }
Some(&Token::TupleStart(_)) => { Some(&Token::Tuple(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::TupleEnd, visitor) self.visit_seq(Some(len), Token::TupleEnd, visitor)
} }
Some(&Token::TupleStructStart(_, _)) => { Some(&Token::TupleStruct(_, _)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), self.visit_seq(Some(len),
Token::TupleStructEnd, Token::TupleStructEnd,
@@ -319,19 +319,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Err(Error::InvalidName(n)) Err(Error::InvalidName(n))
} }
} }
Some(&Token::SeqStart(_)) => { Some(&Token::Seq(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::SeqEnd, visitor) self.visit_seq(Some(len), Token::SeqEnd, visitor)
} }
Some(&Token::SeqArrayStart(_)) => { Some(&Token::SeqFixedSize(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::SeqEnd, visitor) self.visit_seq(Some(len), Token::SeqEnd, visitor)
} }
Some(&Token::TupleStart(_)) => { Some(&Token::Tuple(_)) => {
self.next_token(); self.next_token();
self.visit_seq(Some(len), Token::TupleEnd, visitor) self.visit_seq(Some(len), Token::TupleEnd, visitor)
} }
Some(&Token::TupleStructStart(n, _)) => { Some(&Token::TupleStruct(n, _)) => {
self.next_token(); self.next_token();
if name == n { if name == n {
self.visit_seq(Some(len), self.visit_seq(Some(len),
@@ -354,7 +354,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
where V: Visitor<'de> where V: Visitor<'de>
{ {
match self.tokens.first() { match self.tokens.first() {
Some(&Token::StructStart(n, _)) => { Some(&Token::Struct(n, _)) => {
self.next_token(); self.next_token();
if name == n { if name == n {
self.visit_map(Some(fields.len()), self.visit_map(Some(fields.len()),
@@ -364,7 +364,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
Err(Error::InvalidName(n)) Err(Error::InvalidName(n))
} }
} }
Some(&Token::MapStart(_)) => { Some(&Token::Map(_)) => {
self.next_token(); self.next_token();
self.visit_map(Some(fields.len()), Token::MapEnd, visitor) self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
} }
@@ -448,10 +448,10 @@ impl<'de, 'a> EnumVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
where V: DeserializeSeed<'de> where V: DeserializeSeed<'de>
{ {
match self.de.tokens.first() { match self.de.tokens.first() {
Some(&Token::EnumUnit(_, v)) | Some(&Token::UnitVariant(_, v)) |
Some(&Token::EnumNewType(_, v)) | Some(&Token::NewtypeVariant(_, v)) |
Some(&Token::EnumSeqStart(_, v, _)) | Some(&Token::TupleVariant(_, v, _)) |
Some(&Token::EnumMapStart(_, v, _)) => { Some(&Token::StructVariant(_, v, _)) => {
let de = v.into_deserializer(); let de = v.into_deserializer();
let value = try!(seed.deserialize(de)); let value = try!(seed.deserialize(de));
Ok((value, self)) Ok((value, self))
@@ -470,7 +470,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
fn visit_unit(self) -> Result<(), Error> { fn visit_unit(self) -> Result<(), Error> {
match self.de.tokens.first() { match self.de.tokens.first() {
Some(&Token::EnumUnit(_, _)) => { Some(&Token::UnitVariant(_, _)) => {
self.de.next_token(); self.de.next_token();
Ok(()) Ok(())
} }
@@ -483,7 +483,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
where T: DeserializeSeed<'de> where T: DeserializeSeed<'de>
{ {
match self.de.tokens.first() { match self.de.tokens.first() {
Some(&Token::EnumNewType(_, _)) => { Some(&Token::NewtypeVariant(_, _)) => {
self.de.next_token(); self.de.next_token();
seed.deserialize(self.de) seed.deserialize(self.de)
} }
@@ -496,16 +496,16 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
where V: Visitor<'de> where V: Visitor<'de>
{ {
match self.de.tokens.first() { match self.de.tokens.first() {
Some(&Token::EnumSeqStart(_, _, enum_len)) => { Some(&Token::TupleVariant(_, _, enum_len)) => {
let token = self.de.next_token().unwrap(); let token = self.de.next_token().unwrap();
if len == enum_len { if len == enum_len {
self.de.visit_seq(Some(len), Token::EnumSeqEnd, visitor) self.de.visit_seq(Some(len), Token::TupleVariantEnd, visitor)
} else { } else {
Err(Error::UnexpectedToken(token)) Err(Error::UnexpectedToken(token))
} }
} }
Some(&Token::SeqStart(Some(enum_len))) => { Some(&Token::Seq(Some(enum_len))) => {
let token = self.de.next_token().unwrap(); let token = self.de.next_token().unwrap();
if len == enum_len { if len == enum_len {
@@ -523,18 +523,18 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
where V: Visitor<'de> where V: Visitor<'de>
{ {
match self.de.tokens.first() { match self.de.tokens.first() {
Some(&Token::EnumMapStart(_, _, enum_len)) => { Some(&Token::StructVariant(_, _, enum_len)) => {
let token = self.de.next_token().unwrap(); let token = self.de.next_token().unwrap();
if fields.len() == enum_len { if fields.len() == enum_len {
self.de.visit_map(Some(fields.len()), self.de.visit_map(Some(fields.len()),
Token::EnumMapEnd, Token::StructVariantEnd,
visitor) visitor)
} else { } else {
Err(Error::UnexpectedToken(token)) Err(Error::UnexpectedToken(token))
} }
} }
Some(&Token::MapStart(Some(enum_len))) => { Some(&Token::Map(Some(enum_len))) => {
let token = self.de.next_token().unwrap(); let token = self.de.next_token().unwrap();
if fields.len() == enum_len { if fields.len() == enum_len {
@@ -605,11 +605,11 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
let visitor = DeserializerSeqVisitor { let visitor = DeserializerSeqVisitor {
de: self.de, de: self.de,
len: None, len: None,
end: Token::EnumSeqEnd, end: Token::TupleVariantEnd,
}; };
try!(seed.deserialize(SeqVisitorDeserializer::new(visitor))) try!(seed.deserialize(SeqVisitorDeserializer::new(visitor)))
}; };
try!(self.de.expect_token(Token::EnumSeqEnd)); try!(self.de.expect_token(Token::TupleVariantEnd));
Ok(value) Ok(value)
} }
EnumFormat::Map => { EnumFormat::Map => {
@@ -617,11 +617,11 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
let visitor = DeserializerMapVisitor { let visitor = DeserializerMapVisitor {
de: self.de, de: self.de,
len: None, len: None,
end: Token::EnumMapEnd, end: Token::StructVariantEnd,
}; };
try!(seed.deserialize(MapVisitorDeserializer::new(visitor))) try!(seed.deserialize(MapVisitorDeserializer::new(visitor)))
}; };
try!(self.de.expect_token(Token::EnumMapEnd)); try!(self.de.expect_token(Token::StructVariantEnd));
Ok(value) Ok(value)
} }
EnumFormat::Any => seed.deserialize(&mut *self.de), EnumFormat::Any => seed.deserialize(&mut *self.de),
serde_test/src/ser.rs
+17 -17
View File
@@ -149,12 +149,12 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
_variant_index: usize, _variant_index: usize,
variant: &'static str) variant: &'static str)
-> Result<(), Error> { -> Result<(), Error> {
if self.tokens.first() == Some(&Token::EnumStart(name)) { if self.tokens.first() == Some(&Token::Enum(name)) {
self.next_token(); self.next_token();
assert_next_token!(self, Str(variant)); assert_next_token!(self, Str(variant));
assert_next_token!(self, Unit); assert_next_token!(self, Unit);
} else { } else {
assert_next_token!(self, EnumUnit(name, variant)); assert_next_token!(self, UnitVariant(name, variant));
} }
Ok(()) Ok(())
} }
@@ -162,7 +162,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<(), Error> fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<(), Error>
where T: Serialize where T: Serialize
{ {
assert_next_token!(self, StructNewType(name)); assert_next_token!(self, NewtypeStruct(name));
value.serialize(self) value.serialize(self)
} }
@@ -174,44 +174,44 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
-> Result<(), Error> -> Result<(), Error>
where T: Serialize where T: Serialize
{ {
if self.tokens.first() == Some(&Token::EnumStart(name)) { if self.tokens.first() == Some(&Token::Enum(name)) {
self.next_token(); self.next_token();
assert_next_token!(self, Str(variant)); assert_next_token!(self, Str(variant));
} else { } else {
assert_next_token!(self, EnumNewType(name, variant)); assert_next_token!(self, NewtypeVariant(name, variant));
} }
value.serialize(self) value.serialize(self)
} }
fn serialize_none(self) -> Result<(), Error> { fn serialize_none(self) -> Result<(), Error> {
assert_next_token!(self, Option(false)); assert_next_token!(self, None);
Ok(()) Ok(())
} }
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Error> fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Error>
where T: Serialize where T: Serialize
{ {
assert_next_token!(self, Option(true)); assert_next_token!(self, Some);
value.serialize(self) value.serialize(self)
} }
fn serialize_seq(self, len: Option<usize>) -> Result<Self, Error> { fn serialize_seq(self, len: Option<usize>) -> Result<Self, Error> {
assert_next_token!(self, SeqStart(len)); assert_next_token!(self, Seq(len));
Ok(self) Ok(self)
} }
fn serialize_seq_fixed_size(self, len: usize) -> Result<Self, Error> { fn serialize_seq_fixed_size(self, len: usize) -> Result<Self, Error> {
assert_next_token!(self, SeqArrayStart(len)); assert_next_token!(self, SeqFixedSize(len));
Ok(self) Ok(self)
} }
fn serialize_tuple(self, len: usize) -> Result<Self, Error> { fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
assert_next_token!(self, TupleStart(len)); assert_next_token!(self, Tuple(len));
Ok(self) Ok(self)
} }
fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self, Error> { fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self, Error> {
assert_next_token!(self, TupleStructStart(name, len)); assert_next_token!(self, TupleStruct(name, len));
Ok(self) Ok(self)
} }
@@ -221,17 +221,17 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
variant: &'static str, variant: &'static str,
len: usize) len: usize)
-> Result<Self, Error> { -> Result<Self, Error> {
assert_next_token!(self, EnumSeqStart(name, variant, len)); assert_next_token!(self, TupleVariant(name, variant, len));
Ok(self) Ok(self)
} }
fn serialize_map(self, len: Option<usize>) -> Result<Self, Error> { fn serialize_map(self, len: Option<usize>) -> Result<Self, Error> {
assert_next_token!(self, MapStart(len)); assert_next_token!(self, Map(len));
Ok(self) Ok(self)
} }
fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self, Error> { fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self, Error> {
assert_next_token!(self, StructStart(name, len)); assert_next_token!(self, Struct(name, len));
Ok(self) Ok(self)
} }
@@ -241,7 +241,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
variant: &'static str, variant: &'static str,
len: usize) len: usize)
-> Result<Self, Error> { -> Result<Self, Error> {
assert_next_token!(self, EnumMapStart(name, variant, len)); assert_next_token!(self, StructVariant(name, variant, len));
Ok(self) Ok(self)
} }
} }
@@ -305,7 +305,7 @@ impl<'s, 'a> ser::SerializeTupleVariant for &'s mut Serializer<'a> {
} }
fn end(self) -> Result<(), Error> { fn end(self) -> Result<(), Error> {
assert_next_token!(self, EnumSeqEnd); assert_next_token!(self, TupleVariantEnd);
Ok(()) Ok(())
} }
} }
@@ -367,7 +367,7 @@ impl<'s, 'a> ser::SerializeStructVariant for &'s mut Serializer<'a> {
} }
fn end(self) -> Result<(), Self::Error> { fn end(self) -> Result<(), Self::Error> {
assert_next_token!(self, EnumMapEnd); assert_next_token!(self, StructVariantEnd);
Ok(()) Ok(())
} }
} }