Struct serde_urlencoded::ser::Serializer

pub struct Serializer<'output, T: 'output + UrlEncodedTarget> { /* fields omitted */ }

A serializer for the application/x-www-form-urlencoded format.

• Supported top-level inputs are structs, maps and sequences of pairs, with or without a given length.

• Supported keys and values are integers, bytes (if convertible to strings), unit structs and unit variants.

• Newtype structs defer to their inner values.

Methods

impl<'output, T: 'output + UrlEncodedTarget> Serializer<'output, T>

fn new(urlencoder: &'output mut UrlEncodedSerializer<T>) -> Self

Returns a new Serializer.

Trait Implementations

impl<'output, Target> Serializer for Serializer<'output, Target> where Target: 'output + UrlEncodedTarget

type Error = Error

The error type that can be returned if some error occurs during serialization.

type SeqState = SeqState

State used when serializing sequences.

type TupleState = TupleState

State used when serializing tuples.

type TupleStructState = TupleStructState

State used when serializing tuple structs.

type TupleVariantState = TupleVariantState

State used when serializing tuple variants.

type MapState = MapState

State used when serializing maps.

type StructState = StructState

State used when serializing structs.

type StructVariantState = StructVariantState

State used when serializing struct variants.

fn serialize_bool(&mut self, _v: bool) -> Result<(), Error>

Returns an error.

fn serialize_isize(&mut self, _v: isize) -> Result<(), Error>

Returns an error.

fn serialize_i8(&mut self, _v: i8) -> Result<(), Error>

Returns an error.

fn serialize_i16(&mut self, _v: i16) -> Result<(), Error>

Returns an error.

fn serialize_i32(&mut self, _v: i32) -> Result<(), Error>

Returns an error.

fn serialize_i64(&mut self, _v: i64) -> Result<(), Error>

Returns an error.

fn serialize_usize(&mut self, _v: usize) -> Result<(), Error>

Returns an error.

fn serialize_u8(&mut self, _v: u8) -> Result<(), Error>

Returns an error.

fn serialize_u16(&mut self, _v: u16) -> Result<(), Error>

Returns an error.

fn serialize_u32(&mut self, _v: u32) -> Result<(), Error>

Returns an error.

fn serialize_u64(&mut self, _v: u64) -> Result<(), Error>

Returns an error.

fn serialize_f32(&mut self, _v: f32) -> Result<(), Error>

Returns an error.

fn serialize_f64(&mut self, _v: f64) -> Result<(), Error>

Returns an error.

fn serialize_char(&mut self, _v: char) -> Result<(), Error>

Returns an error.

fn serialize_str(&mut self, _value: &str) -> Result<(), Error>

Returns an error.

fn serialize_bytes(&mut self, _value: &[u8]) -> Result<(), Error>

Returns an error.

fn serialize_unit(&mut self) -> Result<(), Error>

Returns an error.

fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Error>

Returns an error.

fn serialize_unit_variant(&mut self,
                          _name: &'static str,
                          _variant_index: usize,
                          _variant: &'static str)
                          -> Result<(), Error>

Returns an error.

fn serialize_newtype_struct<T>(&mut self,
                               _name: &'static str,
                               value: T)
                               -> Result<(), Error> where T: Serialize

Serializes the inner value, ignoring the newtype name.

fn serialize_newtype_variant<T>(&mut self,
                                _name: &'static str,
                                _variant_index: usize,
                                _variant: &'static str,
                                _value: T)
                                -> Result<(), Error> where T: Serialize

Returns an error.

fn serialize_none(&mut self) -> Result<(), Error>

Returns an error.

fn serialize_some<T>(&mut self, value: T) -> Result<(), Error> where T: Serialize

Returns an error.

fn serialize_seq(&mut self, _len: Option<usize>) -> Result<SeqState, Error>

Begins to serialize a sequence, given length (if any) is ignored.

fn serialize_seq_elt<T>(&mut self,
                        _state: &mut SeqState,
                        value: T)
                        -> Result<(), Error> where T: Serialize

Serializes a sequence element.

fn serialize_seq_end(&mut self, _state: SeqState) -> Result<(), Error>

Finishes serializing a sequence.

fn serialize_seq_fixed_size(&mut self,
                            _length: usize)
                            -> Result<SeqState, Error>

Begins to serialize a sequence, given length is ignored.

fn serialize_tuple(&mut self, _len: usize) -> Result<TupleState, Error>

Returns an error.

fn serialize_tuple_elt<T>(&mut self,
                          _state: &mut TupleState,
                          _value: T)
                          -> Result<(), Error> where T: Serialize

Returns an error.

fn serialize_tuple_end(&mut self, _state: TupleState) -> Result<(), Error>

Returns an error.

fn serialize_tuple_struct(&mut self,
                          _name: &'static str,
                          _len: usize)
                          -> Result<TupleStructState, Error>

Returns an error.

fn serialize_tuple_struct_elt<T>(&mut self,
                                 _state: &mut TupleStructState,
                                 _value: T)
                                 -> Result<(), Error> where T: Serialize

Returns an error.

fn serialize_tuple_struct_end(&mut self,
                              _state: TupleStructState)
                              -> Result<(), Error>

Returns an error.

fn serialize_tuple_variant(&mut self,
                           _name: &'static str,
                           _variant_index: usize,
                           _variant: &'static str,
                           _len: usize)
                           -> Result<TupleVariantState, Error>

Returns an error.

fn serialize_tuple_variant_elt<T>(&mut self,
                                  _state: &mut TupleVariantState,
                                  _value: T)
                                  -> Result<(), Error> where T: Serialize

Returns an error.

fn serialize_tuple_variant_end(&mut self,
                               _state: TupleVariantState)
                               -> Result<(), Error>

Returns an error.

fn serialize_map(&mut self, _len: Option<usize>) -> Result<MapState, Error>

Begins to serialize a map, given length (if any) is ignored.

fn serialize_map_key<T>(&mut self,
                        state: &mut MapState,
                        key: T)
                        -> Result<(), Error> where T: Serialize

Serializes a map key.

fn serialize_map_value<T>(&mut self,
                          state: &mut MapState,
                          value: T)
                          -> Result<(), Error> where T: Serialize

Serializes a map value.

fn serialize_map_end(&mut self, _state: MapState) -> Result<(), Error>

Finishes serializing a map.

fn serialize_struct(&mut self,
                    _name: &'static str,
                    _len: usize)
                    -> Result<StructState, Error>

Begins to serialize a struct, given length is ignored.

fn serialize_struct_elt<T>(&mut self,
                           _state: &mut StructState,
                           key: &'static str,
                           value: T)
                           -> Result<(), Error> where T: Serialize

Serializes a struct element.

fn serialize_struct_end(&mut self, _state: StructState) -> Result<(), Error>

Finishes serializing a struct.

fn serialize_struct_variant(&mut self,
                            _name: &'static str,
                            _variant_index: usize,
                            _variant: &'static str,
                            _len: usize)
                            -> Result<StructVariantState, Error>

Returns an error.

fn serialize_struct_variant_elt<T>(&mut self,
                                   _state: &mut StructVariantState,
                                   _key: &'static str,
                                   _value: T)
                                   -> Result<(), Error>

Returns an error.

fn serialize_struct_variant_end(&mut self,
                                _state: StructVariantState)
                                -> Result<(), Error>

Returns an error.