summaryrefslogtreecommitdiff
path: root/src/ser/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/ser/mod.rs')
-rw-r--r--src/ser/mod.rs218
1 files changed, 111 insertions, 107 deletions
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<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,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<T>(
- &mut self, _name: &'static str, value: T)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_newtype_struct<T>(&mut self,
+ _name: &'static str,
+ value: T)
+ -> Result<(), Error>
+ where T: ser::Serialize,
{
value.serialize(self)
}
/// Returns an error.
- fn serialize_newtype_variant<T>(
- &mut self,
- _name: &'static str,
- _variant_index: usize,
- _variant: &'static str,
- _value: T)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_newtype_variant<T>(&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<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>)
- -> Result<SeqState, Error> {
+ 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)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_seq_elt<T>(&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<SeqState, Error> {
+ 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)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_tuple_elt<T>(&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<TupleStructState, Error> {
+ 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)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_tuple_struct_elt<T>(&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<TupleVariantState, Error> {
+ fn serialize_tuple_variant(&mut self,
+ _name: &'static str,
+ _variant_index: usize,
+ _variant: &'static str,
+ _len: usize)
+ -> Result<TupleVariantState, Error> {
Err(Error::top_level())
}
/// Returns an error.
- fn serialize_tuple_variant_elt<T>(
- &mut self, _state: &mut TupleVariantState, _value: T)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_tuple_variant_elt<T>(&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<usize>)
- -> Result<MapState, Error> {
+ 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)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_map_key<T>(&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<T>(
- &mut self, state: &mut MapState, value: T)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_map_value<T>(&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<StructState, Error> {
+ 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,
- _state: &mut StructState,
- key: &'static str,
- value: T)
- -> Result<(), Error>
- where T: ser::Serialize
+ fn serialize_struct_elt<T>(&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<StructVariantState, Error> {
+ fn serialize_struct_variant(&mut self,
+ _name: &'static str,
+ _variant_index: usize,
+ _variant: &'static str,
+ _len: usize)
+ -> Result<StructVariantState, Error> {
Err(Error::top_level())
}
/// Returns an error.
- fn serialize_struct_variant_elt<T>(
- &mut self,
- _state: &mut StructVariantState,
- _key: &'static str,
- _value: T)
- -> Result<(), Error> {
+ fn serialize_struct_variant_elt<T>(&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())
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-02 09:12:47 +0000