From 8e5cf19e0740afabf8f8254441e88c756240fcb1 Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Fri, 27 Jan 2017 22:56:04 +0100 Subject: Reformat with rustfmt --- src/de.rs | 38 +++++----- src/ser/key.rs | 166 ++++++++++++++++++++++-------------------- src/ser/mod.rs | 218 ++++++++++++++++++++++++++++--------------------------- src/ser/pair.rs | 202 +++++++++++++++++++++++++-------------------------- src/ser/value.rs | 183 +++++++++++++++++++++++----------------------- 5 files changed, 411 insertions(+), 396 deletions(-) (limited to 'src') diff --git a/src/de.rs b/src/de.rs index 0f3cb78..42c1f04 100644 --- a/src/de.rs +++ b/src/de.rs @@ -1,13 +1,13 @@ //! Deserialization support for the `application/x-www-form-urlencoded` format. use serde::de; + +pub use serde::de::value::Error; use serde::de::value::MapDeserializer; use std::borrow::Cow; use url::form_urlencoded::Parse as UrlEncodedParse; use url::form_urlencoded::parse; -pub use serde::de::value::Error; - /// Deserializes a `application/x-wwww-url-encoded` value from a `&[u8]`. /// /// ``` @@ -56,8 +56,10 @@ pub fn from_str(input: &str) -> Result { /// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size` /// defers to `deserialize`. pub struct Deserializer<'a> { - inner: - MapDeserializer, Cow<'a, str>, Cow<'a, str>, Error>, + inner: MapDeserializer, + Cow<'a, str>, + Cow<'a, str>, + Error>, } impl<'a> Deserializer<'a> { @@ -67,38 +69,36 @@ impl<'a> Deserializer<'a> { } } -impl<'a> de::Deserializer for Deserializer<'a> -{ +impl<'a> de::Deserializer for Deserializer<'a> { type Error = Error; - fn deserialize( - &mut self, visitor: V) - -> Result + fn deserialize(&mut self, visitor: V) -> Result where V: de::Visitor, { self.deserialize_map(visitor) } - fn deserialize_map( - &mut self, mut visitor: V) - -> Result + fn deserialize_map(&mut self, + mut visitor: V) + -> Result where V: de::Visitor, { visitor.visit_map(&mut self.inner) } - fn deserialize_seq( - &mut self, mut visitor: V) - -> Result + fn deserialize_seq(&mut self, + mut visitor: V) + -> Result where V: de::Visitor, { visitor.visit_seq(&mut self.inner) } - fn deserialize_seq_fixed_size( - &mut self, _len: usize, mut visitor: V) - -> Result - where V: de::Visitor + fn deserialize_seq_fixed_size(&mut self, + _len: usize, + mut visitor: V) + -> Result + where V: de::Visitor, { visitor.visit_seq(&mut self.inner) } diff --git a/src/ser/key.rs b/src/ser/key.rs index a26c563..0e5f7a6 100644 --- a/src/ser/key.rs +++ b/src/ser/key.rs @@ -1,5 +1,6 @@ -use serde::{Serialize, Serializer}; + use ser::Error; +use serde::{Serialize, Serializer}; use std::borrow::Cow; use std::str; @@ -11,7 +12,7 @@ impl<'key> MapKeySerializer<'key> { } fn set_key(&mut self, key: T) -> Result<(), Error> - where T: Into> + where T: Into>, { *self.0 = Some(key.into()); Ok(()) @@ -99,37 +100,36 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_unit_struct( - &mut self, name: &'static str) - -> Result<(), Error> { + fn serialize_unit_struct(&mut self, + name: &'static str) + -> Result<(), Error> { self.set_key(name) } - fn serialize_unit_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str) - -> Result<(), Error> { + fn serialize_unit_variant(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str) + -> Result<(), Error> { self.set_key(variant) } - fn serialize_newtype_struct( - &mut self, _name: &'static str, value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_newtype_struct(&mut self, + _name: &'static str, + value: T) + -> Result<(), Error> + where T: Serialize, { value.serialize(self) } - fn serialize_newtype_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_newtype_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -139,7 +139,7 @@ impl<'key> Serializer for MapKeySerializer<'key> { } fn serialize_some(&mut self, _value: T) -> Result<(), Error> - where T: Serialize + where T: Serialize, { Err(Error::unsupported_key()) } @@ -148,10 +148,11 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_seq_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_seq_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -168,10 +169,11 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_tuple_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -180,16 +182,18 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_tuple_struct( - &mut self, _name: &'static str, _len: usize) - -> Result<(), Error> { + fn serialize_tuple_struct(&mut self, + _name: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_key()) } - fn serialize_tuple_struct_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_struct_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -198,20 +202,20 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_tuple_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { + fn serialize_tuple_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_key()) } - fn serialize_tuple_variant_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_variant_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -224,18 +228,20 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_map_key( - &mut self, _state: &mut (), _key: T) - -> Result<(), Error> - where T: Serialize + fn serialize_map_key(&mut self, + _state: &mut (), + _key: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } - fn serialize_map_value( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_map_value(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -244,16 +250,19 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_struct( - &mut self, _name: &'static str, _len: usize) - -> Result<(), Error> { + fn serialize_struct(&mut self, + _name: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_key()) } - fn serialize_struct_elt( - &mut self, _state: &mut (), _key: &'static str, _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_struct_elt(&mut self, + _state: &mut (), + _key: &'static str, + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_key()) } @@ -262,25 +271,26 @@ impl<'key> Serializer for MapKeySerializer<'key> { Err(Error::unsupported_key()) } - fn serialize_struct_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { + fn serialize_struct_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_key()) } - fn serialize_struct_variant_elt( - &mut self, _state: &mut (), _key: &'static str, _value: T) - -> Result<(), Error> { + fn serialize_struct_variant_elt(&mut self, + _state: &mut (), + _key: &'static str, + _value: T) + -> Result<(), Error> { Err(Error::unsupported_key()) } - fn serialize_struct_variant_end( - &mut self, _state: ()) - -> Result<(), Error> { + fn serialize_struct_variant_end(&mut self, + _state: ()) + -> Result<(), Error> { Err(Error::unsupported_key()) } } diff --git a/src/ser/mod.rs b/src/ser/mod.rs index f04c956..00c0540 100644 --- a/src/ser/mod.rs +++ b/src/ser/mod.rs @@ -30,7 +30,7 @@ pub fn to_string(input: &T) -> Result { let mut output = String::new(); { let mut urlencoder = UrlEncodedSerializer::new(&mut output); - try!(input.serialize(&mut Serializer::new(&mut urlencoder))); + input.serialize(&mut Serializer::new(&mut urlencoder))?; } Ok(output) } @@ -45,7 +45,7 @@ pub fn to_string(input: &T) -> Result { /// /// * Newtype structs defer to their inner values. pub struct Serializer<'output, T: 'output + UrlEncodedTarget> { - urlencoder: &'output mut UrlEncodedSerializer + urlencoder: &'output mut UrlEncodedSerializer, } impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> { @@ -85,7 +85,8 @@ impl error::Error for Error { /// The lower-level cause of this error, in the case of a `Utf8` error. fn cause(&self) -> Option<&error::Error> { match *self { - Error::Custom(_) | Error::InvalidValue(_) => None, + Error::Custom(_) | + Error::InvalidValue(_) => None, Error::Utf8(ref err) => Some(err), } } @@ -123,7 +124,7 @@ pub struct TupleVariantState { /// State used when serializing maps. pub struct MapState { - key: Option> + key: Option>, } /// State used when serializing structs. @@ -137,7 +138,7 @@ pub struct StructVariantState { } impl<'output, Target> ser::Serializer for Serializer<'output, Target> - where Target: 'output + UrlEncodedTarget + where Target: 'output + UrlEncodedTarget, { type Error = Error; @@ -248,40 +249,39 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> } /// Returns an error. - fn serialize_unit_struct( - &mut self, _name: &'static str) - -> Result<(), Error> { + fn serialize_unit_struct(&mut self, + _name: &'static str) + -> Result<(), Error> { Err(Error::top_level()) } /// Returns an error. - fn serialize_unit_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str) - -> Result<(), Error> { + fn serialize_unit_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str) + -> Result<(), Error> { Err(Error::top_level()) } /// Serializes the inner value, ignoring the newtype name. - fn serialize_newtype_struct( - &mut self, _name: &'static str, value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_newtype_struct(&mut self, + _name: &'static str, + value: T) + -> Result<(), Error> + where T: ser::Serialize, { value.serialize(self) } /// Returns an error. - fn serialize_newtype_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_newtype_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: T) + -> Result<(), Error> + where T: ser::Serialize, { Err(Error::top_level()) } @@ -293,23 +293,24 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> /// Returns an error. fn serialize_some(&mut self, value: T) -> Result<(), Error> - where T: ser::Serialize + where T: ser::Serialize, { value.serialize(self) } /// Begins to serialize a sequence, given length (if any) is ignored. - fn serialize_seq( - &mut self, _len: Option) - -> Result { + fn serialize_seq(&mut self, + _len: Option) + -> Result { Ok(SeqState { _state: () }) } /// Serializes a sequence element. - fn serialize_seq_elt( - &mut self, _state: &mut SeqState, value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_seq_elt(&mut self, + _state: &mut SeqState, + value: T) + -> Result<(), Error> + where T: ser::Serialize, { value.serialize(&mut pair::PairSerializer::new(self.urlencoder)) } @@ -320,9 +321,9 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> } /// Begins to serialize a sequence, given length is ignored. - fn serialize_seq_fixed_size( - &mut self, _length: usize) - -> Result { + fn serialize_seq_fixed_size(&mut self, + _length: usize) + -> Result { Ok(SeqState { _state: () }) } @@ -332,10 +333,11 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> } /// Returns an error. - fn serialize_tuple_elt( - &mut self, _state: &mut TupleState, _value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_tuple_elt(&mut self, + _state: &mut TupleState, + _value: T) + -> Result<(), Error> + where T: ser::Serialize, { Err(Error::top_level()) } @@ -346,80 +348,83 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> } /// Returns an error. - fn serialize_tuple_struct( - &mut self, _name: &'static str, _len: usize) - -> Result { + fn serialize_tuple_struct(&mut self, + _name: &'static str, + _len: usize) + -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_struct_elt( - &mut self, _state: &mut TupleStructState, _value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_tuple_struct_elt(&mut self, + _state: &mut TupleStructState, + _value: T) + -> Result<(), Error> + where T: ser::Serialize, { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_struct_end( - &mut self, _state: TupleStructState) - -> Result<(), Error> - { + fn serialize_tuple_struct_end(&mut self, + _state: TupleStructState) + -> Result<(), Error> { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result { + fn serialize_tuple_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_variant_elt( - &mut self, _state: &mut TupleVariantState, _value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_tuple_variant_elt(&mut self, + _state: &mut TupleVariantState, + _value: T) + -> Result<(), Error> + where T: ser::Serialize, { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_variant_end( - &mut self, _state: TupleVariantState) - -> Result<(), Error> { + fn serialize_tuple_variant_end(&mut self, + _state: TupleVariantState) + -> Result<(), Error> { Err(Error::top_level()) } /// Begins to serialize a map, given length (if any) is ignored. - fn serialize_map( - &mut self, _len: Option) - -> Result { + fn serialize_map(&mut self, + _len: Option) + -> Result { Ok(MapState { key: None }) } /// Serializes a map key. - fn serialize_map_key( - &mut self, state: &mut MapState, key: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_map_key(&mut self, + state: &mut MapState, + key: T) + -> Result<(), Error> + where T: ser::Serialize, { key.serialize(&mut key::MapKeySerializer::new(&mut state.key)) } /// Serializes a map value. - fn serialize_map_value( - &mut self, state: &mut MapState, value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_map_value(&mut self, + state: &mut MapState, + value: T) + -> Result<(), Error> + where T: ser::Serialize, { let mut value_serializer = - try!(value::ValueSerializer::new(&mut state.key, self.urlencoder)); + value::ValueSerializer::new(&mut state.key, self.urlencoder)?; value.serialize(&mut value_serializer) } @@ -429,20 +434,20 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> } /// Begins to serialize a struct, given length is ignored. - fn serialize_struct( - &mut self, _name: &'static str, _len: usize) - -> Result { + fn serialize_struct(&mut self, + _name: &'static str, + _len: usize) + -> Result { Ok(StructState { _state: () }) } /// Serializes a struct element. - fn serialize_struct_elt( - &mut self, - _state: &mut StructState, - key: &'static str, - value: T) - -> Result<(), Error> - where T: ser::Serialize + fn serialize_struct_elt(&mut self, + _state: &mut StructState, + key: &'static str, + value: T) + -> Result<(), Error> + where T: ser::Serialize, { let mut key = Some(key.into()); let mut value_serializer = @@ -451,43 +456,42 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target> } /// Finishes serializing a struct. - fn serialize_struct_end(&mut self, _state: StructState) + fn serialize_struct_end(&mut self, + _state: StructState) -> Result<(), Error> { Ok(()) } /// Returns an error. - fn serialize_struct_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result { + fn serialize_struct_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_struct_variant_elt( - &mut self, - _state: &mut StructVariantState, - _key: &'static str, - _value: T) - -> Result<(), Error> { + fn serialize_struct_variant_elt(&mut self, + _state: &mut StructVariantState, + _key: &'static str, + _value: T) + -> Result<(), Error> { Err(Error::top_level()) } /// Returns an error. - fn serialize_struct_variant_end( - &mut self, _state: StructVariantState) - -> Result<(), Error> { + fn serialize_struct_variant_end(&mut self, + _state: StructVariantState) + -> Result<(), Error> { Err(Error::top_level()) } } impl Error { fn top_level() -> Self { - Error::Custom( - "top-level serializer supports only maps and structs".into()) + Error::Custom("top-level serializer supports only maps and structs" + .into()) } } diff --git a/src/ser/pair.rs b/src/ser/pair.rs index 6dfed3d..36eda51 100644 --- a/src/ser/pair.rs +++ b/src/ser/pair.rs @@ -8,11 +8,10 @@ pub struct PairSerializer<'target, Target>( where Target: 'target + form_urlencoded::Target; impl<'target, Target> PairSerializer<'target, Target> - where Target: 'target + form_urlencoded::Target + where Target: 'target + form_urlencoded::Target, { - pub fn new( - serializer: &'target mut form_urlencoded::Serializer) - -> Self { + pub fn new(serializer: &'target mut form_urlencoded::Serializer) + -> Self { PairSerializer(serializer) } } @@ -21,7 +20,7 @@ pub struct TupleState(Option>>); pub struct TupleStructState(TupleState); impl<'target, Target> Serializer for PairSerializer<'target, Target> - where Target: 'target + form_urlencoded::Target + where Target: 'target + form_urlencoded::Target, { type Error = Error; type SeqState = (); @@ -100,37 +99,36 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> Err(Error::unsupported_pair()) } - fn serialize_unit_struct( - &mut self, _name: &'static str) - -> Result<(), Error> { + fn serialize_unit_struct(&mut self, + _name: &'static str) + -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_unit_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str) - -> Result<(), Error> { + fn serialize_unit_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str) + -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_newtype_struct( - &mut self, _name: &'static str, value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_newtype_struct(&mut self, + _name: &'static str, + value: T) + -> Result<(), Error> + where T: Serialize, { value.serialize(self) } - fn serialize_newtype_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_newtype_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_pair()) } @@ -140,19 +138,20 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> } fn serialize_some(&mut self, value: T) -> Result<(), Error> - where T: Serialize + where T: Serialize, { value.serialize(self) } - fn serialize_seq(&mut self, _len: Option) - -> Result<(), Error> { + fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_seq_elt(&mut self, _state: &mut (), _value: T) + fn serialize_seq_elt(&mut self, + _state: &mut (), + _value: T) -> Result<(), Error> - where T: Serialize + where T: Serialize, { Err(Error::unsupported_pair()) } @@ -161,8 +160,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> Err(Error::unsupported_pair()) } - fn serialize_seq_fixed_size(&mut self, _size: usize) - -> Result<(), Error> { + fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> { Err(Error::unsupported_pair()) } @@ -174,10 +172,11 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> } } - fn serialize_tuple_elt( - &mut self, state: &mut TupleState, value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_elt(&mut self, + state: &mut TupleState, + value: T) + -> Result<(), Error> + where T: Serialize, { match state.0.take() { None => { @@ -185,7 +184,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> { let mut key_serializer = key::MapKeySerializer::new(&mut key); - try!(value.serialize(&mut key_serializer)); + value.serialize(&mut key_serializer)?; } state.0 = Some(key); Ok(()) @@ -194,11 +193,11 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> { let mut value_serializer = value::ValueSerializer::new(key, &mut self.0).unwrap(); - try!(value.serialize(&mut value_serializer)); + value.serialize(&mut value_serializer)?; } state.0 = Some(None); Ok(()) - } + }, } } @@ -206,68 +205,68 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> Ok(()) } - fn serialize_tuple_struct( - &mut self, _name: &'static str, len: usize) - -> Result { + fn serialize_tuple_struct(&mut self, + _name: &'static str, + len: usize) + -> Result { self.serialize_tuple(len).map(TupleStructState) } - fn serialize_tuple_struct_elt( - &mut self, state: &mut TupleStructState, value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_struct_elt(&mut self, + state: &mut TupleStructState, + value: T) + -> Result<(), Error> + where T: Serialize, { self.serialize_tuple_elt(&mut state.0, value) } - fn serialize_tuple_struct_end( - &mut self, _state: TupleStructState) - -> Result<(), Error> { + fn serialize_tuple_struct_end(&mut self, + _state: TupleStructState) + -> Result<(), Error> { Ok(()) } - fn serialize_tuple_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { + fn serialize_tuple_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_tuple_variant_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_variant_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_pair()) } - fn serialize_tuple_variant_end( - &mut self, _state: ()) - -> Result<(), Error> { + fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_map( - &mut self, _len: Option) - -> Result<(), Error> { + fn serialize_map(&mut self, _len: Option) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_map_key( - &mut self, _state: &mut (), _key: T) - -> Result<(), Error> - where T: Serialize + fn serialize_map_key(&mut self, + _state: &mut (), + _key: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_pair()) } - fn serialize_map_value( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_map_value(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_pair()) } @@ -276,54 +275,51 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> Err(Error::unsupported_pair()) } - fn serialize_struct(&mut self, _name: &'static str, _len: usize) + fn serialize_struct(&mut self, + _name: &'static str, + _len: usize) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_struct_elt( - &mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_struct_elt(&mut self, + _state: &mut (), + _key: &'static str, + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_pair()) } - fn serialize_struct_end( - &mut self, _state: ()) - -> Result<(), Error> { + fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_struct_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { + fn serialize_struct_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_struct_variant_elt( - &mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> { + fn serialize_struct_variant_elt(&mut self, + _state: &mut (), + _key: &'static str, + _value: T) + -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_struct_variant_end( - &mut self, _state: ()) - -> Result<(), Error> { + fn serialize_struct_variant_end(&mut self, + _state: ()) + -> Result<(), Error> { Err(Error::unsupported_pair()) } } -impl Error { +impl Error { fn unsupported_pair() -> Self { Error::Custom("unsupported pair".into()) } diff --git a/src/ser/value.rs b/src/ser/value.rs index d017242..fcaf0f4 100644 --- a/src/ser/value.rs +++ b/src/ser/value.rs @@ -5,19 +5,18 @@ use std::str; use url::form_urlencoded; pub struct ValueSerializer<'key, 'target, Target> - where Target: 'target + form_urlencoded::Target + where Target: 'target + form_urlencoded::Target, { key: &'key mut Option>, - serializer: &'target mut form_urlencoded::Serializer + serializer: &'target mut form_urlencoded::Serializer, } impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target> - where Target: 'target + form_urlencoded::Target + where Target: 'target + form_urlencoded::Target, { - pub fn new( - key: &'key mut Option>, - serializer: &'target mut form_urlencoded::Serializer) - -> Result { + pub fn new(key: &'key mut Option>, + serializer: &'target mut form_urlencoded::Serializer) + -> Result { if key.is_some() { Ok(ValueSerializer { key: key, @@ -40,7 +39,7 @@ impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target> impl<'key, 'target, Target> Serializer for ValueSerializer<'key, 'target, Target> - where Target: 'target + form_urlencoded::Target + where Target: 'target + form_urlencoded::Target, { type Error = Error; type SeqState = (); @@ -122,37 +121,36 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_unit_struct( - &mut self, name: &'static str) - -> Result<(), Error> { + fn serialize_unit_struct(&mut self, + name: &'static str) + -> Result<(), Error> { self.append_pair(name) } - fn serialize_unit_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str) - -> Result<(), Error> { + fn serialize_unit_variant(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str) + -> Result<(), Error> { self.append_pair(variant) } - fn serialize_newtype_struct( - &mut self, _name: &'static str, value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_newtype_struct(&mut self, + _name: &'static str, + value: T) + -> Result<(), Error> + where T: Serialize, { value.serialize(self) } - fn serialize_newtype_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_newtype_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -166,7 +164,7 @@ impl<'key, 'target, Target> Serializer } fn serialize_some(&mut self, value: T) -> Result<(), Error> - where T: Serialize + where T: Serialize, { value.serialize(self) } @@ -175,10 +173,11 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_seq_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_seq_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -195,10 +194,11 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_tuple_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -207,16 +207,18 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_tuple_struct( - &mut self, _name: &'static str, _len: usize) - -> Result<(), Error> { + fn serialize_tuple_struct(&mut self, + _name: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_value()) } - fn serialize_tuple_struct_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_struct_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -225,20 +227,20 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_tuple_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { + fn serialize_tuple_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_value()) } - fn serialize_tuple_variant_elt( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_tuple_variant_elt(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -251,18 +253,20 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_map_key( - &mut self, _state: &mut (), _key: T) - -> Result<(), Error> - where T: Serialize + fn serialize_map_key(&mut self, + _state: &mut (), + _key: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } - fn serialize_map_value( - &mut self, _state: &mut (), _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_map_value(&mut self, + _state: &mut (), + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -271,19 +275,19 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_struct( - &mut self, _name: &'static str, _len: usize) - -> Result<(), Error> { + fn serialize_struct(&mut self, + _name: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_value()) } - fn serialize_struct_elt( - &mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize + fn serialize_struct_elt(&mut self, + _state: &mut (), + _key: &'static str, + _value: T) + -> Result<(), Error> + where T: Serialize, { Err(Error::unsupported_value()) } @@ -292,32 +296,33 @@ impl<'key, 'target, Target> Serializer Err(Error::unsupported_value()) } - fn serialize_struct_variant( - &mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { + fn serialize_struct_variant(&mut self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result<(), Error> { Err(Error::unsupported_value()) } - fn serialize_struct_variant_elt( - &mut self, _state: &mut (), _key: &'static str, _value: T) - -> Result<(), Error> { + fn serialize_struct_variant_elt(&mut self, + _state: &mut (), + _key: &'static str, + _value: T) + -> Result<(), Error> { Err(Error::unsupported_value()) } - fn serialize_struct_variant_end( - &mut self, _state: ()) - -> Result<(), Error> { + fn serialize_struct_variant_end(&mut self, + _state: ()) + -> Result<(), Error> { Err(Error::unsupported_value()) } } impl Error { fn no_key() -> Self { - Error::Custom( - "tried to serialize a value before serializing key".into()) + Error::Custom("tried to serialize a value before serializing key" + .into()) } fn unsupported_value() -> Self { -- cgit v1.2.3 From 9960d5af2d853613ea8a7d26cf2d000358d09226 Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sat, 28 Jan 2017 17:09:10 +0100 Subject: Update to serde 0.9.0 (fixes #7) --- Cargo.toml | 5 +- src/de.rs | 33 ++-- src/ser/key.rs | 322 ++++++--------------------------- src/ser/mod.rs | 539 ++++++++++++++++++++++++++++--------------------------- src/ser/pair.rs | 428 +++++++++++++++++++++++-------------------- src/ser/part.rs | 311 ++++++++++++++++++++++++++++++++ src/ser/value.rs | 338 ++++------------------------------ 7 files changed, 924 insertions(+), 1052 deletions(-) create mode 100644 src/ser/part.rs (limited to 'src') diff --git a/Cargo.toml b/Cargo.toml index 95845ca..b9c18f0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,9 @@ documentation = "https://docs.rs/serde_urlencoded" description = "`x-www-form-urlencoded` meets Serde" keywords = ["serde", "serialization", "urlencoded"] +[lib] +test = false + [dependencies] -serde = "0.8.7" +serde = "0.9.2" url = "1.0.0" diff --git a/src/de.rs b/src/de.rs index 42c1f04..95208e9 100644 --- a/src/de.rs +++ b/src/de.rs @@ -4,7 +4,6 @@ use serde::de; pub use serde::de::value::Error; use serde::de::value::MapDeserializer; -use std::borrow::Cow; use url::form_urlencoded::Parse as UrlEncodedParse; use url::form_urlencoded::parse; @@ -24,7 +23,7 @@ use url::form_urlencoded::parse; /// Ok(meal)); /// ``` pub fn from_bytes(input: &[u8]) -> Result { - T::deserialize(&mut Deserializer::new(parse(input))) + T::deserialize(Deserializer::new(parse(input))) } /// Deserializes a `application/x-wwww-url-encoded` value from a `&str`. @@ -56,61 +55,52 @@ pub fn from_str(input: &str) -> Result { /// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size` /// defers to `deserialize`. pub struct Deserializer<'a> { - inner: MapDeserializer, - Cow<'a, str>, - Cow<'a, str>, - Error>, + inner: MapDeserializer, Error>, } impl<'a> Deserializer<'a> { /// Returns a new `Deserializer`. pub fn new(parser: UrlEncodedParse<'a>) -> Self { - Deserializer { inner: MapDeserializer::unbounded(parser) } + Deserializer { inner: MapDeserializer::new(parser) } } } impl<'a> de::Deserializer for Deserializer<'a> { type Error = Error; - fn deserialize(&mut self, visitor: V) -> Result + fn deserialize(self, visitor: V) -> Result where V: de::Visitor, { self.deserialize_map(visitor) } - fn deserialize_map(&mut self, - mut visitor: V) - -> Result + fn deserialize_map(self, visitor: V) -> Result where V: de::Visitor, { - visitor.visit_map(&mut self.inner) + visitor.visit_map(self.inner) } - fn deserialize_seq(&mut self, - mut visitor: V) - -> Result + fn deserialize_seq(self, visitor: V) -> Result where V: de::Visitor, { - visitor.visit_seq(&mut self.inner) + visitor.visit_seq(self.inner) } - fn deserialize_seq_fixed_size(&mut self, + fn deserialize_seq_fixed_size(self, _len: usize, - mut visitor: V) + visitor: V) -> Result where V: de::Visitor, { - visitor.visit_seq(&mut self.inner) + visitor.visit_seq(self.inner) } forward_to_deserialize! { bool - usize u8 u16 u32 u64 - isize i8 i16 i32 @@ -123,6 +113,7 @@ impl<'a> de::Deserializer for Deserializer<'a> { unit option bytes + byte_buf unit_struct newtype_struct tuple_struct diff --git a/src/ser/key.rs b/src/ser/key.rs index 0e5f7a6..149c8f6 100644 --- a/src/ser/key.rs +++ b/src/ser/key.rs @@ -1,302 +1,80 @@ - use ser::Error; -use serde::{Serialize, Serializer}; +use ser::part::Sink; +use serde::Serialize; use std::borrow::Cow; -use std::str; - -pub struct MapKeySerializer<'key>(&'key mut Option>); - -impl<'key> MapKeySerializer<'key> { - pub fn new(output: &'key mut Option>) -> Self { - MapKeySerializer(output) - } +use std::ops::Deref; - fn set_key(&mut self, key: T) -> Result<(), Error> - where T: Into>, - { - *self.0 = Some(key.into()); - Ok(()) - } +pub enum Key<'key> { + Static(&'static str), + Dynamic(Cow<'key, str>), } -impl<'key> Serializer for MapKeySerializer<'key> { - type Error = Error; - type SeqState = (); - type TupleState = (); - type TupleStructState = (); - type TupleVariantState = (); - type MapState = (); - type StructState = (); - type StructVariantState = (); - - fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_isize(&mut self, v: isize) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_i8(&mut self, v: i8) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_i16(&mut self, v: i16) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_i32(&mut self, v: i32) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_i64(&mut self, v: i64) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_usize(&mut self, v: usize) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_u8(&mut self, v: u8) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_u16(&mut self, v: u16) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_u32(&mut self, v: u32) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_u64(&mut self, v: u64) -> Result<(), Error> { - self.set_key(v.to_string()) - } +impl<'key> Deref for Key<'key> { + type Target = str; - fn serialize_f32(&mut self, v: f32) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_f64(&mut self, v: f64) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_char(&mut self, v: char) -> Result<(), Error> { - self.set_key(v.to_string()) - } - - fn serialize_str(&mut self, value: &str) -> Result<(), Error> { - self.set_key(String::from(value)) - } - - fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Error> { - match str::from_utf8(value) { - Ok(value) => self.set_key(String::from(value)), - Err(err) => Err(Error::Utf8(err)), + fn deref(&self) -> &str { + match *self { + Key::Static(key) => key, + Key::Dynamic(ref key) => key, } } +} - fn serialize_unit(&mut self) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_unit_struct(&mut self, - name: &'static str) - -> Result<(), Error> { - self.set_key(name) - } - - fn serialize_unit_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str) - -> Result<(), Error> { - self.set_key(variant) - } - - fn serialize_newtype_struct(&mut self, - _name: &'static str, - value: T) - -> Result<(), Error> - where T: Serialize, - { - value.serialize(self) - } - - fn serialize_newtype_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } - - fn serialize_none(&mut self) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_some(&mut self, _value: T) -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } - - fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_seq_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } - - fn serialize_seq_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_struct_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_struct_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_variant_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } - - fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_key()) - } - - fn serialize_map(&mut self, _len: Option) -> Result<(), Error> { - Err(Error::unsupported_key()) +impl<'key> From> for Cow<'static, str> { + fn from(key: Key<'key>) -> Self { + match key { + Key::Static(key) => key.into(), + Key::Dynamic(key) => key.into_owned().into(), + } } +} - fn serialize_map_key(&mut self, - _state: &mut (), - _key: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) - } +pub struct KeySink { + end: End, +} - fn serialize_map_value(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) +impl KeySink + where End: for<'key> FnOnce(Key<'key>) -> Result +{ + pub fn new(end: End) -> Self { + KeySink { end: end } } +} - fn serialize_map_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_key()) - } +impl Sink for KeySink + where End: for<'key> FnOnce(Key<'key>) -> Result +{ + type Ok = Ok; - fn serialize_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_key()) + fn serialize_bool(self, _value: bool) -> Result { + Err(self.unsupported()) } - fn serialize_struct_elt(&mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_key()) + fn serialize_static_str(self, + value: &'static str) + -> Result { + (self.end)(Key::Static(value)) } - fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_key()) + fn serialize_str(self, value: &str) -> Result { + (self.end)(Key::Dynamic(value.into())) } - fn serialize_struct_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_key()) + fn serialize_string(self, value: String) -> Result { + (self.end)(Key::Dynamic(value.into())) } - fn serialize_struct_variant_elt(&mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> { - Err(Error::unsupported_key()) + fn serialize_none(self) -> Result { + Err(self.unsupported()) } - fn serialize_struct_variant_end(&mut self, - _state: ()) - -> Result<(), Error> { - Err(Error::unsupported_key()) + fn serialize_some(self, + _value: &T) + -> Result { + Err(self.unsupported()) } -} -impl Error { - fn unsupported_key() -> Self { + fn unsupported(self) -> Error { Error::Custom("unsupported key".into()) } } diff --git a/src/ser/mod.rs b/src/ser/mod.rs index 00c0540..400846f 100644 --- a/src/ser/mod.rs +++ b/src/ser/mod.rs @@ -2,12 +2,14 @@ mod key; mod pair; +mod part; mod value; use serde::ser; use std::borrow::Cow; use std::error; use std::fmt; +use std::marker::PhantomData; use std::str; use url::form_urlencoded::Serializer as UrlEncodedSerializer; use url::form_urlencoded::Target as UrlEncodedTarget; @@ -27,12 +29,9 @@ use url::form_urlencoded::Target as UrlEncodedTarget; /// Ok("bread=baguette&cheese=comt%C3%A9&meat=ham&fat=butter".to_owned())); /// ``` pub fn to_string(input: &T) -> Result { - let mut output = String::new(); - { - let mut urlencoder = UrlEncodedSerializer::new(&mut output); - input.serialize(&mut Serializer::new(&mut urlencoder))?; - } - Ok(output) + let mut urlencoder = UrlEncodedSerializer::new("".to_owned()); + input.serialize(Serializer::new(&mut urlencoder))?; + Ok(urlencoder.finish()) } /// A serializer for the `application/x-www-form-urlencoded` format. @@ -44,13 +43,13 @@ pub fn to_string(input: &T) -> Result { /// unit structs and unit variants. /// /// * Newtype structs defer to their inner values. -pub struct Serializer<'output, T: 'output + UrlEncodedTarget> { - urlencoder: &'output mut UrlEncodedSerializer, +pub struct Serializer<'output, Target: 'output + UrlEncodedTarget> { + urlencoder: &'output mut UrlEncodedSerializer, } -impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> { +impl<'output, Target: 'output + UrlEncodedTarget> Serializer<'output, Target> { /// Returns a new `Serializer`. - pub fn new(urlencoder: &'output mut UrlEncodedSerializer) -> Self { + pub fn new(urlencoder: &'output mut UrlEncodedSerializer) -> Self { Serializer { urlencoder: urlencoder } } } @@ -59,15 +58,13 @@ impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T> { #[derive(Clone, Debug, PartialEq, Eq)] pub enum Error { Custom(Cow<'static, str>), - InvalidValue(Cow<'static, str>), Utf8(str::Utf8Error), } impl fmt::Display for Error { - fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Error::Custom(ref msg) => msg.fmt(f), - Error::InvalidValue(ref msg) => write!(f, "invalid value: {}", msg), Error::Utf8(ref err) => write!(f, "invalid UTF-8: {}", err), } } @@ -77,7 +74,6 @@ impl error::Error for Error { fn description(&self) -> &str { match *self { Error::Custom(ref msg) => msg, - Error::InvalidValue(ref msg) => msg, Error::Utf8(ref err) => error::Error::description(err), } } @@ -85,413 +81,432 @@ impl error::Error for Error { /// The lower-level cause of this error, in the case of a `Utf8` error. fn cause(&self) -> Option<&error::Error> { match *self { - Error::Custom(_) | - Error::InvalidValue(_) => None, + Error::Custom(_) => None, Error::Utf8(ref err) => Some(err), } } } impl ser::Error for Error { - fn custom>(msg: T) -> Self { - Error::Custom(msg.into().into()) - } - - fn invalid_value(msg: &str) -> Self { - Error::InvalidValue(String::from(msg).into()) + fn custom(msg: T) -> Self { + Error::Custom(format!("{}", msg).into()) } } -/// State used when serializing sequences. -pub struct SeqState { - _state: (), +/// Sequence serializer. +pub struct SeqSerializer<'output, Target: 'output + UrlEncodedTarget> { + urlencoder: &'output mut UrlEncodedSerializer, } -/// State used when serializing tuples. -pub struct TupleState { - _state: (), +/// Tuple serializer. +/// +/// Never instantiated, tuples are not supported at top-level. +pub struct TupleSerializer<'output, T: 'output + UrlEncodedTarget> { + _marker: PhantomData<&'output T>, } -/// State used when serializing tuple structs. -pub struct TupleStructState { - _state: (), +/// Tuple struct serializer. +/// +/// Never instantiated, tuple structs are not supported. +pub struct TupleStructSerializer<'output, T: 'output + UrlEncodedTarget> { + _marker: PhantomData<&'output T>, } -/// State used when serializing tuple variants. -pub struct TupleVariantState { - _state: (), +/// Tuple variant serializer. +/// +/// Never instantiated, tuple variants are not supported. +pub struct TupleVariantSerializer<'output, T: 'output + UrlEncodedTarget> { + _marker: PhantomData<&'output T>, } -/// State used when serializing maps. -pub struct MapState { +/// Map serializer. +pub struct MapSerializer<'output, Target: 'output + UrlEncodedTarget> { + urlencoder: &'output mut UrlEncodedSerializer, key: Option>, } -/// State used when serializing structs. -pub struct StructState { - _state: (), +/// Struct serializer. +pub struct StructSerializer<'output, Target: 'output + UrlEncodedTarget> { + urlencoder: &'output mut UrlEncodedSerializer, } -/// State used when serializing struct variants. -pub struct StructVariantState { - _state: (), +/// Struct variant serializer. +/// +/// Never instantiated, struct variants are not supported. +pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> { + _marker: PhantomData<&'output T>, } impl<'output, Target> ser::Serializer for Serializer<'output, Target> where Target: 'output + UrlEncodedTarget, { + type Ok = &'output mut UrlEncodedSerializer; type Error = Error; - - /// State used when serializing sequences. - type SeqState = SeqState; - - /// State used when serializing tuples. - type TupleState = TupleState; - - /// State used when serializing tuple structs. - type TupleStructState = TupleStructState; - - /// State used when serializing tuple variants. - type TupleVariantState = TupleVariantState; - - /// State used when serializing maps. - type MapState = MapState; - - /// State used when serializing structs. - type StructState = StructState; - - /// State used when serializing struct variants. - type StructVariantState = StructVariantState; + type SerializeSeq = SeqSerializer<'output, Target>; + type SerializeTuple = TupleSerializer<'output, Target>; + type SerializeTupleStruct = TupleStructSerializer<'output, Target>; + type SerializeTupleVariant = TupleVariantSerializer<'output, Target>; + type SerializeMap = MapSerializer<'output, Target>; + type SerializeStruct = StructSerializer<'output, Target>; + type SerializeStructVariant = StructVariantSerializer<'output, Target>; /// Returns an error. - fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> { + fn serialize_bool(self, _v: bool) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> { + fn serialize_i8(self, _v: i8) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> { + fn serialize_i16(self, _v: i16) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> { + fn serialize_i32(self, _v: i32) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> { + fn serialize_i64(self, _v: i64) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> { + fn serialize_u8(self, _v: u8) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> { + fn serialize_u16(self, _v: u16) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> { + fn serialize_u32(self, _v: u32) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> { + fn serialize_u64(self, _v: u64) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> { + fn serialize_f32(self, _v: f32) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> { + fn serialize_f64(self, _v: f64) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> { + fn serialize_char(self, _v: char) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> { + fn serialize_str(self, _value: &str) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_char(&mut self, _v: char) -> Result<(), Error> { + fn serialize_bytes(self, _value: &[u8]) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_str(&mut self, _value: &str) -> Result<(), Error> { + fn serialize_unit(self) -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Error> { - Err(Error::top_level()) - } - - /// Returns an error. - fn serialize_unit(&mut self) -> Result<(), Error> { - Err(Error::top_level()) - } - - /// Returns an error. - fn serialize_unit_struct(&mut self, + fn serialize_unit_struct(self, _name: &'static str) - -> Result<(), Error> { + -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_unit_variant(&mut self, + fn serialize_unit_variant(self, _name: &'static str, _variant_index: usize, _variant: &'static str) - -> Result<(), Error> { + -> Result { Err(Error::top_level()) } /// Serializes the inner value, ignoring the newtype name. - fn serialize_newtype_struct(&mut self, - _name: &'static str, - value: T) - -> Result<(), Error> - where T: ser::Serialize, - { + fn serialize_newtype_struct + (self, + _name: &'static str, + value: &T) + -> Result { value.serialize(self) } /// Returns an error. - fn serialize_newtype_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: ser::Serialize, - { + fn serialize_newtype_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: &T) + -> Result { Err(Error::top_level()) } - /// Returns an error. - fn serialize_none(&mut self) -> Result<(), Error> { - Ok(()) + /// Returns `Ok`. + fn serialize_none(self) -> Result { + Ok(self.urlencoder) } - /// Returns an error. - fn serialize_some(&mut self, value: T) -> Result<(), Error> - where T: ser::Serialize, - { + /// Serializes the given value. + fn serialize_some + (self, + value: &T) + -> Result { value.serialize(self) } - /// Begins to serialize a sequence, given length (if any) is ignored. - fn serialize_seq(&mut self, + /// Serialize a sequence, given length (if any) is ignored. + fn serialize_seq(self, _len: Option) - -> Result { - Ok(SeqState { _state: () }) + -> Result { + Ok(SeqSerializer { urlencoder: self.urlencoder }) } - /// Serializes a sequence element. - fn serialize_seq_elt(&mut self, - _state: &mut SeqState, - value: T) - -> Result<(), Error> - where T: ser::Serialize, - { - value.serialize(&mut pair::PairSerializer::new(self.urlencoder)) - } - - /// Finishes serializing a sequence. - fn serialize_seq_end(&mut self, _state: SeqState) -> Result<(), Error> { - Ok(()) - } - - /// Begins to serialize a sequence, given length is ignored. - fn serialize_seq_fixed_size(&mut self, - _length: usize) - -> Result { - Ok(SeqState { _state: () }) + /// Serializes a sequence, given length is ignored. + fn serialize_seq_fixed_size(self, + _len: usize) + -> Result { + Ok(SeqSerializer { urlencoder: self.urlencoder }) } /// Returns an error. - fn serialize_tuple(&mut self, _len: usize) -> Result { + fn serialize_tuple(self, + _len: usize) + -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_elt(&mut self, - _state: &mut TupleState, - _value: T) - -> Result<(), Error> - where T: ser::Serialize, - { + fn serialize_tuple_struct(self, + _name: &'static str, + _len: usize) + -> Result { Err(Error::top_level()) } /// Returns an error. - fn serialize_tuple_end(&mut self, _state: TupleState) -> Result<(), Error> { + fn serialize_tuple_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(Error::top_level()) } - /// Returns an error. - fn serialize_tuple_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result { - Err(Error::top_level()) + /// Serializes a map, given length is ignored. + fn serialize_map(self, + _len: Option) + -> Result { + Ok(MapSerializer { + urlencoder: self.urlencoder, + key: None, + }) } - /// Returns an error. - fn serialize_tuple_struct_elt(&mut self, - _state: &mut TupleStructState, - _value: T) - -> Result<(), Error> - where T: ser::Serialize, - { - Err(Error::top_level()) + /// Serializes a struct, given length is ignored. + fn serialize_struct(self, + _name: &'static str, + _len: usize) + -> Result { + Ok(StructSerializer { urlencoder: self.urlencoder }) } /// Returns an error. - fn serialize_tuple_struct_end(&mut self, - _state: TupleStructState) - -> Result<(), Error> { + fn serialize_struct_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(Error::top_level()) } +} - /// Returns an error. - fn serialize_tuple_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result { - Err(Error::top_level()) +impl<'output, Target> ser::SerializeSeq for SeqSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_element(&mut self, + value: &T) + -> Result<(), Error> { + value.serialize(pair::PairSerializer::new(self.urlencoder)) } - /// Returns an error. - fn serialize_tuple_variant_elt(&mut self, - _state: &mut TupleVariantState, - _value: T) - -> Result<(), Error> - where T: ser::Serialize, - { - Err(Error::top_level()) + fn end(self) -> Result { + Ok(self.urlencoder) } +} - /// Returns an error. - fn serialize_tuple_variant_end(&mut self, - _state: TupleVariantState) - -> Result<(), Error> { - Err(Error::top_level()) +impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_element(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() } - /// Begins to serialize a map, given length (if any) is ignored. - fn serialize_map(&mut self, - _len: Option) - -> Result { - Ok(MapState { key: None }) - } - - /// Serializes a map key. - fn serialize_map_key(&mut self, - state: &mut MapState, - key: T) - -> Result<(), Error> - where T: ser::Serialize, - { - key.serialize(&mut key::MapKeySerializer::new(&mut state.key)) - } - - /// Serializes a map value. - fn serialize_map_value(&mut self, - state: &mut MapState, - value: T) - -> Result<(), Error> - where T: ser::Serialize, - { - let mut value_serializer = - value::ValueSerializer::new(&mut state.key, self.urlencoder)?; - value.serialize(&mut value_serializer) - } - - /// Finishes serializing a map. - fn serialize_map_end(&mut self, _state: MapState) -> Result<(), Error> { + fn end(self) -> Result { + unreachable!() + } +} + +impl<'output, Target> ser::SerializeTupleStruct + for TupleStructSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'output, Target> ser::SerializeTupleVariant + for TupleVariantSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'output, Target> ser::SerializeMap for MapSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_entry + (&mut self, + key: &K, + value: &V) + -> Result<(), Error> { + let key_sink = key::KeySink::new(|key| { + let value_sink = value::ValueSink::new(self.urlencoder, &key); + value.serialize(part::PartSerializer::new(value_sink))?; + self.key = None; + Ok(()) + }); + let entry_serializer = part::PartSerializer::new(key_sink); + key.serialize(entry_serializer) + } + + fn serialize_key(&mut self, + key: &T) + -> Result<(), Error> { + let key_sink = key::KeySink::new(|key| Ok(key.into())); + let key_serializer = part::PartSerializer::new(key_sink); + self.key = Some(key.serialize(key_serializer)?); Ok(()) } - /// Begins to serialize a struct, given length is ignored. - fn serialize_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result { - Ok(StructState { _state: () }) - } - - /// Serializes a struct element. - fn serialize_struct_elt(&mut self, - _state: &mut StructState, - key: &'static str, - value: T) - -> Result<(), Error> - where T: ser::Serialize, - { - let mut key = Some(key.into()); - let mut value_serializer = - value::ValueSerializer::new(&mut key, self.urlencoder).unwrap(); - value.serialize(&mut value_serializer) - } - - /// Finishes serializing a struct. - fn serialize_struct_end(&mut self, - _state: StructState) - -> Result<(), Error> { + fn serialize_value(&mut self, + value: &T) + -> Result<(), Error> { + { + let key = self.key.as_ref().ok_or_else(|| Error::no_key())?; + let value_sink = value::ValueSink::new(self.urlencoder, &key); + value.serialize(part::PartSerializer::new(value_sink))?; + } + self.key = None; Ok(()) } - /// Returns an error. - fn serialize_struct_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result { - Err(Error::top_level()) + fn end(self) -> Result { + Ok(self.urlencoder) } +} - /// Returns an error. - fn serialize_struct_variant_elt(&mut self, - _state: &mut StructVariantState, - _key: &'static str, - _value: T) - -> Result<(), Error> { - Err(Error::top_level()) +impl<'output, Target> ser::SerializeStruct for StructSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_field(&mut self, + key: &'static str, + value: &T) + -> Result<(), Error> { + let value_sink = value::ValueSink::new(self.urlencoder, key); + value.serialize(part::PartSerializer::new(value_sink)) } - /// Returns an error. - fn serialize_struct_variant_end(&mut self, - _state: StructVariantState) - -> Result<(), Error> { - Err(Error::top_level()) + fn end(self) -> Result { + Ok(self.urlencoder) + } +} + +impl<'output, Target> ser::SerializeStructVariant + for StructVariantSerializer<'output, Target> + where Target: 'output + UrlEncodedTarget, +{ + type Ok = &'output mut UrlEncodedSerializer; + type Error = Error; + + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() } } impl Error { fn top_level() -> Self { - Error::Custom("top-level serializer supports only maps and structs" - .into()) + let msg = "top-level serializer supports only maps and structs"; + Error::Custom(msg.into()) + } + + fn no_key() -> Self { + let msg = "tried to serialize a value before serializing key"; + Error::Custom(msg.into()) } } diff --git a/src/ser/pair.rs b/src/ser/pair.rs index 36eda51..3d91637 100644 --- a/src/ser/pair.rs +++ b/src/ser/pair.rs @@ -1,111 +1,107 @@ -use ser::{Error, key, value}; -use serde::{Serialize, Serializer}; +use ser::Error; +use ser::key::KeySink; +use ser::part::PartSerializer; +use ser::value::ValueSink; +use serde::ser; use std::borrow::Cow; -use url::form_urlencoded; +use std::mem; +use url::form_urlencoded::Serializer as UrlEncodedSerializer; +use url::form_urlencoded::Target as UrlEncodedTarget; -pub struct PairSerializer<'target, Target>( - &'target mut form_urlencoded::Serializer) - where Target: 'target + form_urlencoded::Target; +pub struct PairSerializer<'target, Target: 'target + UrlEncodedTarget> { + urlencoder: &'target mut UrlEncodedSerializer, + state: PairState, +} impl<'target, Target> PairSerializer<'target, Target> - where Target: 'target + form_urlencoded::Target, + where Target: 'target + UrlEncodedTarget, { - pub fn new(serializer: &'target mut form_urlencoded::Serializer) - -> Self { - PairSerializer(serializer) + pub fn new(urlencoder: &'target mut UrlEncodedSerializer) -> Self { + PairSerializer { + urlencoder: urlencoder, + state: PairState::WaitingForKey, + } } } -pub struct TupleState(Option>>); -pub struct TupleStructState(TupleState); - -impl<'target, Target> Serializer for PairSerializer<'target, Target> - where Target: 'target + form_urlencoded::Target, +impl<'target, Target> ser::Serializer for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, { + type Ok = (); type Error = Error; - type SeqState = (); - type TupleState = TupleState; - type TupleStructState = TupleStructState; - type TupleVariantState = (); - type MapState = (); - type StructState = (); - type StructVariantState = (); - - fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> { - Err(Error::Custom("booleans are not supported values".into())) - } - - fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> { - Err(Error::unsupported_pair()) - } + type SerializeSeq = Self; + type SerializeTuple = Self; + type SerializeTupleStruct = Self; + type SerializeTupleVariant = Self; + type SerializeMap = Self; + type SerializeStruct = Self; + type SerializeStructVariant = Self; - fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> { + fn serialize_bool(self, _v: bool) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> { + fn serialize_i8(self, _v: i8) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> { + fn serialize_i16(self, _v: i16) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> { + fn serialize_i32(self, _v: i32) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> { + fn serialize_i64(self, _v: i64) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> { + fn serialize_u8(self, _v: u8) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> { + fn serialize_u16(self, _v: u16) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> { + fn serialize_u32(self, _v: u32) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> { + fn serialize_u64(self, _v: u64) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> { + fn serialize_f32(self, _v: f32) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> { + fn serialize_f64(self, _v: f64) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_char(&mut self, _v: char) -> Result<(), Error> { + fn serialize_char(self, _v: char) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_str(&mut self, _value: &str) -> Result<(), Error> { + fn serialize_str(self, _value: &str) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Error> { + fn serialize_bytes(self, _value: &[u8]) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_unit(&mut self) -> Result<(), Error> { + fn serialize_unit(self) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_unit_struct(&mut self, - _name: &'static str) - -> Result<(), Error> { + fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_unit_variant(&mut self, + fn serialize_unit_variant(self, _name: &'static str, _variant_index: usize, _variant: &'static str) @@ -113,213 +109,259 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target> Err(Error::unsupported_pair()) } - fn serialize_newtype_struct(&mut self, - _name: &'static str, - value: T) - -> Result<(), Error> - where T: Serialize, - { + fn serialize_newtype_struct + (self, + _name: &'static str, + value: &T) + -> Result<(), Error> { value.serialize(self) } - fn serialize_newtype_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize, - { + fn serialize_newtype_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: &T) + -> Result<(), Error> { Err(Error::unsupported_pair()) } - fn serialize_none(&mut self) -> Result<(), Error> { + fn serialize_none(self) -> Result<(), Error> { Ok(()) } - fn serialize_some(&mut self, value: T) -> Result<(), Error> - where T: Serialize, - { + fn serialize_some(self, + value: &T) + -> Result<(), Error> { value.serialize(self) } - fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> { + fn serialize_seq(self, _len: Option) -> Result { Err(Error::unsupported_pair()) } - fn serialize_seq_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { + fn serialize_seq_fixed_size(self, _len: usize) -> Result { Err(Error::unsupported_pair()) } - fn serialize_seq_end(&mut self, _state: ()) -> Result<(), Error> { + fn serialize_tuple(self, len: usize) -> Result { + if len == 2 { + Ok(self) + } else { + Err(Error::unsupported_pair()) + } + } + + fn serialize_tuple_struct(self, + _name: &'static str, + _len: usize) + -> Result { Err(Error::unsupported_pair()) } - fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> { + fn serialize_tuple_variant(self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(Error::unsupported_pair()) } - fn serialize_tuple(&mut self, len: usize) -> Result { - if len == 2 { - Ok(TupleState(None)) - } else { - Err(Error::unsupported_pair()) - } + fn serialize_map(self, _len: Option) -> Result { + Err(Error::unsupported_pair()) } - fn serialize_tuple_elt(&mut self, - state: &mut TupleState, - value: T) - -> Result<(), Error> - where T: Serialize, - { - match state.0.take() { - None => { - let mut key = None; - { - let mut key_serializer = - key::MapKeySerializer::new(&mut key); - value.serialize(&mut key_serializer)?; - } - state.0 = Some(key); + fn serialize_struct(self, + _name: &'static str, + _len: usize) + -> Result { + Err(Error::unsupported_pair()) + } + + fn serialize_struct_variant(self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { + Err(Error::unsupported_pair()) + } +} + +impl<'target, Target> ser::SerializeSeq for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; + + fn serialize_element(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result<(), Error> { + unreachable!() + } +} + +impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; + + fn serialize_element(&mut self, + value: &T) + -> Result<(), Error> { + match mem::replace(&mut self.state, PairState::Done) { + PairState::WaitingForKey => { + let key_sink = KeySink::new(|key| Ok(key.into())); + let key_serializer = PartSerializer::new(key_sink); + self.state = PairState::WaitingForValue { + key: value.serialize(key_serializer)?, + }; Ok(()) }, - Some(ref mut key) => { - { - let mut value_serializer = - value::ValueSerializer::new(key, &mut self.0).unwrap(); - value.serialize(&mut value_serializer)?; + PairState::WaitingForValue { key } => { + let result = { + let value_sink = ValueSink::new(self.urlencoder, &key); + let value_serializer = PartSerializer::new(value_sink); + value.serialize(value_serializer) + }; + if result.is_ok() { + self.state = PairState::Done; + } else { + self.state = PairState::WaitingForValue { key: key }; } - state.0 = Some(None); - Ok(()) + result }, + PairState::Done => Err(Error::done()), } } - fn serialize_tuple_end(&mut self, _state: TupleState) -> Result<(), Error> { - Ok(()) + fn end(self) -> Result<(), Error> { + if let PairState::Done = self.state { + Ok(()) + } else { + Err(Error::not_done()) + } } +} - fn serialize_tuple_struct(&mut self, - _name: &'static str, - len: usize) - -> Result { - self.serialize_tuple(len).map(TupleStructState) - } +impl<'target, Target> ser::SerializeTupleStruct + for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; - fn serialize_tuple_struct_elt(&mut self, - state: &mut TupleStructState, - value: T) - -> Result<(), Error> - where T: Serialize, - { - self.serialize_tuple_elt(&mut state.0, value) + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() } - fn serialize_tuple_struct_end(&mut self, - _state: TupleStructState) - -> Result<(), Error> { - Ok(()) + fn end(self) -> Result<(), Error> { + unreachable!() } +} - fn serialize_tuple_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_pair()) - } +impl<'target, Target> ser::SerializeTupleVariant + for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; - fn serialize_tuple_variant_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_pair()) + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() } - fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_pair()) + fn end(self) -> Result<(), Error> { + unreachable!() } +} - fn serialize_map(&mut self, _len: Option) -> Result<(), Error> { - Err(Error::unsupported_pair()) - } +impl<'target, Target> ser::SerializeMap for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; - fn serialize_map_key(&mut self, - _state: &mut (), - _key: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_pair()) + fn serialize_key(&mut self, + _key: &T) + -> Result<(), Error> { + unreachable!() } - fn serialize_map_value(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_pair()) + fn serialize_value(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() } - fn serialize_map_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_pair()) + fn end(self) -> Result<(), Error> { + unreachable!() } +} - fn serialize_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_pair()) - } +impl<'target, Target> ser::SerializeStruct for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; - fn serialize_struct_elt(&mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_pair()) + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + unreachable!() } - fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_pair()) + fn end(self) -> Result<(), Error> { + unreachable!() } +} - fn serialize_struct_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_pair()) - } - fn serialize_struct_variant_elt(&mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> { - Err(Error::unsupported_pair()) +impl<'target, Target> ser::SerializeStructVariant + for PairSerializer<'target, Target> + where Target: 'target + UrlEncodedTarget, +{ + type Ok = (); + type Error = Error; + + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + unreachable!() } - fn serialize_struct_variant_end(&mut self, - _state: ()) - -> Result<(), Error> { - Err(Error::unsupported_pair()) + fn end(self) -> Result<(), Error> { + unreachable!() } } +enum PairState { + WaitingForKey, + WaitingForValue { key: Cow<'static, str> }, + Done, +} + impl Error { + fn done() -> Self { + Error::Custom("this pair has already been serialized".into()) + } + + fn not_done() -> Self { + Error::Custom("this pair has not yet been serialized".into()) + } + fn unsupported_pair() -> Self { Error::Custom("unsupported pair".into()) } diff --git a/src/ser/part.rs b/src/ser/part.rs new file mode 100644 index 0000000..a865450 --- /dev/null +++ b/src/ser/part.rs @@ -0,0 +1,311 @@ +use ser::Error; +use serde::ser; +use std::str; + +pub struct PartSerializer { + sink: S, +} + +impl PartSerializer { + pub fn new(sink: S) -> Self { + PartSerializer { sink: sink } + } +} + +pub trait Sink: Sized { + type Ok; + + fn serialize_bool(self, value: bool) -> Result; + + fn serialize_static_str(self, + value: &'static str) + -> Result; + + fn serialize_str(self, value: &str) -> Result; + fn serialize_string(self, value: String) -> Result; + fn serialize_none(self) -> Result; + + fn serialize_some + (self, + value: &T) + -> Result; + + fn unsupported(self) -> Error; +} + +impl ser::Serializer for PartSerializer { + type Ok = S::Ok; + type Error = Error; + type SerializeSeq = Self; + type SerializeTuple = Self; + type SerializeTupleStruct = Self; + type SerializeTupleVariant = Self; + type SerializeMap = Self; + type SerializeStruct = Self; + type SerializeStructVariant = Self; + + fn serialize_bool(self, v: bool) -> Result { + self.sink.serialize_bool(v) + } + + fn serialize_i8(self, v: i8) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_i16(self, v: i16) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_i32(self, v: i32) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_i64(self, v: i64) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_u8(self, v: u8) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_u16(self, v: u16) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_u32(self, v: u32) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_u64(self, v: u64) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_f32(self, v: f32) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_f64(self, v: f64) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_char(self, v: char) -> Result { + self.sink.serialize_string(v.to_string()) + } + + fn serialize_str(self, value: &str) -> Result { + self.sink.serialize_str(value) + } + + fn serialize_bytes(self, value: &[u8]) -> Result { + match str::from_utf8(value) { + Ok(value) => self.sink.serialize_str(value), + Err(err) => Err(Error::Utf8(err)), + } + } + + fn serialize_unit(self) -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_unit_struct(self, name: &'static str) -> Result { + self.sink.serialize_static_str(name.into()) + } + + fn serialize_unit_variant(self, + _name: &'static str, + _variant_index: usize, + variant: &'static str) + -> Result { + self.sink.serialize_static_str(variant.into()) + } + + fn serialize_newtype_struct + (self, + _name: &'static str, + value: &T) + -> Result { + value.serialize(self) + } + + fn serialize_newtype_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _value: &T) + -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_none(self) -> Result { + self.sink.serialize_none() + } + + fn serialize_some(self, + value: &T) + -> Result { + self.sink.serialize_some(value) + } + + fn serialize_seq(self, _len: Option) -> Result { + Err(self.sink.unsupported()) + } + + + fn serialize_seq_fixed_size(self, _len: usize) -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_tuple(self, _len: usize) -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_tuple_struct(self, + _name: &'static str, + _len: usize) + -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_tuple_variant(self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_map(self, _len: Option) -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_struct(self, + _name: &'static str, + _len: usize) + -> Result { + Err(self.sink.unsupported()) + } + + fn serialize_struct_variant(self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { + Err(self.sink.unsupported()) + } +} + +impl ser::SerializeSeq for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_element(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl ser::SerializeTuple for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_element(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl ser::SerializeTupleStruct for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl ser::SerializeTupleVariant for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl ser::SerializeMap for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_key(&mut self, + _key: &T) + -> Result<(), Error> { + unreachable!() + } + + fn serialize_value(&mut self, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl ser::SerializeStruct for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl ser::SerializeStructVariant for PartSerializer { + type Ok = S::Ok; + type Error = Error; + + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} diff --git a/src/ser/value.rs b/src/ser/value.rs index fcaf0f4..4bba002 100644 --- a/src/ser/value.rs +++ b/src/ser/value.rs @@ -1,331 +1,63 @@ use ser::Error; -use serde::{Serialize, Serializer}; -use std::borrow::Cow; +use ser::part::{PartSerializer, Sink}; +use serde::ser::Serialize; use std::str; -use url::form_urlencoded; +use url::form_urlencoded::Serializer as UrlEncodedSerializer; +use url::form_urlencoded::Target as UrlEncodedTarget; -pub struct ValueSerializer<'key, 'target, Target> - where Target: 'target + form_urlencoded::Target, +pub struct ValueSink<'key, 'target, Target> + where Target: 'target + UrlEncodedTarget, { - key: &'key mut Option>, - serializer: &'target mut form_urlencoded::Serializer, + urlencoder: &'target mut UrlEncodedSerializer, + key: &'key str, } -impl<'key, 'target, Target> ValueSerializer<'key, 'target, Target> - where Target: 'target + form_urlencoded::Target, +impl<'key, 'target, Target> ValueSink<'key, 'target, Target> + where Target: 'target + UrlEncodedTarget, { - pub fn new(key: &'key mut Option>, - serializer: &'target mut form_urlencoded::Serializer) - -> Result { - if key.is_some() { - Ok(ValueSerializer { - key: key, - serializer: serializer, - }) - } else { - Err(Error::no_key()) - } - } - - fn append_pair(&mut self, value: &str) -> Result<(), Error> { - if let Some(key) = self.key.take() { - self.serializer.append_pair(&key, value); - Ok(()) - } else { - Err(Error::no_key()) + pub fn new(urlencoder: &'target mut UrlEncodedSerializer, + key: &'key str) + -> Self { + ValueSink { + urlencoder: urlencoder, + key: key, } } } -impl<'key, 'target, Target> Serializer - for ValueSerializer<'key, 'target, Target> - where Target: 'target + form_urlencoded::Target, +impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target> + where Target: 'target + UrlEncodedTarget, { - type Error = Error; - type SeqState = (); - type TupleState = (); - type TupleStructState = (); - type TupleVariantState = (); - type MapState = (); - type StructState = (); - type StructVariantState = (); - - fn serialize_bool(&mut self, v: bool) -> Result<(), Error> { - self.append_pair(if v { "true" } else { "false" }) - } - - fn serialize_isize(&mut self, v: isize) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_i8(&mut self, v: i8) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_i16(&mut self, v: i16) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_i32(&mut self, v: i32) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_i64(&mut self, v: i64) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_usize(&mut self, v: usize) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_u8(&mut self, v: u8) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_u16(&mut self, v: u16) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_u32(&mut self, v: u32) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_u64(&mut self, v: u64) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_f32(&mut self, v: f32) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_f64(&mut self, v: f64) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_char(&mut self, v: char) -> Result<(), Error> { - self.append_pair(&v.to_string()) - } - - fn serialize_str(&mut self, value: &str) -> Result<(), Error> { - self.append_pair(value) - } + type Ok = (); - fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Error> { - match str::from_utf8(value) { - Ok(value) => self.append_pair(value), - Err(err) => Err(Error::Utf8(err)), - } - } - - fn serialize_unit(&mut self) -> Result<(), Error> { - Err(Error::unsupported_value()) + fn serialize_bool(self, value: bool) -> Result { + self.serialize_string(value.to_string()) } - fn serialize_unit_struct(&mut self, - name: &'static str) - -> Result<(), Error> { - self.append_pair(name) + fn serialize_str(self, value: &str) -> Result<(), Error> { + self.urlencoder.append_pair(self.key, value); + Ok(()) } - fn serialize_unit_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str) - -> Result<(), Error> { - self.append_pair(variant) + fn serialize_static_str(self, value: &'static str) -> Result<(), Error> { + self.serialize_str(value) } - fn serialize_newtype_struct(&mut self, - _name: &'static str, - value: T) - -> Result<(), Error> - where T: Serialize, - { - value.serialize(self) + fn serialize_string(self, value: String) -> Result<(), Error> { + self.serialize_str(&value) } - fn serialize_newtype_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_none(&mut self) -> Result<(), Error> { - if let Some(_) = self.key.take() { - Ok(()) - } else { - Err(Error::no_key()) - } + fn serialize_none(self) -> Result { + Ok(()) } - fn serialize_some(&mut self, value: T) -> Result<(), Error> - where T: Serialize, - { - value.serialize(self) - } - - fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_seq_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_seq_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_seq_fixed_size(&mut self, _size: usize) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_struct_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_struct_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_variant_elt(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_tuple_variant_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_map(&mut self, _len: Option) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_map_key(&mut self, - _state: &mut (), - _key: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_map_value(&mut self, - _state: &mut (), - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_map_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_struct(&mut self, - _name: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_struct_elt(&mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> - where T: Serialize, - { - Err(Error::unsupported_value()) - } - - fn serialize_struct_end(&mut self, _state: ()) -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_struct_variant(&mut self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result<(), Error> { - Err(Error::unsupported_value()) - } - fn serialize_struct_variant_elt(&mut self, - _state: &mut (), - _key: &'static str, - _value: T) - -> Result<(), Error> { - Err(Error::unsupported_value()) - } - - fn serialize_struct_variant_end(&mut self, - _state: ()) - -> Result<(), Error> { - Err(Error::unsupported_value()) - } -} - -impl Error { - fn no_key() -> Self { - Error::Custom("tried to serialize a value before serializing key" - .into()) + fn serialize_some(self, + value: &T) + -> Result { + value.serialize(PartSerializer::new(self)) } - fn unsupported_value() -> Self { + fn unsupported(self) -> Error { Error::Custom("unsupported value".into()) } } -- cgit v1.2.3 From fa8fb69da0b3a9d24bff09da3795e54d6b20a157 Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sat, 28 Jan 2017 23:01:20 +0100 Subject: Do not allocate a String to serialize a bool --- src/ser/value.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/ser/value.rs b/src/ser/value.rs index 4bba002..34ea7d0 100644 --- a/src/ser/value.rs +++ b/src/ser/value.rs @@ -31,7 +31,7 @@ impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target> type Ok = (); fn serialize_bool(self, value: bool) -> Result { - self.serialize_string(value.to_string()) + self.serialize_static_str(if value { "true" } else { "false" }) } fn serialize_str(self, value: &str) -> Result<(), Error> { -- cgit v1.2.3 From e140c2b5c5bb5abab7fcc6a9d4540aaa3bf566a6 Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sat, 28 Jan 2017 23:52:52 +0100 Subject: Use void for the unreachable serializers --- Cargo.toml | 1 + src/lib.rs | 1 + src/ser/mod.rs | 36 ++++++------ src/ser/pair.rs | 146 +++++++---------------------------------------- src/ser/part.rs | 174 ++++++++++++-------------------------------------------- src/ser/void.rs | 122 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 198 insertions(+), 282 deletions(-) create mode 100644 src/ser/void.rs (limited to 'src') diff --git a/Cargo.toml b/Cargo.toml index b9c18f0..a68819a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,3 +14,4 @@ test = false [dependencies] serde = "0.9.2" url = "1.0.0" +void = "1.0.2" diff --git a/src/lib.rs b/src/lib.rs index bacb67f..0c1a99e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,6 +3,7 @@ #[macro_use] extern crate serde; extern crate url; +extern crate void; pub mod de; pub mod ser; diff --git a/src/ser/mod.rs b/src/ser/mod.rs index 400846f..50355fd 100644 --- a/src/ser/mod.rs +++ b/src/ser/mod.rs @@ -4,12 +4,12 @@ mod key; mod pair; mod part; mod value; +mod void; use serde::ser; use std::borrow::Cow; use std::error; use std::fmt; -use std::marker::PhantomData; use std::str; use url::form_urlencoded::Serializer as UrlEncodedSerializer; use url::form_urlencoded::Target as UrlEncodedTarget; @@ -102,21 +102,21 @@ pub struct SeqSerializer<'output, Target: 'output + UrlEncodedTarget> { /// /// Never instantiated, tuples are not supported at top-level. pub struct TupleSerializer<'output, T: 'output + UrlEncodedTarget> { - _marker: PhantomData<&'output T>, + inner: void::VoidSerializer<&'output mut UrlEncodedSerializer>, } /// Tuple struct serializer. /// /// Never instantiated, tuple structs are not supported. pub struct TupleStructSerializer<'output, T: 'output + UrlEncodedTarget> { - _marker: PhantomData<&'output T>, + inner: void::VoidSerializer<&'output mut UrlEncodedSerializer>, } /// Tuple variant serializer. /// /// Never instantiated, tuple variants are not supported. pub struct TupleVariantSerializer<'output, T: 'output + UrlEncodedTarget> { - _marker: PhantomData<&'output T>, + inner: void::VoidSerializer<&'output mut UrlEncodedSerializer>, } /// Map serializer. @@ -134,7 +134,7 @@ pub struct StructSerializer<'output, Target: 'output + UrlEncodedTarget> { /// /// Never instantiated, struct variants are not supported. pub struct StructVariantSerializer<'output, T: 'output + UrlEncodedTarget> { - _marker: PhantomData<&'output T>, + inner: void::VoidSerializer<&'output mut UrlEncodedSerializer>, } impl<'output, Target> ser::Serializer for Serializer<'output, Target> @@ -368,13 +368,13 @@ impl<'output, Target> ser::SerializeTuple for TupleSerializer<'output, Target> type Error = Error; fn serialize_element(&mut self, - _value: &T) + value: &T) -> Result<(), Error> { - unreachable!() + self.inner.serialize_element(value) } fn end(self) -> Result { - unreachable!() + self.inner.end() } } @@ -386,13 +386,13 @@ impl<'output, Target> ser::SerializeTupleStruct type Error = Error; fn serialize_field(&mut self, - _value: &T) + value: &T) -> Result<(), Error> { - unreachable!() + self.inner.serialize_field(value) } fn end(self) -> Result { - unreachable!() + self.inner.end() } } @@ -404,13 +404,13 @@ impl<'output, Target> ser::SerializeTupleVariant type Error = Error; fn serialize_field(&mut self, - _value: &T) + value: &T) -> Result<(), Error> { - unreachable!() + self.inner.serialize_field(value) } fn end(self) -> Result { - unreachable!() + self.inner.end() } } @@ -488,14 +488,14 @@ impl<'output, Target> ser::SerializeStructVariant type Error = Error; fn serialize_field(&mut self, - _key: &'static str, - _value: &T) + key: &'static str, + value: &T) -> Result<(), Error> { - unreachable!() + self.inner.serialize_field(key, value) } fn end(self) -> Result { - unreachable!() + self.inner.end() } } diff --git a/src/ser/pair.rs b/src/ser/pair.rs index 3d91637..743b3dd 100644 --- a/src/ser/pair.rs +++ b/src/ser/pair.rs @@ -2,6 +2,7 @@ use ser::Error; use ser::key::KeySink; use ser::part::PartSerializer; use ser::value::ValueSink; +use ser::void::VoidSerializer; use serde::ser; use std::borrow::Cow; use std::mem; @@ -29,13 +30,13 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target> { type Ok = (); type Error = Error; - type SerializeSeq = Self; + type SerializeSeq = VoidSerializer<()>; type SerializeTuple = Self; - type SerializeTupleStruct = Self; - type SerializeTupleVariant = Self; - type SerializeMap = Self; - type SerializeStruct = Self; - type SerializeStructVariant = Self; + type SerializeTupleStruct = VoidSerializer<()>; + type SerializeTupleVariant = VoidSerializer<()>; + type SerializeMap = VoidSerializer<()>; + type SerializeStruct = VoidSerializer<()>; + type SerializeStructVariant = VoidSerializer<()>; fn serialize_bool(self, _v: bool) -> Result<(), Error> { Err(Error::unsupported_pair()) @@ -137,11 +138,15 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target> value.serialize(self) } - fn serialize_seq(self, _len: Option) -> Result { + fn serialize_seq(self, + _len: Option) + -> Result, Error> { Err(Error::unsupported_pair()) } - fn serialize_seq_fixed_size(self, _len: usize) -> Result { + fn serialize_seq_fixed_size(self, + _len: usize) + -> Result, Error> { Err(Error::unsupported_pair()) } @@ -156,7 +161,7 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target> fn serialize_tuple_struct(self, _name: &'static str, _len: usize) - -> Result { + -> Result, Error> { Err(Error::unsupported_pair()) } @@ -165,18 +170,20 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target> _variant_index: usize, _variant: &'static str, _len: usize) - -> Result { + -> Result, Error> { Err(Error::unsupported_pair()) } - fn serialize_map(self, _len: Option) -> Result { + fn serialize_map(self, + _len: Option) + -> Result, Error> { Err(Error::unsupported_pair()) } fn serialize_struct(self, _name: &'static str, _len: usize) - -> Result { + -> Result, Error> { Err(Error::unsupported_pair()) } @@ -185,28 +192,11 @@ impl<'target, Target> ser::Serializer for PairSerializer<'target, Target> _variant_index: usize, _variant: &'static str, _len: usize) - -> Result { + -> Result, Error> { Err(Error::unsupported_pair()) } } -impl<'target, Target> ser::SerializeSeq for PairSerializer<'target, Target> - where Target: 'target + UrlEncodedTarget, -{ - type Ok = (); - type Error = Error; - - fn serialize_element(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result<(), Error> { - unreachable!() - } -} - impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target> where Target: 'target + UrlEncodedTarget, { @@ -251,102 +241,6 @@ impl<'target, Target> ser::SerializeTuple for PairSerializer<'target, Target> } } -impl<'target, Target> ser::SerializeTupleStruct - for PairSerializer<'target, Target> - where Target: 'target + UrlEncodedTarget, -{ - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result<(), Error> { - unreachable!() - } -} - -impl<'target, Target> ser::SerializeTupleVariant - for PairSerializer<'target, Target> - where Target: 'target + UrlEncodedTarget, -{ - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result<(), Error> { - unreachable!() - } -} - -impl<'target, Target> ser::SerializeMap for PairSerializer<'target, Target> - where Target: 'target + UrlEncodedTarget, -{ - type Ok = (); - type Error = Error; - - fn serialize_key(&mut self, - _key: &T) - -> Result<(), Error> { - unreachable!() - } - - fn serialize_value(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result<(), Error> { - unreachable!() - } -} - -impl<'target, Target> ser::SerializeStruct for PairSerializer<'target, Target> - where Target: 'target + UrlEncodedTarget, -{ - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, - _key: &'static str, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result<(), Error> { - unreachable!() - } -} - -impl<'target, Target> ser::SerializeStructVariant - for PairSerializer<'target, Target> - where Target: 'target + UrlEncodedTarget, -{ - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, - _key: &'static str, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result<(), Error> { - unreachable!() - } -} - enum PairState { WaitingForKey, WaitingForValue { key: Cow<'static, str> }, diff --git a/src/ser/part.rs b/src/ser/part.rs index a865450..097504e 100644 --- a/src/ser/part.rs +++ b/src/ser/part.rs @@ -1,4 +1,5 @@ use ser::Error; +use ser::void::VoidSerializer; use serde::ser; use std::str; @@ -36,13 +37,13 @@ pub trait Sink: Sized { impl ser::Serializer for PartSerializer { type Ok = S::Ok; type Error = Error; - type SerializeSeq = Self; - type SerializeTuple = Self; - type SerializeTupleStruct = Self; - type SerializeTupleVariant = Self; - type SerializeMap = Self; - type SerializeStruct = Self; - type SerializeStructVariant = Self; + type SerializeSeq = VoidSerializer; + type SerializeTuple = VoidSerializer; + type SerializeTupleStruct = VoidSerializer; + type SerializeTupleVariant = VoidSerializer; + type SerializeMap = VoidSerializer; + type SerializeStruct = VoidSerializer; + type SerializeStructVariant = VoidSerializer; fn serialize_bool(self, v: bool) -> Result { self.sink.serialize_bool(v) @@ -147,165 +148,62 @@ impl ser::Serializer for PartSerializer { self.sink.serialize_some(value) } - fn serialize_seq(self, _len: Option) -> Result { + fn serialize_seq(self, + _len: Option) + -> Result { Err(self.sink.unsupported()) } - fn serialize_seq_fixed_size(self, _len: usize) -> Result { + fn serialize_seq_fixed_size(self, + _len: usize) + -> Result { Err(self.sink.unsupported()) } - fn serialize_tuple(self, _len: usize) -> Result { + fn serialize_tuple(self, + _len: usize) + -> Result { Err(self.sink.unsupported()) } fn serialize_tuple_struct(self, _name: &'static str, _len: usize) - -> Result { + -> Result { Err(self.sink.unsupported()) } - fn serialize_tuple_variant(self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result { + fn serialize_tuple_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(self.sink.unsupported()) } - fn serialize_map(self, _len: Option) -> Result { + fn serialize_map(self, + _len: Option) + -> Result { Err(self.sink.unsupported()) } fn serialize_struct(self, _name: &'static str, _len: usize) - -> Result { + -> Result { Err(self.sink.unsupported()) } - fn serialize_struct_variant(self, - _name: &'static str, - _variant_index: usize, - _variant: &'static str, - _len: usize) - -> Result { + fn serialize_struct_variant + (self, + _name: &'static str, + _variant_index: usize, + _variant: &'static str, + _len: usize) + -> Result { Err(self.sink.unsupported()) } } - -impl ser::SerializeSeq for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_element(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} - -impl ser::SerializeTuple for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_element(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} - -impl ser::SerializeTupleStruct for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_field(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} - -impl ser::SerializeTupleVariant for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_field(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} - -impl ser::SerializeMap for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_key(&mut self, - _key: &T) - -> Result<(), Error> { - unreachable!() - } - - fn serialize_value(&mut self, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} - -impl ser::SerializeStruct for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_field(&mut self, - _key: &'static str, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} - -impl ser::SerializeStructVariant for PartSerializer { - type Ok = S::Ok; - type Error = Error; - - fn serialize_field(&mut self, - _key: &'static str, - _value: &T) - -> Result<(), Error> { - unreachable!() - } - - fn end(self) -> Result { - unreachable!() - } -} diff --git a/src/ser/void.rs b/src/ser/void.rs new file mode 100644 index 0000000..4765bb7 --- /dev/null +++ b/src/ser/void.rs @@ -0,0 +1,122 @@ +use ser::Error; +use serde::ser; +use std::marker::PhantomData; +use void; + +pub struct VoidSerializer { + void: void::Void, + _marker: PhantomData, +} + +impl ser::SerializeSeq for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_element(&mut self, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} + +impl ser::SerializeTuple for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_element(&mut self, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} + +impl ser::SerializeTupleStruct for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} + +impl ser::SerializeTupleVariant for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_field(&mut self, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} + +impl ser::SerializeMap for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_key(&mut self, + _key: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn serialize_value(&mut self, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} + +impl ser::SerializeStruct for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} + +impl ser::SerializeStructVariant for VoidSerializer { + type Ok = Ok; + type Error = Error; + + fn serialize_field(&mut self, + _key: &'static str, + _value: &T) + -> Result<(), Error> { + void::unreachable(self.void) + } + + fn end(self) -> Result { + void::unreachable(self.void) + } +} -- cgit v1.2.3 From 1d88bbb26b9caaa90993845042e21af444e9399a Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sat, 28 Jan 2017 23:56:15 +0100 Subject: Use itoa to not allocate a String to serialize an integer --- Cargo.toml | 1 + src/lib.rs | 1 + src/ser/part.rs | 28 ++++++++++++++++++++-------- 3 files changed, 22 insertions(+), 8 deletions(-) (limited to 'src') diff --git a/Cargo.toml b/Cargo.toml index a68819a..e7865a4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,7 @@ keywords = ["serde", "serialization", "urlencoded"] test = false [dependencies] +itoa = "0.3.0" serde = "0.9.2" url = "1.0.0" void = "1.0.2" diff --git a/src/lib.rs b/src/lib.rs index 0c1a99e..7a3be26 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,6 @@ //! `x-www-form-urlencoded` meets Serde +extern crate itoa; #[macro_use] extern crate serde; extern crate url; diff --git a/src/ser/part.rs b/src/ser/part.rs index 097504e..33811f4 100644 --- a/src/ser/part.rs +++ b/src/ser/part.rs @@ -1,3 +1,4 @@ +use itoa; use ser::Error; use ser::void::VoidSerializer; use serde::ser; @@ -50,35 +51,35 @@ impl ser::Serializer for PartSerializer { } fn serialize_i8(self, v: i8) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_i16(self, v: i16) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_i32(self, v: i32) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_i64(self, v: i64) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_u8(self, v: u8) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_u16(self, v: u16) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_u32(self, v: u32) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_u64(self, v: u64) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_integer(v) } fn serialize_f32(self, v: f32) -> Result { @@ -207,3 +208,14 @@ impl ser::Serializer for PartSerializer { Err(self.sink.unsupported()) } } + +impl PartSerializer { + fn serialize_integer(self, value: I) -> Result + where I: itoa::Integer + { + let mut buf = [b'\0'; 20]; + let len = itoa::write(&mut buf[..], value).unwrap(); + let part = unsafe { str::from_utf8_unchecked(&buf[0..len]) }; + ser::Serializer::serialize_str(self, part) + } +} -- cgit v1.2.3 From 5625c254e55c767a1ec0235219c232f53dcf9e96 Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sun, 29 Jan 2017 00:14:57 +0100 Subject: Use dtoa to not allocate a String to serialize a float --- Cargo.toml | 1 + src/lib.rs | 1 + src/ser/part.rs | 14 ++++++++++++-- 3 files changed, 14 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/Cargo.toml b/Cargo.toml index e7865a4..8566cc1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,7 @@ keywords = ["serde", "serialization", "urlencoded"] test = false [dependencies] +dtoa = "0.4.0" itoa = "0.3.0" serde = "0.9.2" url = "1.0.0" diff --git a/src/lib.rs b/src/lib.rs index 7a3be26..8fefd77 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,6 +1,7 @@ //! `x-www-form-urlencoded` meets Serde extern crate itoa; +extern crate dtoa; #[macro_use] extern crate serde; extern crate url; diff --git a/src/ser/part.rs b/src/ser/part.rs index 33811f4..049bacd 100644 --- a/src/ser/part.rs +++ b/src/ser/part.rs @@ -1,3 +1,4 @@ +use dtoa; use itoa; use ser::Error; use ser::void::VoidSerializer; @@ -83,11 +84,11 @@ impl ser::Serializer for PartSerializer { } fn serialize_f32(self, v: f32) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_floating(v) } fn serialize_f64(self, v: f64) -> Result { - self.sink.serialize_string(v.to_string()) + self.serialize_floating(v) } fn serialize_char(self, v: char) -> Result { @@ -218,4 +219,13 @@ impl PartSerializer { let part = unsafe { str::from_utf8_unchecked(&buf[0..len]) }; ser::Serializer::serialize_str(self, part) } + + fn serialize_floating(self, value: F) -> Result + where F: dtoa::Floating + { + let mut buf = [b'\0'; 24]; + let len = dtoa::write(&mut buf[..], value).unwrap(); + let part = unsafe { str::from_utf8_unchecked(&buf[0..len]) }; + ser::Serializer::serialize_str(self, part) + } } -- cgit v1.2.3 From f5b1ae88282adfc2fe2253e4cd51c6ba5eca0c54 Mon Sep 17 00:00:00 2001 From: Anthony Ramine Date: Sun, 29 Jan 2017 00:17:54 +0100 Subject: Do not forbid bool keys anymore Floats are supported so... --- src/ser/key.rs | 4 ---- src/ser/part.rs | 4 +--- src/ser/value.rs | 4 ---- 3 files changed, 1 insertion(+), 11 deletions(-) (limited to 'src') diff --git a/src/ser/key.rs b/src/ser/key.rs index 149c8f6..6cbbff4 100644 --- a/src/ser/key.rs +++ b/src/ser/key.rs @@ -46,10 +46,6 @@ impl Sink for KeySink { type Ok = Ok; - fn serialize_bool(self, _value: bool) -> Result { - Err(self.unsupported()) - } - fn serialize_static_str(self, value: &'static str) -> Result { diff --git a/src/ser/part.rs b/src/ser/part.rs index 049bacd..e720314 100644 --- a/src/ser/part.rs +++ b/src/ser/part.rs @@ -18,8 +18,6 @@ impl PartSerializer { pub trait Sink: Sized { type Ok; - fn serialize_bool(self, value: bool) -> Result; - fn serialize_static_str(self, value: &'static str) -> Result; @@ -48,7 +46,7 @@ impl ser::Serializer for PartSerializer { type SerializeStructVariant = VoidSerializer; fn serialize_bool(self, v: bool) -> Result { - self.sink.serialize_bool(v) + self.sink.serialize_static_str(if v { "true" } else { "false" }) } fn serialize_i8(self, v: i8) -> Result { diff --git a/src/ser/value.rs b/src/ser/value.rs index 34ea7d0..e4e1f2c 100644 --- a/src/ser/value.rs +++ b/src/ser/value.rs @@ -30,10 +30,6 @@ impl<'key, 'target, Target> Sink for ValueSink<'key, 'target, Target> { type Ok = (); - fn serialize_bool(self, value: bool) -> Result { - self.serialize_static_str(if value { "true" } else { "false" }) - } - fn serialize_str(self, value: &str) -> Result<(), Error> { self.urlencoder.append_pair(self.key, value); Ok(()) -- cgit v1.2.3