berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Update to serde 0.5.0

This commit is contained in:
Erick Tryzelaar 2015-07-29 13:13:21 -07:00
parent 0d6b8a48b6
commit 8ec54e562a
2 changed files with 48 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
src/reader_serde.rs
View File

@ -346,13 +346,18 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
} }
} }
fn visit_enum<V>(&mut self, _enum: &str, mut visitor: V) -> Result<V::Value, Self::Error> fn visit_enum<V>(&mut self,
_enum: &'static str,
_variants: &'static [&'static str],
mut visitor: V) -> Result<V::Value, Self::Error>
where V: serde::de::EnumVisitor, where V: serde::de::EnumVisitor,
{ {
visitor.visit(self) visitor.visit(self)
} }
fn visit_tuple<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn visit_tuple<V>(&mut self,
_len: usize,
mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
struct TupleVisitor<'a, 'b: 'a, R: Read + 'b>(&'a mut Deserializer<'b, R>); struct TupleVisitor<'a, 'b: 'a, R: Read + 'b>(&'a mut Deserializer<'b, R>);
@ -375,12 +380,6 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit_seq(TupleVisitor(self)) visitor.visit_seq(TupleVisitor(self))
} }
fn visit_named_seq<V>(&mut self, _name: &str, visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor,
{
self.visit_tuple(visitor)
}
fn visit_option<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value> fn visit_option<V>(&mut self, mut visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
@ -476,56 +475,13 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
visitor.visit_map(MapVisitor { deserializer: self, len: len }) visitor.visit_map(MapVisitor { deserializer: self, len: len })
} }
fn visit_named_map<V>(&mut self, fn visit_struct<V>(&mut self,
_name: &str, _name: &str,
fields: &'static [&'static str], fields: &'static [&'static str],
mut visitor: V) -> DeserializeResult<V::Value> visitor: V) -> DeserializeResult<V::Value>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
struct StructVisitor<'a, 'b: 'a, R: Read + 'b> { self.visit_tuple(fields.len(), visitor)
deserializer: &'a mut Deserializer<'b, R>,
index: usize,
fields: &'static [&'static str],
}
impl<'a, 'b: 'a, R: Read + 'b> serde::de::MapVisitor for StructVisitor<'a, 'b, R> {
type Error = DeserializeError;
fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
where K: serde::de::Deserialize,
{
if self.index < self.fields.len() {
let mut deserializer = self.index.into_deserializer();
self.index += 1;
let key = try!(serde::Deserialize::deserialize(&mut deserializer));
Ok(Some(key))
} else {
Ok(None)
}
}
fn visit_value<V>(&mut self) -> Result<V, Self::Error>
where V: serde::de::Deserialize,
{
let value = try!(serde::Deserialize::deserialize(self.deserializer));
Ok(value)
}
fn end(&mut self) -> Result<(), Self::Error> {
if self.index < self.fields.len() {
Err(serde::de::Error::missing_field_error(self.fields[self.index]))
} else {
Ok(())
}
}
}
visitor.visit_map(StructVisitor {
deserializer: self,
index: 0,
fields: fields,
})
} }
} }
@ -544,20 +500,21 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
Ok(()) Ok(())
} }
fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> fn visit_tuple<V>(&mut self,
len: usize,
visitor: V) -> Result<V::Value, Self::Error>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
serde::de::Deserializer::visit_named_seq(self, "", visitor) serde::de::Deserializer::visit_tuple(self, len, visitor)
} }
fn visit_map<V>(&mut self, fn visit_struct<V>(&mut self,
fields: &'static [&'static str], fields: &'static [&'static str],
visitor: V) -> Result<V::Value, Self::Error> visitor: V) -> Result<V::Value, Self::Error>
where V: serde::de::Visitor, where V: serde::de::Visitor,
{ {
serde::de::Deserializer::visit_named_map(self, "", fields, visitor) serde::de::Deserializer::visit_tuple(self, fields.len(), visitor)
} }
} }
pub fn from_reader<R, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult<T> pub fn from_reader<R, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult<T>

70
src/writer_serde.rs
View File

@ -174,14 +174,6 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(()) Ok(())
} }
fn visit_named_seq<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor,
{
while let Some(()) = try!(visitor.visit(self)) { }
Ok(())
}
fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()> fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
where V: serde::Serialize, where V: serde::Serialize,
{ {
@ -211,7 +203,7 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
value.serialize(self) value.serialize(self)
} }
fn visit_named_map<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> fn visit_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
@ -219,25 +211,25 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(()) Ok(())
} }
fn visit_named_map_elt<K, V>(&mut self, _key: K, value: V) -> SerializeResult<()> fn visit_struct_elt<K, V>(&mut self, _key: K, value: V) -> SerializeResult<()>
where K: serde::Serialize, where K: serde::Serialize,
V: serde::Serialize, V: serde::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn visit_enum_unit(&mut self, fn visit_unit_variant(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str) -> SerializeResult<()> { _variant: &str) -> SerializeResult<()> {
self.add_enum_tag(variant_index) self.add_enum_tag(variant_index)
} }
fn visit_enum_seq<V>(&mut self, fn visit_tuple_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
mut visitor: V) -> SerializeResult<()> mut visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor, where V: serde::ser::SeqVisitor,
{ {
try!(self.add_enum_tag(variant_index)); try!(self.add_enum_tag(variant_index));
@ -247,11 +239,11 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
Ok(()) Ok(())
} }
fn visit_enum_map<V>(&mut self, fn visit_struct_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
mut visitor: V) -> SerializeResult<()> mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
try!(self.add_enum_tag(variant_index)); try!(self.add_enum_tag(variant_index));
@ -386,12 +378,6 @@ impl serde::Serializer for SizeChecker {
Ok(()) Ok(())
} }
fn visit_named_seq<V>(&mut self, _name: &str, visitor: V) -> SerializeResult<()>
where V: serde::ser::SeqVisitor,
{
self.visit_tuple(visitor)
}
fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()> fn visit_seq_elt<V>(&mut self, value: V) -> SerializeResult<()>
where V: serde::Serialize, where V: serde::Serialize,
{ {
@ -421,7 +407,7 @@ impl serde::Serializer for SizeChecker {
value.serialize(self) value.serialize(self)
} }
fn visit_named_map<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()> fn visit_struct<V>(&mut self, _name: &str, mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
while let Some(()) = try!(visitor.visit(self)) { } while let Some(()) = try!(visitor.visit(self)) { }
@ -429,21 +415,21 @@ impl serde::Serializer for SizeChecker {
Ok(()) Ok(())
} }
fn visit_named_map_elt<K, V>(&mut self, _key: K, value: V) -> SerializeResult<()> fn visit_struct_elt<K, V>(&mut self, _key: K, value: V) -> SerializeResult<()>
where K: serde::Serialize, where K: serde::Serialize,
V: serde::Serialize, V: serde::Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn visit_enum_unit(&mut self, fn visit_unit_variant(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str) -> SerializeResult<()> { _variant: &str) -> SerializeResult<()> {
self.add_enum_tag(variant_index) self.add_enum_tag(variant_index)
} }
fn visit_enum_seq<V>(&mut self, fn visit_tuple_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
@ -457,11 +443,11 @@ impl serde::Serializer for SizeChecker {
Ok(()) Ok(())
} }
fn visit_enum_map<V>(&mut self, fn visit_struct_variant<V>(&mut self,
_name: &str, _name: &str,
variant_index: usize, variant_index: usize,
_variant: &str, _variant: &str,
mut visitor: V) -> SerializeResult<()> mut visitor: V) -> SerializeResult<()>
where V: serde::ser::MapVisitor, where V: serde::ser::MapVisitor,
{ {
try!(self.add_enum_tag(variant_index)); try!(self.add_enum_tag(variant_index));