# Trait serde::ser::Serializer [−] [src]

    pub trait Serializer: Sized {
        type Ok;
        type Error: Error;
        type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
        type SerializeTuple: SerializeTuple<Ok = Self::Ok, Error = Self::Error>;
        type SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error = Self::Error>;
        type SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error = Self::Error>;
        type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
        type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>;
        type SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok, Error = Self::Error>;
        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>;
        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;
        fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
        fn serialize_some<T: ?Sized>(
            self,
            value: &T
        ) -> Result<Self::Ok, Self::Error>
        where
            T: Serialize;
        fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
        fn serialize_unit_struct(
            self,
            name: &'static str
        ) -> Result<Self::Ok, Self::Error>;
        fn serialize_unit_variant(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str
        ) -> Result<Self::Ok, Self::Error>;
        fn serialize_newtype_struct<T: ?Sized>(
            self,
            name: &'static str,
            value: &T
        ) -> Result<Self::Ok, Self::Error>
        where
            T: Serialize;
        fn serialize_newtype_variant<T: ?Sized>(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
            value: &T
        ) -> Result<Self::Ok, Self::Error>
        where
            T: Serialize;
        fn serialize_seq(
            self,
            len: Option<usize>
        ) -> Result<Self::SerializeSeq, Self::Error>;
        fn serialize_tuple(
            self,
            len: usize
        ) -> Result<Self::SerializeTuple, Self::Error>;
        fn serialize_tuple_struct(
            self,
            name: &'static str,
            len: usize
        ) -> Result<Self::SerializeTupleStruct, Self::Error>;
        fn serialize_tuple_variant(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
            len: usize
        ) -> Result<Self::SerializeTupleVariant, Self::Error>;
        fn serialize_map(
            self,
            len: Option<usize>
        ) -> Result<Self::SerializeMap, Self::Error>;
        fn serialize_struct(
            self,
            name: &'static str,
            len: usize
        ) -> Result<Self::SerializeStruct, Self::Error>;
        fn serialize_struct_variant(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
            len: usize
        ) -> Result<Self::SerializeStructVariant, Self::Error>;

        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> { ... }
        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> { ... }
        fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
        where
            I: IntoIterator,
            <I as IntoIterator>::Item: Serialize,
        { ... }
        fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
        where
            K: Serialize,
            V: Serialize,
            I: IntoIterator<Item = (K, V)>,
        { ... }
        fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
        where
            T: Display,
        { ... }
        fn is_human_readable(&self) -> bool { ... }
    }

A data format that can serialize any data structure supported by Serde.

The role of this trait is to define the serialization half of the Serde data model, which is a way to categorize every Rust data structure into one of 29 possible types. Each method of the `Serializer` trait corresponds to one of the types of the data model.

Implementations of `Serialize` map themselves into this data model by invoking exactly one of the `Serializer` methods.

The types that make up the Serde data model are:

- 14 primitive types
  - bool
  - i8, i16, i32, i64, i128
  - u8, u16, u32, u64, u128
  - f32, f64
  - char
- string
  - UTF-8 bytes with a length and no null terminator.
  - When serializing, all strings are handled equally. When deserializing, there are three flavors of strings: transient, owned, and borrowed.
- byte array - [u8]
  - Similar to strings, during deserialization byte arrays can be transient, owned, or borrowed.
- option
  - Either none or some value.
- unit
  - The type of `()` in Rust. It represents an anonymous value containing no data.
- unit_struct
  - For example `struct Unit` or `PhantomData<T>`. It represents a named value containing no data.
- unit_variant
  - For example the `E::A` and `E::B` in `enum E { A, B }`.
- newtype_struct
  - For example `struct Millimeters(u8)`.
- newtype_variant
  - For example the `E::N` in `enum E { N(u8) }`.
- seq
  - A variably sized heterogeneous sequence of values, for example `Vec<T>` or `HashSet<T>`. When serializing, the length may or may not be known before iterating through all the data. When deserializing, the length is determined by looking at the serialized data.
- tuple
  - A statically sized heterogeneous sequence of values for which the length will be known at deserialization time without looking at the serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or `[u64; 10]`.
- tuple_struct
  - A named tuple, for example `struct Rgb(u8, u8, u8)`.
- tuple_variant
  - For example the `E::T` in `enum E { T(u8, u8) }`.
- map
  - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
- struct
  - A heterogeneous key-value pairing in which the keys are strings and will be known at deserialization time without looking at the serialized data, for example `struct S { r: u8, g: u8, b: u8 }`.
- struct_variant
  - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.

Many Serde serializers produce text or binary data as output, for example JSON or Bincode. This is not a requirement of the `Serializer` trait, and there are serializers that do not produce text or binary output. One example is the `serde_json::value::Serializer` (distinct from the main `serde_json` serializer) that produces a `serde_json::Value` data structure in memory as output.

# Example implementation

The example data format presented on the website contains example code for a basic JSON `Serializer`.

## Associated Types

### `type Ok` [src]

The output type produced by this `Serializer` during successful serialization. Most serializers that produce text or binary output should set `Ok = ()` and serialize into an `io::Write` or buffer contained within the `Serializer` instance. Serializers that build in-memory data structures may be simplified by using `Ok` to propagate the data structure around.

### `type Error: Error` [src]

The error type when some error occurs during serialization.

### `type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_seq` for serializing the content of the sequence.

### `type SerializeTuple: SerializeTuple<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_tuple` for serializing the content of the tuple.

### `type SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_tuple_struct` for serializing the content of the tuple struct.

### `type SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_tuple_variant` for serializing the content of the tuple variant.

### `type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_map` for serializing the content of the map.

### `type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_struct` for serializing the content of the struct.

### `type SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok, Error = Self::Error>` [src]

Type returned from `serialize_struct_variant` for serializing the content of the struct variant.

Loading content...

## Required methods

### `fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `bool` value.

ⓘ

    impl Serialize for bool {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_bool(*self)
        }
    }

### `fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `i8` value.

If the format does not differentiate between `i8` and `i64`, a reasonable implementation would be to cast the value to `i64` and forward to `serialize_i64`.

ⓘ

    impl Serialize for i8 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_i8(*self)
        }
    }

### `fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `i16` value.

If the format does not differentiate between `i16` and `i64`, a reasonable implementation would be to cast the value to `i64` and forward to `serialize_i64`.

ⓘ

    impl Serialize for i16 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_i16(*self)
        }
    }

### `fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `i32` value.

If the format does not differentiate between `i32` and `i64`, a reasonable implementation would be to cast the value to `i64` and forward to `serialize_i64`.

ⓘ

    impl Serialize for i32 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_i32(*self)
        }
    }

### `fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `i64` value.

ⓘ

    impl Serialize for i64 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_i64(*self)
        }
    }

### `fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `u8` value.

If the format does not differentiate between `u8` and `u64`, a reasonable implementation would be to cast the value to `u64` and forward to `serialize_u64`.

ⓘ

    impl Serialize for u8 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_u8(*self)
        }
    }

### `fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `u16` value.

If the format does not differentiate between `u16` and `u64`, a reasonable implementation would be to cast the value to `u64` and forward to `serialize_u64`.

ⓘ

    impl Serialize for u16 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_u16(*self)
        }
    }

### `fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `u32` value.

If the format does not differentiate between `u32` and `u64`, a reasonable implementation would be to cast the value to `u64` and forward to `serialize_u64`.

ⓘ

    impl Serialize for u32 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_u32(*self)
        }
    }

### `fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `u64` value.

ⓘ

    impl Serialize for u64 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_u64(*self)
        }
    }

### `fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `f32` value.

If the format does not differentiate between `f32` and `f64`, a reasonable implementation would be to cast the value to `f64` and forward to `serialize_f64`.

ⓘ

    impl Serialize for f32 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_f32(*self)
        }
    }

### `fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `f64` value.

ⓘ

    impl Serialize for f64 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_f64(*self)
        }
    }

### `fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>` [src]

Serialize a character.

If the format does not support characters, it is reasonable to serialize it as a single element `str` or a `u32`.

ⓘ

    impl Serialize for char {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_char(*self)
        }
    }

### `fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `&str`.

ⓘ

    impl Serialize for str {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_str(self)
        }
    }

### `fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>` [src]

Serialize a chunk of raw byte data.

Enables serializers to serialize byte slices more compactly or more efficiently than other types of slices. If no efficient implementation is available, a reasonable implementation would be to forward to `serialize_seq`. If forwarded, the implementation looks usually just like this:

ⓘ

    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        let mut seq = self.serialize_seq(Some(v.len()))?;
        for b in v {
            seq.serialize_element(b)?;
        }
        seq.end()
    }

### `fn serialize_none(self) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `None` value.

ⓘ

    impl<T> Serialize for Option<T>
    where
        T: Serialize,
    {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match *self {
                Some(ref value) => serializer.serialize_some(value),
                None => serializer.serialize_none(),
            }
        }
    }

### `fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Serialize,` [src]

Serialize a `Some(T)` value.

ⓘ

    impl<T> Serialize for Option<T>
    where
        T: Serialize,
    {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match *self {
                Some(ref value) => serializer.serialize_some(value),
                None => serializer.serialize_none(),
            }
        }
    }

### `fn serialize_unit(self) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `()` value.

ⓘ

    impl Serialize for () {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_unit()
        }
    }

### `fn serialize_unit_struct(
self,
name: &'static str
) -> Result<Self::Ok, Self::Error>` [src]

Serialize a unit struct like `struct Unit` or `PhantomData<T>`.

A reasonable implementation would be to forward to `serialize_unit`.

ⓘ

    use serde::{Serialize, Serializer};

    struct Nothing;

    impl Serialize for Nothing {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_unit_struct("Nothing")
        }
    }

### `fn serialize_unit_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str
) -> Result<Self::Ok, Self::Error>` [src]

Serialize a unit variant like `E::A` in `enum E { A, B }`.

The `name` is the name of the enum, the `variant_index` is the index of this variant within the enum, and the `variant` is the name of the variant.

ⓘ

    use serde::{Serialize, Serializer};

    enum E {
        A,
        B,
    }

    impl Serialize for E {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match *self {
                E::A => serializer.serialize_unit_variant("E", 0, "A"),
                E::B => serializer.serialize_unit_variant("E", 1, "B"),
            }
        }
    }

### `fn serialize_newtype_struct<T: ?Sized>(
self,
name: &'static str,
value: &T
) -> Result<Self::Ok, Self::Error> where
T: Serialize,` [src]

Serialize a newtype struct like `struct Millimeters(u8)`.

Serializers are encouraged to treat newtype structs as insignificant wrappers around the data they contain. A reasonable implementation would be to forward to `value.serialize(self)`.

ⓘ

    use serde::{Serialize, Serializer};

    struct Millimeters(u8);

    impl Serialize for Millimeters {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_newtype_struct("Millimeters", &self.0)
        }
    }

### `fn serialize_newtype_variant<T: ?Sized>(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
value: &T
) -> Result<Self::Ok, Self::Error> where
T: Serialize,` [src]

Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.

The `name` is the name of the enum, the `variant_index` is the index of this variant within the enum, and the `variant` is the name of the variant. The `value` is the data contained within this newtype variant.

ⓘ

    use serde::{Serialize, Serializer};

    enum E {
        M(String),
        N(u8),
    }

    impl Serialize for E {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match *self {
                E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
                E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),
            }
        }
    }

### `fn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Self::Error>` [src]

Begin to serialize a variably sized sequence. This call must be followed by zero or more calls to `serialize_element`, then a call to `end`.

The argument is the number of elements in the sequence, which may or may not be computable before the sequence is iterated. Some serializers only support sequences whose length is known up front.

ⓘ

    use serde::ser::{Serialize, Serializer, SerializeSeq};

    impl<T> Serialize for Vec<T>
    where
        T: Serialize,
    {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut seq = serializer.serialize_seq(Some(self.len()))?;
            for element in self {
                seq.serialize_element(element)?;
            }
            seq.end()
        }
    }

### `fn serialize_tuple(
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>` [src]

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to `serialize_element`, then a call to `end`.

ⓘ

    use serde::ser::{Serialize, Serializer, SerializeTuple};

    impl<A, B, C> Serialize for (A, B, C)
    where
        A: Serialize,
        B: Serialize,
        C: Serialize,
    {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut tup = serializer.serialize_tuple(3)?;
            tup.serialize_element(&self.0)?;
            tup.serialize_element(&self.1)?;
            tup.serialize_element(&self.2)?;
            tup.end()
        }
    }

ⓘ

    use serde::ser::{Serialize, SerializeTuple, Serializer};

    const VRAM_SIZE: usize = 386;
    struct Vram([u16; VRAM_SIZE]);

    impl Serialize for Vram {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;
            for element in &self.0[..] {
                seq.serialize_element(element)?;
            }
            seq.end()
        }
    }

### `fn serialize_tuple_struct(
self,
name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>` [src]

Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`.

The `name` is the name of the tuple struct and the `len` is the number of data fields that will be serialized.

ⓘ

    use serde::ser::{Serialize, SerializeTupleStruct, Serializer};

    struct Rgb(u8, u8, u8);

    impl Serialize for Rgb {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
            ts.serialize_field(&self.0)?;
            ts.serialize_field(&self.1)?;
            ts.serialize_field(&self.2)?;
            ts.end()
        }
    }

### `fn serialize_tuple_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Self::Error>` [src]

Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8) }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`.

The `name` is the name of the enum, the `variant_index` is the index of this variant within the enum, the `variant` is the name of the variant, and the `len` is the number of data fields that will be serialized.

ⓘ

    use serde::ser::{Serialize, SerializeTupleVariant, Serializer};

    enum E {
        T(u8, u8),
        U(String, u32, u32),
    }

    impl Serialize for E {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match *self {
                E::T(ref a, ref b) => {
                    let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
                    tv.serialize_field(a)?;
                    tv.serialize_field(b)?;
                    tv.end()
                }
                E::U(ref a, ref b, ref c) => {
                    let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
                    tv.serialize_field(a)?;
                    tv.serialize_field(b)?;
                    tv.serialize_field(c)?;
                    tv.end()
                }
            }
        }
    }

### `fn serialize_map(
self,
len: Option<usize>
) -> Result<Self::SerializeMap, Self::Error>` [src]

Begin to serialize a map. This call must be followed by zero or more calls to `serialize_key` and `serialize_value`, then a call to `end`.

The argument is the number of elements in the map, which may or may not be computable before the map is iterated. Some serializers only support maps whose length is known up front.

ⓘ

    use serde::ser::{Serialize, Serializer, SerializeMap};

    impl<K, V> Serialize for HashMap<K, V>
    where
        K: Serialize,
        V: Serialize,
    {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut map = serializer.serialize_map(Some(self.len()))?;
            for (k, v) in self {
                map.serialize_entry(k, v)?;
            }
            map.end()
        }
    }

### `fn serialize_struct(
self,
name: &'static str,
len: usize
) -> Result<Self::SerializeStruct, Self::Error>` [src]

Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`.

The `name` is the name of the struct and the `len` is the number of data fields that will be serialized.

ⓘ

    use serde::ser::{Serialize, SerializeStruct, Serializer};

    struct Rgb {
        r: u8,
        g: u8,
        b: u8,
    }

    impl Serialize for Rgb {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut rgb = serializer.serialize_struct("Rgb", 3)?;
            rgb.serialize_field("r", &self.r)?;
            rgb.serialize_field("g", &self.g)?;
            rgb.serialize_field("b", &self.b)?;
            rgb.end()
        }
    }

### `fn serialize_struct_variant(
self,
name: &'static str,
variant_index: u32,
variant: &'static str,
len: usize
) -> Result<Self::SerializeStructVariant, Self::Error>` [src]

Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`. This call must be followed by zero or more calls to `serialize_field`, then a call to `end`.

The `name` is the name of the enum, the `variant_index` is the index of this variant within the enum, the `variant` is the name of the variant, and the `len` is the number of data fields that will be serialized.

ⓘ

    use serde::ser::{Serialize, SerializeStructVariant, Serializer};

    enum E {
        S { r: u8, g: u8, b: u8 },
    }

    impl Serialize for E {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            match *self {
                E::S {
                    ref r,
                    ref g,
                    ref b,
                } => {
                    let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
                    sv.serialize_field("r", r)?;
                    sv.serialize_field("g", g)?;
                    sv.serialize_field("b", b)?;
                    sv.end()
                }
            }
        }
    }

Loading content...

## Provided methods

### `fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>` [src]

Serialize an `i128` value.

ⓘ

    impl Serialize for i128 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_i128(*self)
        }
    }

This method is available only on Rust compiler versions >=1.26. The default behavior unconditionally returns an error.

### `fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>` [src]

Serialize a `u128` value.

ⓘ

    impl Serialize for u128 {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.serialize_u128(*self)
        }
    }

This method is available only on Rust compiler versions >=1.26. The default behavior unconditionally returns an error.

### `fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,` [src]

Collect an iterator as a sequence.

The default implementation serializes each item yielded by the iterator using `serialize_seq`. Implementors should not need to override this method.

ⓘ

    use serde::{Serialize, Serializer};

    struct SecretlyOneHigher {
        data: Vec<i32>,
    }

    impl Serialize for SecretlyOneHigher {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.collect_seq(self.data.iter().map(|x| x + 1))
        }
    }

### `fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
K: Serialize,
V: Serialize,
I: IntoIterator<Item = (K, V)>,` [src]

Collect an iterator as a map.

The default implementation serializes each pair yielded by the iterator using `serialize_map`. Implementors should not need to override this method.

ⓘ

    use serde::{Serialize, Serializer};
    use std::collections::BTreeSet;

    struct MapToUnit {
        keys: BTreeSet<i32>,
    }

    // Serializes as a map in which the values are all unit.
    impl Serialize for MapToUnit {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.collect_map(self.keys.iter().map(|k| (k, ())))
        }
    }

### `fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display,` [src]

Serialize a string produced by an implementation of `Display`.

The default implementation builds a heap-allocated `String` and delegates to `serialize_str`. Serializers are encouraged to provide a more efficient implementation if possible.

ⓘ

    use serde::{Serialize, Serializer};

    impl Serialize for DateTime {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            serializer.collect_str(&format_args!("{:?}{:?}",
                                                 self.naive_local(),
                                                 self.offset()))
        }
    }

### `fn is_human_readable(&self) -> bool` [src]

Determine whether `Serialize` implementations should serialize in human-readable form.

Some types have a human-readable form that may be somewhat expensive to construct, as well as a binary form that is compact and efficient. Generally text-based formats like JSON and YAML will prefer to use the human-readable one and binary formats like Bincode will prefer the compact one.

ⓘ

    use serde::{Serialize, Serializer};

    impl Serialize for Timestamp {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            if serializer.is_human_readable() {
                // Serialize to a human-readable string "2015-05-15T17:01:00Z".
                self.to_string().serialize(serializer)
            } else {
                // Serialize to a compact binary representation.
                self.seconds_since_epoch().serialize(serializer)
            }
        }
    }

The default implementation of this method returns `true`. Data formats may override this to `false` to request a compact form for types that support one. Note that modifying this method to change a format from human-readable to compact or vice versa should be regarded as a breaking change, as a value serialized in human-readable mode is not required to deserialize from the same data in compact mode.

Loading content...

## Implementations on Foreign Types

### `impl<'a, 'b> Serializer for &'a mut Formatter<'b>` [src]

ⓘ

    use serde::Serialize;
    use std::fmt::{self, Display};

    #[derive(Serialize)]
    #[serde(rename_all = "kebab-case")]
    pub enum MessageType {
        StartRequest,
        EndRequest,
    }

    impl Display for MessageType {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            self.serialize(f)
        }
    }

#### `type Ok = ()`

#### `type Error = Error`

#### `type SerializeSeq = Impossible<(), Error>`

#### `type SerializeTuple = Impossible<(), Error>`

#### `type SerializeTupleStruct = Impossible<(), Error>`

#### `type SerializeTupleVariant = Impossible<(), Error>`

#### `type SerializeMap = Impossible<(), Error>`

#### `type SerializeStruct = Impossible<(), Error>`

#### `type SerializeStructVariant = Impossible<(), Error>`

#### `fn serialize_bool(self, v: bool) -> Result` [src]

#### `fn serialize_i8(self, v: i8) -> Result` [src]

#### `fn serialize_i16(self, v: i16) -> Result` [src]

#### `fn serialize_i32(self, v: i32) -> Result` [src]

#### `fn serialize_i64(self, v: i64) -> Result` [src]

#### `fn serialize_u8(self, v: u8) -> Result` [src]

#### `fn serialize_u16(self, v: u16) -> Result` [src]

#### `fn serialize_u32(self, v: u32) -> Result` [src]

#### `fn serialize_u64(self, v: u64) -> Result` [src]

#### `fn serialize_f32(self, v: f32) -> Result` [src]

#### `fn serialize_f64(self, v: f64) -> Result` [src]

#### `fn serialize_char(self, v: char) -> Result` [src]

#### `fn serialize_str(self, v: &str) -> Result` [src]

#### `fn serialize_unit_struct(self, v: &'static str) -> Result` [src]

#### `fn serialize_i128(self, v: i128) -> Result` [src]

#### `fn serialize_u128(self, v: u128) -> Result` [src]

#### `fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result` [src]

#### `fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result where
T: Serialize,` [src]

#### `fn serialize_bytes(self, _v: &[u8]) -> Result` [src]

#### `fn serialize_none(self) -> Result` [src]

#### `fn serialize_some<T: ?Sized>(self, _value: &T) -> Result where
T: Serialize,` [src]

#### `fn serialize_unit(self) -> Result` [src]

#### `fn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T
) -> Result where
T: Serialize,` [src]

#### `fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error>` [src]

#### `fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error>` [src]

#### `fn serialize_tuple_struct(
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeTupleStruct, Error>` [src]

#### `fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeTupleVariant, Error>` [src]

#### `fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error>` [src]

#### `fn serialize_struct(
self,
_name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct, Error>` [src]

#### `fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant, Error>` [src]

#### `fn collect_str<T: ?Sized>(self, value: &T) -> Result where
T: Display,` [src]

Loading content...

## Implementors

Loading content...