# Struct toml::ser::Serializer

source · [−]

    pub struct Serializer<'a> { /* private fields */ }

Expand description

Serialization implementation for TOML.

This structure implements serialization support for TOML to serialize an arbitrary type to TOML. Note that the TOML format does not support all datatypes in Rust, such as enums, tuples, and tuple structs. These types will generate an error when serialized.

Currently a serializer always writes its output to an in-memory `String`, which is passed in when creating the serializer itself.

## Implementations

source

### impl<'a> Serializer<'a>

source

#### pub fn new(dst: &'a mut String) -> Serializer<'a>

Creates a new serializer which will emit TOML into the buffer provided.

The serializer can then be used to serialize a type after which the data will be present in `dst`.

source

#### pub fn pretty(dst: &'a mut String) -> Serializer<'a>

Instantiate a “pretty” formatter

By default this will use:

- pretty strings: strings with newlines will use the `'''` syntax. See `Serializer::pretty_string`
- pretty arrays: each item in arrays will be on a newline, have an indentation of 4 and have a trailing comma. See `Serializer::pretty_array`

source

#### pub fn pretty_string(&mut self, value: bool) -> &mut Self

Enable or Disable pretty strings

If enabled, literal strings will be used when possible and strings with one or more newlines will use triple quotes (i.e.: `'''` or `"""`)

##### Examples

Instead of:

    single = "no newlines"
    text = "\nfoo\nbar\n"

You will have:

    single = 'no newlines'
    text = '''
    foo
    bar
    '''

source

#### pub fn pretty_string_literal(&mut self, value: bool) -> &mut Self

Enable or Disable Literal strings for pretty strings

If enabled, literal strings will be used when possible and strings with one or more newlines will use triple quotes (i.e.: `'''` or `"""`)

If disabled, literal strings will NEVER be used and strings with one or more newlines will use `"""`

##### Examples

Instead of:

    single = "no newlines"
    text = "\nfoo\nbar\n"

You will have:

    single = "no newlines"
    text = """
    foo
    bar
    """

source

#### pub fn pretty_array(&mut self, value: bool) -> &mut Self

Enable or Disable pretty arrays

If enabled, arrays will always have each item on their own line.

Some specific features can be controlled via other builder methods:

- `Serializer::pretty_array_indent`: set the indent to a value other than 4.
- `Serializer::pretty_array_trailing_comma`: enable/disable the trailing comma on the last item.

##### Examples

Instead of:

    array = ["foo", "bar"]

You will have:

    array = [
        "foo",
        "bar",
    ]

source

#### pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self

Set the indent for pretty arrays

See `Serializer::pretty_array` for more details.

source

#### pub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self

Specify whether to use a trailing comma when serializing pretty arrays

See `Serializer::pretty_array` for more details.

## Trait Implementations

source

### impl<'a, 'b> Serializer for &'b mut Serializer<'a>

#### type Ok = ()

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. Read more

#### type Error = Error

The error type when some error occurs during serialization.

#### type SerializeSeq = SerializeSeq<'a, 'b>

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

#### type SerializeTuple = SerializeSeq<'a, 'b>

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

#### type SerializeTupleStruct = SerializeSeq<'a, 'b>

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

#### type SerializeTupleVariant = SerializeSeq<'a, 'b>

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

#### type SerializeMap = SerializeTable<'a, 'b>

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

#### type SerializeStruct = SerializeTable<'a, 'b>

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

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

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

source

#### fn serialize_bool(self, v: bool) -> Result<(), Self::Error>

Serialize a `bool` value. Read more

source

#### fn serialize_i8(self, v: i8) -> Result<(), Self::Error>

Serialize an `i8` value. Read more

source

#### fn serialize_i16(self, v: i16) -> Result<(), Self::Error>

Serialize an `i16` value. Read more

source

#### fn serialize_i32(self, v: i32) -> Result<(), Self::Error>

Serialize an `i32` value. Read more

source

#### fn serialize_i64(self, v: i64) -> Result<(), Self::Error>

Serialize an `i64` value. Read more

source

#### fn serialize_u8(self, v: u8) -> Result<(), Self::Error>

Serialize a `u8` value. Read more

source

#### fn serialize_u16(self, v: u16) -> Result<(), Self::Error>

Serialize a `u16` value. Read more

source

#### fn serialize_u32(self, v: u32) -> Result<(), Self::Error>

Serialize a `u32` value. Read more

source

#### fn serialize_u64(self, v: u64) -> Result<(), Self::Error>

Serialize a `u64` value. Read more

source

#### fn serialize_f32(self, v: f32) -> Result<(), Self::Error>

Serialize an `f32` value. Read more

source

#### fn serialize_f64(self, v: f64) -> Result<(), Self::Error>

Serialize an `f64` value. Read more

source

#### fn serialize_char(self, v: char) -> Result<(), Self::Error>

Serialize a character. Read more

source

#### fn serialize_str(self, value: &str) -> Result<(), Self::Error>

Serialize a `&str`. Read more

source

#### fn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error>

Serialize a chunk of raw byte data. Read more

source

#### fn serialize_none(self) -> Result<(), Self::Error>

Serialize a `None` value. Read more

source

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

Serialize a `Some(T)` value. Read more

source

#### fn serialize_unit(self) -> Result<(), Self::Error>

Serialize a `()` value. Read more

source

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

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

source

#### fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result<(), Self::Error>

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

source

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

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

source

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

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

source

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

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`. Read more

source

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

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`. Read more

source

#### fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>

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`. Read more

source

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

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`. Read more

source

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

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`. Read more

source

#### fn serialize_struct(
self,
name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct, Self::Error>

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`. Read more

source

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

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`. Read more

source

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

Serialize an `i128` value. Read more

source

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

Serialize a `u128` value. Read more

source

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

Collect an iterator as a sequence. Read more

source

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

Collect an iterator as a map. Read more

source

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

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

source

#### fn is_human_readable(&self) -> bool

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

## Auto Trait Implementations

### impl<'a> !RefUnwindSafe for Serializer<'a>

### impl<'a> !Send for Serializer<'a>

### impl<'a> !Sync for Serializer<'a>

### impl<'a> Unpin for Serializer<'a>

### impl<'a> !UnwindSafe for Serializer<'a>

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.