pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-23 00:08:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename named_* to use {enum,struct,unit}_*

Browse Source 
This better reflects how they're used.
This commit is contained in:
Erick Tryzelaar
2015-07-04 12:11:20 -07:00
parent d30cf07254
commit 10f23dddfe
8 changed files with 66 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_tests/tests/test_de.rs
+19 -19
View File
@@ -161,7 +161,7 @@ impl Deserializer for TokenDeserializer {
}
}
fn visit_named_unit<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
fn visit_unit_struct<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.tokens.peek() {
@@ -178,7 +178,7 @@ impl Deserializer for TokenDeserializer {
}
}
fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
fn visit_tuple_struct<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.tokens.peek() {
@@ -195,7 +195,7 @@ impl Deserializer for TokenDeserializer {
}
}
fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
fn visit_struct<V>(&mut self, name: &str, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor,
{
match self.tokens.peek() {
@@ -334,13 +334,13 @@ impl<'a> de::VariantVisitor for TokenDeserializerVariantVisitor<'a> {
//////////////////////////////////////////////////////////////////////////
#[derive(Copy, Clone, PartialEq, Debug, Deserialize)]
struct NamedUnit;
struct UnitStruct;
#[derive(PartialEq, Debug, Deserialize)]
struct NamedSeq(i32, i32, i32);
struct TupleStruct(i32, i32, i32);
#[derive(PartialEq, Debug, Deserialize)]
struct NamedMap {
struct Struct {
a: i32,
b: i32,
c: i32,
@@ -498,19 +498,19 @@ declare_tests! {
Token::SeqEnd,
],
}
test_named_unit {
NamedUnit => vec![Token::Unit],
NamedUnit => vec![
Token::Name("NamedUnit"),
test_unit_struct {
UnitStruct => vec![Token::Unit],
UnitStruct => vec![
Token::Name("UnitStruct"),
Token::Unit,
],
NamedUnit => vec![
UnitStruct => vec![
Token::SeqStart(0),
Token::SeqEnd,
],
}
test_named_seq {
NamedSeq(1, 2, 3) => vec![
test_tuple_struct {
TupleStruct(1, 2, 3) => vec![
Token::SeqStart(3),
Token::SeqSep,
Token::I32(1),
@@ -522,8 +522,8 @@ declare_tests! {
Token::I32(3),
Token::SeqEnd,
],
NamedSeq(1, 2, 3) => vec![
Token::Name("NamedSeq"),
TupleStruct(1, 2, 3) => vec![
Token::Name("TupleStruct"),
Token::SeqStart(3),
Token::SeqSep,
Token::I32(1),
@@ -818,8 +818,8 @@ declare_tests! {
Token::MapEnd,
],
}
test_named_map {
NamedMap { a: 1, b: 2, c: 3 } => vec![
test_struct {
Struct { a: 1, b: 2, c: 3 } => vec![
Token::MapStart(3),
Token::MapSep,
Token::Str("a"),
@@ -834,8 +834,8 @@ declare_tests! {
Token::I32(3),
Token::MapEnd,
],
NamedMap { a: 1, b: 2, c: 3 } => vec![
Token::Name("NamedMap"),
Struct { a: 1, b: 2, c: 3 } => vec![
Token::Name("Struct"),
Token::MapStart(3),
Token::MapSep,
Token::Str("a"),
serde_tests/tests/test_ser.rs
+20 -20
View File
@@ -24,17 +24,17 @@ pub enum Token<'a> {
Option(bool),
Unit,
NamedUnit(&'a str),
UnitStruct(&'a str),
EnumUnit(&'a str, &'a str),
SeqStart(Option<usize>),
NamedSeqStart(&'a str, Option<usize>),
TupleStructStart(&'a str, Option<usize>),
EnumSeqStart(&'a str, &'a str, Option<usize>),
SeqSep,
SeqEnd,
MapStart(Option<usize>),
NamedMapStart(&'a str, Option<usize>),
StructStart(&'a str, Option<usize>),
EnumMapStart(&'a str, &'a str, Option<usize>),
MapSep,
MapEnd,
@@ -80,8 +80,8 @@ impl<'a> Serializer for AssertSerializer<'a> {
Ok(())
}
fn visit_named_unit(&mut self, name: &str) -> Result<(), ()> {
assert_eq!(self.iter.next().unwrap(), Token::NamedUnit(name));
fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
assert_eq!(self.iter.next().unwrap(), Token::UnitStruct(name));
Ok(())
}
@@ -188,12 +188,12 @@ impl<'a> Serializer for AssertSerializer<'a> {
self.visit_sequence(visitor)
}
fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
fn visit_tuple_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
where V: SeqVisitor
{
let len = visitor.len();
assert_eq!(self.iter.next().unwrap(), Token::NamedSeqStart(name, len));
assert_eq!(self.iter.next().unwrap(), Token::TupleStructStart(name, len));
self.visit_sequence(visitor)
}
@@ -228,12 +228,12 @@ impl<'a> Serializer for AssertSerializer<'a> {
self.visit_mapping(visitor)
}
fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
fn visit_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
where V: MapVisitor
{
let len = visitor.len();
assert_eq!(self.iter.next().unwrap(), Token::NamedMapStart(name, len));
assert_eq!(self.iter.next().unwrap(), Token::StructStart(name, len));
self.visit_mapping(visitor)
}
@@ -262,13 +262,13 @@ impl<'a> Serializer for AssertSerializer<'a> {
//////////////////////////////////////////////////////////////////////////
#[derive(Serialize)]
struct NamedUnit;
struct UnitStruct;
#[derive(Serialize)]
struct NamedSeq(i32, i32, i32);
struct TupleStruct(i32, i32, i32);
#[derive(Serialize)]
struct NamedMap {
struct Struct {
a: i32,
b: i32,
c: i32,
@@ -480,12 +480,12 @@ declare_tests! {
Token::MapEnd,
],
}
test_named_unit {
NamedUnit => vec![Token::NamedUnit("NamedUnit")],
test_unit_struct {
UnitStruct => vec![Token::UnitStruct("UnitStruct")],
}
test_named_seq {
NamedSeq(1, 2, 3) => vec![
Token::NamedSeqStart("NamedSeq", Some(3)),
test_tuple_struct {
TupleStruct(1, 2, 3) => vec![
Token::TupleStructStart("TupleStruct", Some(3)),
Token::SeqSep,
Token::I32(1),
@@ -497,9 +497,9 @@ declare_tests! {
Token::SeqEnd,
],
}
test_named_map {
NamedMap { a: 1, b: 2, c: 3 } => vec![
Token::NamedMapStart("NamedMap", Some(3)),
test_struct {
Struct { a: 1, b: 2, c: 3 } => vec![
Token::StructStart("Struct", Some(3)),
Token::MapSep,
Token::Str("a"),
Token::I32(1),