mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format serde with rustfmt 0.8.0

Browse Source
This commit is contained in:
David Tolnay 2017-03-08 21:11:17 -08:00
parent 6750fdaae1
commit 77ee306b57
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
7 changed files with 245 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
serde/src/de/content.rs
View File

@ -604,8 +604,10 @@ impl<E> Deserializer for ContentDeserializer<E>
Ok(value) Ok(value)
} }
Content::Map(v) => { Content::Map(v) => {
let map = v.into_iter() let map = v.into_iter().map(|(k, v)| {
.map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v))); (ContentDeserializer::new(k),
ContentDeserializer::new(v))
});
let mut map_visitor = de::value::MapDeserializer::new(map); let mut map_visitor = de::value::MapDeserializer::new(map);
let value = try!(visitor.visit_map(&mut map_visitor)); let value = try!(visitor.visit_map(&mut map_visitor));
try!(map_visitor.end()); try!(map_visitor.end());
@ -632,8 +634,12 @@ impl<E> Deserializer for ContentDeserializer<E>
visitor.visit_newtype_struct(self) visitor.visit_newtype_struct(self)
} }
fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error> fn deserialize_enum<V>(self,
where V: Visitor, _name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor
{ {
let (variant, value) = match self.content { let (variant, value) = match self.content {
Content::Map(value) => { Content::Map(value) => {
@ -641,12 +647,14 @@ impl<E> Deserializer for ContentDeserializer<E>
let (variant, value) = match iter.next() { let (variant, value) = match iter.next() {
Some(v) => v, Some(v) => v,
None => { None => {
return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key")); return Err(de::Error::invalid_value(de::Unexpected::Map,
&"map with a single key"));
} }
}; };
// enums are encoded in json as maps with a single key:value pair // enums are encoded in json as maps with a single key:value pair
if iter.next().is_some() { if iter.next().is_some() {
return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key")); return Err(de::Error::invalid_value(de::Unexpected::Map,
&"map with a single key"));
} }
(variant, Some(value)) (variant, Some(value))
} }
@ -680,30 +688,43 @@ impl<E> ContentDeserializer<E> {
} }
} }
struct EnumDeserializer<E> where E: de::Error { struct EnumDeserializer<E>
where E: de::Error
{
variant: Content, variant: Content,
value: Option<Content>, value: Option<Content>,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<E> de::EnumVisitor for EnumDeserializer<E> where E: de::Error { impl<E> de::EnumVisitor for EnumDeserializer<E>
where E: de::Error
{
type Error = E; type Error = E;
type Variant = VariantDeserializer<Self::Error>; type Variant = VariantDeserializer<Self::Error>;
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer<E>), Self::Error> fn visit_variant_seed<V>(self,
where V: de::DeserializeSeed, seed: V)
-> Result<(V::Value, VariantDeserializer<E>), Self::Error>
where V: de::DeserializeSeed
{ {
let visitor = VariantDeserializer { value: self.value, err: PhantomData, }; let visitor = VariantDeserializer {
value: self.value,
err: PhantomData,
};
seed.deserialize(ContentDeserializer::new(self.variant)).map(|v| (v, visitor)) seed.deserialize(ContentDeserializer::new(self.variant)).map(|v| (v, visitor))
} }
} }
struct VariantDeserializer<E> where E: de::Error { struct VariantDeserializer<E>
where E: de::Error
{
value: Option<Content>, value: Option<Content>,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<E> de::VariantVisitor for VariantDeserializer<E> where E: de::Error { impl<E> de::VariantVisitor for VariantDeserializer<E>
where E: de::Error
{
type Error = E; type Error = E;
fn visit_unit(self) -> Result<(), E> { fn visit_unit(self) -> Result<(), E> {
@ -722,11 +743,7 @@ impl<E> de::VariantVisitor for VariantDeserializer<E> where E: de::Error {
} }
} }
fn visit_tuple<V>( fn visit_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
self,
_len: usize,
visitor: V
) -> Result<V::Value, Self::Error>
where V: de::Visitor where V: de::Visitor
{ {
match self.value { match self.value {
@ -734,15 +751,14 @@ impl<E> de::VariantVisitor for VariantDeserializer<E> where E: de::Error {
de::Deserializer::deserialize(SeqDeserializer::new(v), visitor) de::Deserializer::deserialize(SeqDeserializer::new(v), visitor)
} }
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")), Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")) None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")),
} }
} }
fn visit_struct<V>( fn visit_struct<V>(self,
self,
_fields: &'static [&'static str], _fields: &'static [&'static str],
visitor: V visitor: V)
) -> Result<V::Value, Self::Error> -> Result<V::Value, Self::Error>
where V: de::Visitor where V: de::Visitor
{ {
match self.value { match self.value {
@ -750,17 +766,21 @@ impl<E> de::VariantVisitor for VariantDeserializer<E> where E: de::Error {
de::Deserializer::deserialize(MapDeserializer::new(v), visitor) de::Deserializer::deserialize(MapDeserializer::new(v), visitor)
} }
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")), Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
_ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")) _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")),
} }
} }
} }
struct SeqDeserializer<E> where E: de::Error { struct SeqDeserializer<E>
where E: de::Error
{
iter: <Vec<Content> as IntoIterator>::IntoIter, iter: <Vec<Content> as IntoIterator>::IntoIter,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<E> SeqDeserializer<E> where E: de::Error { impl<E> SeqDeserializer<E>
where E: de::Error
{
fn new(vec: Vec<Content>) -> Self { fn new(vec: Vec<Content>) -> Self {
SeqDeserializer { SeqDeserializer {
iter: vec.into_iter(), iter: vec.into_iter(),
@ -769,12 +789,14 @@ impl<E> SeqDeserializer<E> where E: de::Error {
} }
} }
impl<E> de::Deserializer for SeqDeserializer<E> where E: de::Error { impl<E> de::Deserializer for SeqDeserializer<E>
where E: de::Error
{
type Error = E; type Error = E;
#[inline] #[inline]
fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor
{ {
let len = self.iter.len(); let len = self.iter.len();
if len == 0 { if len == 0 {
@ -797,11 +819,13 @@ impl<E> de::Deserializer for SeqDeserializer<E> where E: de::Error {
} }
} }
impl<E> de::SeqVisitor for SeqDeserializer<E> where E: de::Error { impl<E> de::SeqVisitor for SeqDeserializer<E>
where E: de::Error
{
type Error = E; type Error = E;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed, where T: de::DeserializeSeed
{ {
match self.iter.next() { match self.iter.next() {
Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some), Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
@ -814,13 +838,17 @@ impl<E> de::SeqVisitor for SeqDeserializer<E> where E: de::Error {
} }
} }
struct MapDeserializer<E> where E: de::Error { struct MapDeserializer<E>
where E: de::Error
{
iter: <Vec<(Content, Content)> as IntoIterator>::IntoIter, iter: <Vec<(Content, Content)> as IntoIterator>::IntoIter,
value: Option<Content>, value: Option<Content>,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<E> MapDeserializer<E> where E: de::Error { impl<E> MapDeserializer<E>
where E: de::Error
{
fn new(map: Vec<(Content, Content)>) -> Self { fn new(map: Vec<(Content, Content)>) -> Self {
MapDeserializer { MapDeserializer {
iter: map.into_iter(), iter: map.into_iter(),
@ -830,11 +858,13 @@ impl<E> MapDeserializer<E> where E: de::Error {
} }
} }
impl<E> de::MapVisitor for MapDeserializer<E> where E: de::Error { impl<E> de::MapVisitor for MapDeserializer<E>
where E: de::Error
{
type Error = E; type Error = E;
fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed, where T: de::DeserializeSeed
{ {
match self.iter.next() { match self.iter.next() {
Some((key, value)) => { Some((key, value)) => {
@ -846,7 +876,7 @@ impl<E> de::MapVisitor for MapDeserializer<E> where E: de::Error {
} }
fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
where T: de::DeserializeSeed, where T: de::DeserializeSeed
{ {
match self.value.take() { match self.value.take() {
Some(value) => seed.deserialize(ContentDeserializer::new(value)), Some(value) => seed.deserialize(ContentDeserializer::new(value)),
@ -859,12 +889,14 @@ impl<E> de::MapVisitor for MapDeserializer<E> where E: de::Error {
} }
} }
impl<E> de::Deserializer for MapDeserializer<E> where E: de::Error { impl<E> de::Deserializer for MapDeserializer<E>
where E: de::Error
{
type Error = E; type Error = E;
#[inline] #[inline]
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor
{ {
visitor.visit_map(self) visitor.visit_map(self)
} }
@ -920,7 +952,8 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
} }
Content::Map(ref v) => { Content::Map(ref v) => {
let map = v.into_iter().map(|&(ref k, ref v)| { let map = v.into_iter().map(|&(ref k, ref v)| {
(ContentRefDeserializer::new(k), ContentRefDeserializer::new(v)) (ContentRefDeserializer::new(k),
ContentRefDeserializer::new(v))
}); });
let mut map_visitor = de::value::MapDeserializer::new(map); let mut map_visitor = de::value::MapDeserializer::new(map);
let value = try!(visitor.visit_map(&mut map_visitor)); let value = try!(visitor.visit_map(&mut map_visitor));
@ -948,8 +981,12 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
visitor.visit_newtype_struct(self) visitor.visit_newtype_struct(self)
} }
fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error> fn deserialize_enum<V>(self,
where V: Visitor, _name: &str,
_variants: &'static [&'static str],
visitor: V)
-> Result<V::Value, Self::Error>
where V: Visitor
{ {
let (variant, value) = match *self.content { let (variant, value) = match *self.content {
Content::Map(ref value) => { Content::Map(ref value) => {
@ -957,12 +994,14 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
let &(ref variant, ref value) = match iter.next() { let &(ref variant, ref value) = match iter.next() {
Some(v) => v, Some(v) => v,
None => { None => {
return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key")); return Err(de::Error::invalid_value(de::Unexpected::Map,
&"map with a single key"));
} }
}; };
// enums are encoded in json as maps with a single key:value pair // enums are encoded in json as maps with a single key:value pair
if iter.next().is_some() { if iter.next().is_some() {
return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key")); return Err(de::Error::invalid_value(de::Unexpected::Map,
&"map with a single key"));
} }
(variant, Some(value)) (variant, Some(value))
} }
@ -996,30 +1035,41 @@ impl<'a, E> ContentRefDeserializer<'a, E> {
} }
} }
struct EnumRefDeserializer<'a, E> where E: de::Error { struct EnumRefDeserializer<'a, E>
where E: de::Error
{
variant: &'a Content, variant: &'a Content,
value: Option<&'a Content>, value: Option<&'a Content>,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<'a, E> de::EnumVisitor for EnumRefDeserializer<'a, E> where E: de::Error { impl<'a, E> de::EnumVisitor for EnumRefDeserializer<'a, E>
where E: de::Error
{
type Error = E; type Error = E;
type Variant = VariantRefDeserializer<'a, Self::Error>; type Variant = VariantRefDeserializer<'a, Self::Error>;
fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
where V: de::DeserializeSeed, where V: de::DeserializeSeed
{ {
let visitor = VariantRefDeserializer { value: self.value, err: PhantomData, }; let visitor = VariantRefDeserializer {
value: self.value,
err: PhantomData,
};
seed.deserialize(ContentRefDeserializer::new(self.variant)).map(|v| (v, visitor)) seed.deserialize(ContentRefDeserializer::new(self.variant)).map(|v| (v, visitor))
} }
} }
struct VariantRefDeserializer<'a, E> where E: de::Error { struct VariantRefDeserializer<'a, E>
where E: de::Error
{
value: Option<&'a Content>, value: Option<&'a Content>,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<'a, E> de::VariantVisitor for VariantRefDeserializer<'a, E> where E: de::Error { impl<'a, E> de::VariantVisitor for VariantRefDeserializer<'a, E>
where E: de::Error
{
type Error = E; type Error = E;
fn visit_unit(self) -> Result<(), E> { fn visit_unit(self) -> Result<(), E> {
@ -1038,11 +1088,7 @@ impl<'a, E> de::VariantVisitor for VariantRefDeserializer<'a, E> where E: de::Er
} }
} }
fn visit_tuple<V>( fn visit_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
self,
_len: usize,
visitor: V
) -> Result<V::Value, Self::Error>
where V: de::Visitor where V: de::Visitor
{ {
match self.value { match self.value {
@ -1050,15 +1096,14 @@ impl<'a, E> de::VariantVisitor for VariantRefDeserializer<'a, E> where E: de::Er
de::Deserializer::deserialize(SeqRefDeserializer::new(v), visitor) de::Deserializer::deserialize(SeqRefDeserializer::new(v), visitor)
} }
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")), Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")) None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant")),
} }
} }
fn visit_struct<V>( fn visit_struct<V>(self,
self,
_fields: &'static [&'static str], _fields: &'static [&'static str],
visitor: V visitor: V)
) -> Result<V::Value, Self::Error> -> Result<V::Value, Self::Error>
where V: de::Visitor where V: de::Visitor
{ {
match self.value { match self.value {
@ -1066,17 +1111,21 @@ impl<'a, E> de::VariantVisitor for VariantRefDeserializer<'a, E> where E: de::Er
de::Deserializer::deserialize(MapRefDeserializer::new(v), visitor) de::Deserializer::deserialize(MapRefDeserializer::new(v), visitor)
} }
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")), Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
_ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")) _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant")),
} }
} }
} }
struct SeqRefDeserializer<'a, E> where E: de::Error { struct SeqRefDeserializer<'a, E>
where E: de::Error
{
iter: <&'a [Content] as IntoIterator>::IntoIter, iter: <&'a [Content] as IntoIterator>::IntoIter,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<'a, E> SeqRefDeserializer<'a, E> where E: de::Error { impl<'a, E> SeqRefDeserializer<'a, E>
where E: de::Error
{
fn new(vec: &'a [Content]) -> Self { fn new(vec: &'a [Content]) -> Self {
SeqRefDeserializer { SeqRefDeserializer {
iter: vec.into_iter(), iter: vec.into_iter(),
@ -1085,12 +1134,14 @@ impl<'a, E> SeqRefDeserializer<'a, E> where E: de::Error {
} }
} }
impl<'a, E> de::Deserializer for SeqRefDeserializer<'a, E> where E: de::Error { impl<'a, E> de::Deserializer for SeqRefDeserializer<'a, E>
where E: de::Error
{
type Error = E; type Error = E;
#[inline] #[inline]
fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor
{ {
let len = self.iter.len(); let len = self.iter.len();
if len == 0 { if len == 0 {
@ -1113,11 +1164,13 @@ impl<'a, E> de::Deserializer for SeqRefDeserializer<'a, E> where E: de::Error {
} }
} }
impl<'a, E> de::SeqVisitor for SeqRefDeserializer<'a, E> where E: de::Error { impl<'a, E> de::SeqVisitor for SeqRefDeserializer<'a, E>
where E: de::Error
{
type Error = E; type Error = E;
fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed, where T: de::DeserializeSeed
{ {
match self.iter.next() { match self.iter.next() {
Some(value) => seed.deserialize(ContentRefDeserializer::new(value)).map(Some), Some(value) => seed.deserialize(ContentRefDeserializer::new(value)).map(Some),
@ -1130,13 +1183,17 @@ impl<'a, E> de::SeqVisitor for SeqRefDeserializer<'a, E> where E: de::Error {
} }
} }
struct MapRefDeserializer<'a, E> where E: de::Error { struct MapRefDeserializer<'a, E>
where E: de::Error
{
iter: <&'a [(Content, Content)] as IntoIterator>::IntoIter, iter: <&'a [(Content, Content)] as IntoIterator>::IntoIter,
value: Option<&'a Content>, value: Option<&'a Content>,
err: PhantomData<E>, err: PhantomData<E>,
} }
impl<'a, E> MapRefDeserializer<'a, E> where E: de::Error { impl<'a, E> MapRefDeserializer<'a, E>
where E: de::Error
{
fn new(map: &'a [(Content, Content)]) -> Self { fn new(map: &'a [(Content, Content)]) -> Self {
MapRefDeserializer { MapRefDeserializer {
iter: map.into_iter(), iter: map.into_iter(),
@ -1146,11 +1203,13 @@ impl<'a, E> MapRefDeserializer<'a, E> where E: de::Error {
} }
} }
impl<'a, E> de::MapVisitor for MapRefDeserializer<'a, E> where E: de::Error { impl<'a, E> de::MapVisitor for MapRefDeserializer<'a, E>
where E: de::Error
{
type Error = E; type Error = E;
fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error> fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where T: de::DeserializeSeed, where T: de::DeserializeSeed
{ {
match self.iter.next() { match self.iter.next() {
Some(&(ref key, ref value)) => { Some(&(ref key, ref value)) => {
@ -1162,7 +1221,7 @@ impl<'a, E> de::MapVisitor for MapRefDeserializer<'a, E> where E: de::Error {
} }
fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error> fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
where T: de::DeserializeSeed, where T: de::DeserializeSeed
{ {
match self.value.take() { match self.value.take() {
Some(value) => seed.deserialize(ContentRefDeserializer::new(value)), Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
@ -1175,12 +1234,14 @@ impl<'a, E> de::MapVisitor for MapRefDeserializer<'a, E> where E: de::Error {
} }
} }
impl<'a, E> de::Deserializer for MapRefDeserializer<'a, E> where E: de::Error { impl<'a, E> de::Deserializer for MapRefDeserializer<'a, E>
where E: de::Error
{
type Error = E; type Error = E;
#[inline] #[inline]
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor
{ {
visitor.visit_map(self) visitor.visit_map(self)
} }

8
serde/src/de/value.rs
View File

@ -192,11 +192,11 @@ primitive_deserializer!(char, CharDeserializer, visit_char);
/// A helper deserializer that deserializes a number. /// A helper deserializer that deserializes a number.
pub struct U32Deserializer<E> { pub struct U32Deserializer<E> {
value: u32, value: u32,
marker: PhantomData<E> marker: PhantomData<E>,
} }
impl<E> ValueDeserializer<E> for u32 impl<E> ValueDeserializer<E> for u32
where E: de::Error, where E: de::Error
{ {
type Deserializer = U32Deserializer<E>; type Deserializer = U32Deserializer<E>;
@ -209,7 +209,7 @@ impl<E> ValueDeserializer<E> for u32
} }
impl<E> de::Deserializer for U32Deserializer<E> impl<E> de::Deserializer for U32Deserializer<E>
where E: de::Error, where E: de::Error
{ {
type Error = E; type Error = E;
@ -220,7 +220,7 @@ impl<E> de::Deserializer for U32Deserializer<E>
} }
fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error> fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor, where V: de::Visitor
{ {
visitor.visit_u32(self.value) visitor.visit_u32(self.value)
} }

74
serde/src/ser/content.rs
View File

@ -33,10 +33,7 @@ impl<M> ser::SerializeTupleVariant for SerializeTupleVariantAsMapValue<M>
type Ok = M::Ok; type Ok = M::Ok;
type Error = M::Error; type Error = M::Error;
fn serialize_field<T: ?Sized + Serialize>(&mut self, fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), M::Error> {
value: &T)
-> Result<(), M::Error>
{
let value = try!(value.serialize(ContentSerializer::<M::Error>::new())); let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push(value); self.fields.push(value);
Ok(()) Ok(())
@ -73,8 +70,7 @@ impl<M> ser::SerializeStructVariant for SerializeStructVariantAsMapValue<M>
fn serialize_field<T: ?Sized + Serialize>(&mut self, fn serialize_field<T: ?Sized + Serialize>(&mut self,
key: &'static str, key: &'static str,
value: &T) value: &T)
-> Result<(), M::Error> -> Result<(), M::Error> {
{
let value = try!(value.serialize(ContentSerializer::<M::Error>::new())); let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value)); self.fields.push((key, value));
Ok(()) Ok(())
@ -151,7 +147,9 @@ impl Serialize for Content {
Content::UnitStruct(n) => serializer.serialize_unit_struct(n), Content::UnitStruct(n) => serializer.serialize_unit_struct(n),
Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v), Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v),
Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c), Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c),
Content::NewtypeVariant(n, i, v, ref c) => serializer.serialize_newtype_variant(n, i, v, &**c), Content::NewtypeVariant(n, i, v, ref c) => {
serializer.serialize_newtype_variant(n, i, v, &**c)
}
Content::Seq(ref elements) => elements.serialize(serializer), Content::Seq(ref elements) => elements.serialize(serializer),
Content::SeqFixedSize(ref elements) => { Content::SeqFixedSize(ref elements) => {
use ser::SerializeSeq; use ser::SerializeSeq;
@ -219,9 +217,7 @@ struct ContentSerializer<E> {
impl<E> ContentSerializer<E> { impl<E> ContentSerializer<E> {
fn new() -> Self { fn new() -> Self {
ContentSerializer { ContentSerializer { error: PhantomData }
error: PhantomData,
}
} }
} }
@ -299,9 +295,7 @@ impl<E> Serializer for ContentSerializer<E>
Ok(Content::None) Ok(Content::None)
} }
fn serialize_some<T: ?Sized + Serialize>(self, fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Content, E> {
value: &T)
-> Result<Content, E> {
Ok(Content::Some(Box::new(try!(value.serialize(self))))) Ok(Content::Some(Box::new(try!(value.serialize(self)))))
} }
@ -309,9 +303,7 @@ impl<E> Serializer for ContentSerializer<E>
Ok(Content::Unit) Ok(Content::Unit)
} }
fn serialize_unit_struct(self, fn serialize_unit_struct(self, name: &'static str) -> Result<Content, E> {
name: &'static str)
-> Result<Content, E> {
Ok(Content::UnitStruct(name)) Ok(Content::UnitStruct(name))
} }
@ -336,12 +328,13 @@ impl<E> Serializer for ContentSerializer<E>
variant: &'static str, variant: &'static str,
value: &T) value: &T)
-> Result<Content, E> { -> Result<Content, E> {
Ok(Content::NewtypeVariant(name, variant_index, variant, Box::new(try!(value.serialize(self))))) Ok(Content::NewtypeVariant(name,
variant_index,
variant,
Box::new(try!(value.serialize(self)))))
} }
fn serialize_seq(self, fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> {
len: Option<usize>)
-> Result<Self::SerializeSeq, E> {
Ok(SerializeSeq { Ok(SerializeSeq {
fixed_size: false, fixed_size: false,
elements: Vec::with_capacity(len.unwrap_or(0)), elements: Vec::with_capacity(len.unwrap_or(0)),
@ -349,9 +342,7 @@ impl<E> Serializer for ContentSerializer<E>
}) })
} }
fn serialize_seq_fixed_size(self, fn serialize_seq_fixed_size(self, size: usize) -> Result<Self::SerializeSeq, E> {
size: usize)
-> Result<Self::SerializeSeq, E> {
Ok(SerializeSeq { Ok(SerializeSeq {
fixed_size: true, fixed_size: true,
elements: Vec::with_capacity(size), elements: Vec::with_capacity(size),
@ -359,9 +350,7 @@ impl<E> Serializer for ContentSerializer<E>
}) })
} }
fn serialize_tuple(self, fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
len: usize)
-> Result<Self::SerializeTuple, E> {
Ok(SerializeTuple { Ok(SerializeTuple {
elements: Vec::with_capacity(len), elements: Vec::with_capacity(len),
error: PhantomData, error: PhantomData,
@ -394,9 +383,7 @@ impl<E> Serializer for ContentSerializer<E>
}) })
} }
fn serialize_map(self, fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> {
len: Option<usize>)
-> Result<Self::SerializeMap, E> {
Ok(SerializeMap { Ok(SerializeMap {
entries: Vec::with_capacity(len.unwrap_or(0)), entries: Vec::with_capacity(len.unwrap_or(0)),
key: None, key: None,
@ -404,10 +391,7 @@ impl<E> Serializer for ContentSerializer<E>
}) })
} }
fn serialize_struct(self, fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct, E> {
name: &'static str,
len: usize)
-> Result<Self::SerializeStruct, E> {
Ok(SerializeStruct { Ok(SerializeStruct {
name: name, name: name,
fields: Vec::with_capacity(len), fields: Vec::with_capacity(len),
@ -443,9 +427,7 @@ impl<E> ser::SerializeSeq for SerializeSeq<E>
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_element<T: ?Sized + Serialize>(&mut self, fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
value: &T)
-> Result<(), E> {
let value = try!(value.serialize(ContentSerializer::<E>::new())); let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value); self.elements.push(value);
Ok(()) Ok(())
@ -471,9 +453,7 @@ impl<E> ser::SerializeTuple for SerializeTuple<E>
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_element<T: ?Sized + Serialize>(&mut self, fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
value: &T)
-> Result<(), E> {
let value = try!(value.serialize(ContentSerializer::<E>::new())); let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value); self.elements.push(value);
Ok(()) Ok(())
@ -496,9 +476,7 @@ impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E>
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self, fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
value: &T)
-> Result<(), E> {
let value = try!(value.serialize(ContentSerializer::<E>::new())); let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value); self.fields.push(value);
Ok(()) Ok(())
@ -523,9 +501,7 @@ impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E>
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_field<T: ?Sized + Serialize>(&mut self, fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
value: &T)
-> Result<(), E> {
let value = try!(value.serialize(ContentSerializer::<E>::new())); let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value); self.fields.push(value);
Ok(()) Ok(())
@ -548,17 +524,13 @@ impl<E> ser::SerializeMap for SerializeMap<E>
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_key<T: ?Sized + Serialize>(&mut self, fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), E> {
key: &T)
-> Result<(), E> {
let key = try!(key.serialize(ContentSerializer::<E>::new())); let key = try!(key.serialize(ContentSerializer::<E>::new()));
self.key = Some(key); self.key = Some(key);
Ok(()) Ok(())
} }
fn serialize_value<T: ?Sized + Serialize>(&mut self, fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), E> {
value: &T)
-> Result<(), E> {
let key = self.key.take().expect("serialize_value called before serialize_key"); let key = self.key.take().expect("serialize_value called before serialize_key");
let value = try!(value.serialize(ContentSerializer::<E>::new())); let value = try!(value.serialize(ContentSerializer::<E>::new()));
self.entries.push((key, value)); self.entries.push((key, value));

4
serde/src/ser/mod.rs
View File

@ -646,7 +646,7 @@ pub trait Serializer: Sized {
/// ``` /// ```
#[cfg(any(feature = "std", feature = "collections"))] #[cfg(any(feature = "std", feature = "collections"))]
fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
where T: Display, where T: Display
{ {
let mut string = String::new(); let mut string = String::new();
write!(string, "{}", value).unwrap(); write!(string, "{}", value).unwrap();
@ -677,7 +677,7 @@ pub trait Serializer: Sized {
/// ``` /// ```
#[cfg(not(any(feature = "std", feature = "collections")))] #[cfg(not(any(feature = "std", feature = "collections")))]
fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
where T: Display, where T: Display
{ {
// TODO https://github.com/serde-rs/serde/issues/805 // TODO https://github.com/serde-rs/serde/issues/805
// Remove this impl and force no_std formats to implement collect_str. // Remove this impl and force no_std formats to implement collect_str.

4
serde/src/ser/private.rs
View File

@ -81,7 +81,9 @@ impl Display for Error {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, write!(formatter,
"cannot serialize tagged newtype variant {}::{} containing {}", "cannot serialize tagged newtype variant {}::{} containing {}",
self.type_ident, self.variant_ident, self.ty) self.type_ident,
self.variant_ident,
self.ty)
} }
} }