chris/ruwuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reformat with rustfmt

Browse Source
This commit is contained in:
Anthony Ramine 2017-01-27 22:56:04 +01:00
parent 9aefb1c02d
commit 8e5cf19e07
7 changed files with 439 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
rustfmt.toml Normal file
View File

@ -0,0 +1,7 @@
match_block_trailing_comma = true
max_width = 80
newline_style = "Unix"
reorder_imported_names = true
reorder_imports = true
use_try_shorthand = true
where_trailing_comma = true

32
src/de.rs
View File

@ -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<T: de::Deserialize>(input: &str) -> Result<T, Error> {
/// * Everything else but `deserialize_seq` and `deserialize_seq_fixed_size`
/// defers to `deserialize`.
pub struct Deserializer<'a> {
inner:
MapDeserializer<UrlEncodedParse<'a>, Cow<'a, str>, Cow<'a, str>, Error>,
inner: MapDeserializer<UrlEncodedParse<'a>,
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<V>(
&mut self, visitor: V)
-> Result<V::Value, Self::Error>
fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
where V: de::Visitor,
{
self.deserialize_map(visitor)
}
fn deserialize_map<V>(
&mut self, mut visitor: V)
fn deserialize_map<V>(&mut self,
mut visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_map(&mut self.inner)
}
fn deserialize_seq<V>(
&mut self, mut visitor: V)
fn deserialize_seq<V>(&mut self,
mut visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor,
{
visitor.visit_seq(&mut self.inner)
}
fn deserialize_seq_fixed_size<V>(
&mut self, _len: usize, mut visitor: V)
fn deserialize_seq_fixed_size<V>(&mut self,
_len: usize,
mut visitor: V)
-> Result<V::Value, Self::Error>
where V: de::Visitor
where V: de::Visitor,
{
visitor.visit_seq(&mut self.inner)
}

102
src/ser/key.rs
View File

@ -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<T>(&mut self, key: T) -> Result<(), Error>
where T: Into<Cow<'static, str>>
where T: Into<Cow<'static, str>>,
{
*self.0 = Some(key.into());
Ok(())
@ -99,14 +100,13 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key())
}
fn serialize_unit_struct(
&mut self, name: &'static str)
fn serialize_unit_struct(&mut self,
name: &'static str)
-> Result<(), Error> {
self.set_key(name)
}
fn serialize_unit_variant(
&mut self,
fn serialize_unit_variant(&mut self,
_name: &'static str,
_variant_index: usize,
variant: &'static str)
@ -114,22 +114,22 @@ impl<'key> Serializer for MapKeySerializer<'key> {
self.set_key(variant)
}
fn serialize_newtype_struct<T>(
&mut self, _name: &'static str, value: T)
fn serialize_newtype_struct<T>(&mut self,
_name: &'static str,
value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T>(
&mut self,
fn serialize_newtype_variant<T>(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_key())
}
@ -139,7 +139,7 @@ impl<'key> Serializer for MapKeySerializer<'key> {
}
fn serialize_some<T>(&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<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_seq_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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)
fn serialize_tuple_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<(), Error> {
Err(Error::unsupported_key())
}
fn serialize_tuple_struct_elt<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_struct_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_key())
}
@ -198,8 +202,7 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key())
}
fn serialize_tuple_variant(
&mut self,
fn serialize_tuple_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -208,10 +211,11 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key())
}
fn serialize_tuple_variant_elt<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_variant_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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<T>(
&mut self, _state: &mut (), _key: T)
fn serialize_map_key<T>(&mut self,
_state: &mut (),
_key: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_key())
}
fn serialize_map_value<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_map_value<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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)
fn serialize_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<(), Error> {
Err(Error::unsupported_key())
}
fn serialize_struct_elt<T>(
&mut self, _state: &mut (), _key: &'static str, _value: T)
fn serialize_struct_elt<T>(&mut self,
_state: &mut (),
_key: &'static str,
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_key())
}
@ -262,8 +271,7 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key())
}
fn serialize_struct_variant(
&mut self,
fn serialize_struct_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -272,14 +280,16 @@ impl<'key> Serializer for MapKeySerializer<'key> {
Err(Error::unsupported_key())
}
fn serialize_struct_variant_elt<T>(
&mut self, _state: &mut (), _key: &'static str, _value: T)
fn serialize_struct_variant_elt<T>(&mut self,
_state: &mut (),
_key: &'static str,
_value: T)
-> Result<(), Error> {
Err(Error::unsupported_key())
}
fn serialize_struct_variant_end(
&mut self, _state: ())
fn serialize_struct_variant_end(&mut self,
_state: ())
-> Result<(), Error> {
Err(Error::unsupported_key())
}

134
src/ser/mod.rs
View File

@ -30,7 +30,7 @@ pub fn to_string<T: ser::Serialize>(input: &T) -> Result<String, Error> {
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<T: ser::Serialize>(input: &T) -> Result<String, Error> {
///
/// * Newtype structs defer to their inner values.
pub struct Serializer<'output, T: 'output + UrlEncodedTarget> {
urlencoder: &'output mut UrlEncodedSerializer<T>
urlencoder: &'output mut UrlEncodedSerializer<T>,
}
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<Cow<'static, str>>
key: Option<Cow<'static, str>>,
}
/// 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,15 +249,14 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_unit_struct(
&mut self, _name: &'static str)
fn serialize_unit_struct(&mut self,
_name: &'static str)
-> Result<(), Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_unit_variant(
&mut self,
fn serialize_unit_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str)
@ -265,23 +265,23 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Serializes the inner value, ignoring the newtype name.
fn serialize_newtype_struct<T>(
&mut self, _name: &'static str, value: T)
fn serialize_newtype_struct<T>(&mut self,
_name: &'static str,
value: T)
-> Result<(), Error>
where T: ser::Serialize
where T: ser::Serialize,
{
value.serialize(self)
}
/// Returns an error.
fn serialize_newtype_variant<T>(
&mut self,
fn serialize_newtype_variant<T>(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_value: T)
-> Result<(), Error>
where T: ser::Serialize
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<T>(&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<usize>)
fn serialize_seq(&mut self,
_len: Option<usize>)
-> Result<SeqState, Error> {
Ok(SeqState { _state: () })
}
/// Serializes a sequence element.
fn serialize_seq_elt<T>(
&mut self, _state: &mut SeqState, value: T)
fn serialize_seq_elt<T>(&mut self,
_state: &mut SeqState,
value: T)
-> Result<(), Error>
where T: ser::Serialize
where T: ser::Serialize,
{
value.serialize(&mut pair::PairSerializer::new(self.urlencoder))
}
@ -320,8 +321,8 @@ 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)
fn serialize_seq_fixed_size(&mut self,
_length: usize)
-> Result<SeqState, Error> {
Ok(SeqState { _state: () })
}
@ -332,10 +333,11 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_tuple_elt<T>(
&mut self, _state: &mut TupleState, _value: T)
fn serialize_tuple_elt<T>(&mut self,
_state: &mut TupleState,
_value: T)
-> Result<(), Error>
where T: ser::Serialize
where T: ser::Serialize,
{
Err(Error::top_level())
}
@ -346,32 +348,32 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_tuple_struct(
&mut self, _name: &'static str, _len: usize)
fn serialize_tuple_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<TupleStructState, Error> {
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_struct_elt<T>(
&mut self, _state: &mut TupleStructState, _value: T)
fn serialize_tuple_struct_elt<T>(&mut self,
_state: &mut TupleStructState,
_value: T)
-> Result<(), Error>
where T: ser::Serialize
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,
fn serialize_tuple_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -381,45 +383,48 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_tuple_variant_elt<T>(
&mut self, _state: &mut TupleVariantState, _value: T)
fn serialize_tuple_variant_elt<T>(&mut self,
_state: &mut TupleVariantState,
_value: T)
-> Result<(), Error>
where T: ser::Serialize
where T: ser::Serialize,
{
Err(Error::top_level())
}
/// Returns an error.
fn serialize_tuple_variant_end(
&mut self, _state: TupleVariantState)
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<usize>)
fn serialize_map(&mut self,
_len: Option<usize>)
-> Result<MapState, Error> {
Ok(MapState { key: None })
}
/// Serializes a map key.
fn serialize_map_key<T>(
&mut self, state: &mut MapState, key: T)
fn serialize_map_key<T>(&mut self,
state: &mut MapState,
key: T)
-> Result<(), Error>
where T: ser::Serialize
where T: ser::Serialize,
{
key.serialize(&mut key::MapKeySerializer::new(&mut state.key))
}
/// Serializes a map value.
fn serialize_map_value<T>(
&mut self, state: &mut MapState, value: T)
fn serialize_map_value<T>(&mut self,
state: &mut MapState,
value: T)
-> Result<(), Error>
where T: ser::Serialize
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)
fn serialize_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<StructState, Error> {
Ok(StructState { _state: () })
}
/// Serializes a struct element.
fn serialize_struct_elt<T>(
&mut self,
fn serialize_struct_elt<T>(&mut self,
_state: &mut StructState,
key: &'static str,
value: T)
-> Result<(), Error>
where T: ser::Serialize
where T: ser::Serialize,
{
let mut key = Some(key.into());
let mut value_serializer =
@ -451,14 +456,14 @@ 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,
fn serialize_struct_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -468,8 +473,7 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_struct_variant_elt<T>(
&mut self,
fn serialize_struct_variant_elt<T>(&mut self,
_state: &mut StructVariantState,
_key: &'static str,
_value: T)
@ -478,8 +482,8 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
}
/// Returns an error.
fn serialize_struct_variant_end(
&mut self, _state: StructVariantState)
fn serialize_struct_variant_end(&mut self,
_state: StructVariantState)
-> Result<(), Error> {
Err(Error::top_level())
}
@ -487,7 +491,7 @@ impl<'output, Target> ser::Serializer for Serializer<'output, Target>
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())
}
}

124
src/ser/pair.rs
View File

@ -8,10 +8,9 @@ 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<Target>)
pub fn new(serializer: &'target mut form_urlencoded::Serializer<Target>)
-> Self {
PairSerializer(serializer)
}
@ -21,7 +20,7 @@ pub struct TupleState(Option<Option<Cow<'static, str>>>);
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,14 +99,13 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair())
}
fn serialize_unit_struct(
&mut self, _name: &'static str)
fn serialize_unit_struct(&mut self,
_name: &'static str)
-> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_unit_variant(
&mut self,
fn serialize_unit_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str)
@ -115,22 +113,22 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair())
}
fn serialize_newtype_struct<T>(
&mut self, _name: &'static str, value: T)
fn serialize_newtype_struct<T>(&mut self,
_name: &'static str,
value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T>(
&mut self,
fn serialize_newtype_variant<T>(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_pair())
}
@ -140,19 +138,20 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
}
fn serialize_some<T>(&mut self, value: T) -> Result<(), Error>
where T: Serialize
where T: Serialize,
{
value.serialize(self)
}
fn serialize_seq(&mut self, _len: Option<usize>)
-> Result<(), Error> {
fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_seq_elt<T>(&mut self, _state: &mut (), _value: T)
fn serialize_seq_elt<T>(&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<T>(
&mut self, state: &mut TupleState, value: T)
fn serialize_tuple_elt<T>(&mut self,
state: &mut TupleState,
value: T)
-> Result<(), Error>
where T: Serialize
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,28 +205,29 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Ok(())
}
fn serialize_tuple_struct(
&mut self, _name: &'static str, len: usize)
fn serialize_tuple_struct(&mut self,
_name: &'static str,
len: usize)
-> Result<TupleStructState, Error> {
self.serialize_tuple(len).map(TupleStructState)
}
fn serialize_tuple_struct_elt<T>(
&mut self, state: &mut TupleStructState, value: T)
fn serialize_tuple_struct_elt<T>(&mut self,
state: &mut TupleStructState,
value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
self.serialize_tuple_elt(&mut state.0, value)
}
fn serialize_tuple_struct_end(
&mut self, _state: TupleStructState)
fn serialize_tuple_struct_end(&mut self,
_state: TupleStructState)
-> Result<(), Error> {
Ok(())
}
fn serialize_tuple_variant(
&mut self,
fn serialize_tuple_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -236,38 +236,37 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair())
}
fn serialize_tuple_variant_elt<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_variant_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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<usize>)
-> Result<(), Error> {
fn serialize_map(&mut self, _len: Option<usize>) -> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_map_key<T>(
&mut self, _state: &mut (), _key: T)
fn serialize_map_key<T>(&mut self,
_state: &mut (),
_key: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_pair())
}
fn serialize_map_value<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_map_value<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_pair())
}
@ -276,30 +275,28 @@ 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<T>(
&mut self,
fn serialize_struct_elt<T>(&mut self,
_state: &mut (),
_key: &'static str,
_value: T)
-> Result<(), Error>
where T: Serialize
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,
fn serialize_struct_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -307,8 +304,7 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
-> Result<(), Error> {
Err(Error::unsupported_pair())
}
fn serialize_struct_variant_elt<T>(
&mut self,
fn serialize_struct_variant_elt<T>(&mut self,
_state: &mut (),
_key: &'static str,
_value: T)
@ -316,8 +312,8 @@ impl<'target, Target> Serializer for PairSerializer<'target, Target>
Err(Error::unsupported_pair())
}
fn serialize_struct_variant_end(
&mut self, _state: ())
fn serialize_struct_variant_end(&mut self,
_state: ())
-> Result<(), Error> {
Err(Error::unsupported_pair())
}

109
src/ser/value.rs
View File

@ -5,17 +5,16 @@ 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<Cow<'static, str>>,
serializer: &'target mut form_urlencoded::Serializer<Target>
serializer: &'target mut form_urlencoded::Serializer<Target>,
}
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<Cow<'static, str>>,
pub fn new(key: &'key mut Option<Cow<'static, str>>,
serializer: &'target mut form_urlencoded::Serializer<Target>)
-> Result<Self, Error> {
if key.is_some() {
@ -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,14 +121,13 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value())
}
fn serialize_unit_struct(
&mut self, name: &'static str)
fn serialize_unit_struct(&mut self,
name: &'static str)
-> Result<(), Error> {
self.append_pair(name)
}
fn serialize_unit_variant(
&mut self,
fn serialize_unit_variant(&mut self,
_name: &'static str,
_variant_index: usize,
variant: &'static str)
@ -137,22 +135,22 @@ impl<'key, 'target, Target> Serializer
self.append_pair(variant)
}
fn serialize_newtype_struct<T>(
&mut self, _name: &'static str, value: T)
fn serialize_newtype_struct<T>(&mut self,
_name: &'static str,
value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
value.serialize(self)
}
fn serialize_newtype_variant<T>(
&mut self,
fn serialize_newtype_variant<T>(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_value())
}
@ -166,7 +164,7 @@ impl<'key, 'target, Target> Serializer
}
fn serialize_some<T>(&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<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_seq_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_value())
}
@ -195,10 +194,11 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value())
}
fn serialize_tuple_elt<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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)
fn serialize_tuple_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<(), Error> {
Err(Error::unsupported_value())
}
fn serialize_tuple_struct_elt<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_struct_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_value())
}
@ -225,8 +227,7 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value())
}
fn serialize_tuple_variant(
&mut self,
fn serialize_tuple_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -235,10 +236,11 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value())
}
fn serialize_tuple_variant_elt<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_tuple_variant_elt<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_value())
}
@ -251,18 +253,20 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value())
}
fn serialize_map_key<T>(
&mut self, _state: &mut (), _key: T)
fn serialize_map_key<T>(&mut self,
_state: &mut (),
_key: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_value())
}
fn serialize_map_value<T>(
&mut self, _state: &mut (), _value: T)
fn serialize_map_value<T>(&mut self,
_state: &mut (),
_value: T)
-> Result<(), Error>
where T: Serialize
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)
fn serialize_struct(&mut self,
_name: &'static str,
_len: usize)
-> Result<(), Error> {
Err(Error::unsupported_value())
}
fn serialize_struct_elt<T>(
&mut self,
fn serialize_struct_elt<T>(&mut self,
_state: &mut (),
_key: &'static str,
_value: T)
-> Result<(), Error>
where T: Serialize
where T: Serialize,
{
Err(Error::unsupported_value())
}
@ -292,8 +296,7 @@ impl<'key, 'target, Target> Serializer
Err(Error::unsupported_value())
}
fn serialize_struct_variant(
&mut self,
fn serialize_struct_variant(&mut self,
_name: &'static str,
_variant_index: usize,
_variant: &'static str,
@ -301,14 +304,16 @@ impl<'key, 'target, Target> Serializer
-> Result<(), Error> {
Err(Error::unsupported_value())
}
fn serialize_struct_variant_elt<T>(
&mut self, _state: &mut (), _key: &'static str, _value: T)
fn serialize_struct_variant_elt<T>(&mut self,
_state: &mut (),
_key: &'static str,
_value: T)
-> Result<(), Error> {
Err(Error::unsupported_value())
}
fn serialize_struct_variant_end(
&mut self, _state: ())
fn serialize_struct_variant_end(&mut self,
_state: ())
-> Result<(), Error> {
Err(Error::unsupported_value())
}
@ -316,8 +321,8 @@ impl<'key, 'target, Target> Serializer
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 {

35
tests/test_serialize.rs
View File

@ -2,50 +2,33 @@ extern crate serde_urlencoded;
#[test]
fn serialize_option_map_int() {
let params = &[
("first", Some(23)),
("middle", None),
("last", Some(42)),
];
let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];
assert_eq!(
serde_urlencoded::to_string(params),
assert_eq!(serde_urlencoded::to_string(params),
Ok("first=23&last=42".to_owned()));
}
#[test]
fn serialize_option_map_string() {
let params = &[
("first", Some("hello")),
("middle", None),
("last", Some("world")),
];
let params =
&[("first", Some("hello")), ("middle", None), ("last", Some("world"))];
assert_eq!(
serde_urlencoded::to_string(params),
assert_eq!(serde_urlencoded::to_string(params),
Ok("first=hello&last=world".to_owned()));
}
#[test]
fn serialize_option_map_bool() {
let params = &[
("one", Some(true)),
("two", Some(false))
];
let params = &[("one", Some(true)), ("two", Some(false))];
assert_eq!(
serde_urlencoded::to_string(params),
assert_eq!(serde_urlencoded::to_string(params),
Ok("one=true&two=false".to_owned()));
}
#[test]
fn serialize_map_bool() {
let params = &[
("one", true),
("two", false)
];
let params = &[("one", true), ("two", false)];
assert_eq!(
serde_urlencoded::to_string(params),
assert_eq!(serde_urlencoded::to_string(params),
Ok("one=true&two=false".to_owned()));
}