[][src]Struct toml::ser::Serializer

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

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.

Methods

impl<'a> Serializer<'a>
[src]

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

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.

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

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

pub fn pretty_string(&mut self, value: bool) -> &mut Self
[src]

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
'''

pub fn pretty_string_literal(&mut self, value: bool) -> &mut Self
[src]

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
"""

pub fn pretty_array(&mut self, value: bool) -> &mut Self
[src]

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",
]

pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self
[src]

Set the indent for pretty arrays

See Serializer::pretty_array for more details.

pub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self
[src]

Specify whether to use a trailing comma when serializing pretty arrays

See Serializer::pretty_array for more details.

Trait Implementations

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

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

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

Serialize an i128 value. Read more

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

Serialize a u128 value. Read more

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

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

Collect an iterator as a map. Read more

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

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

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

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

Auto Trait Implementations

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

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

Blanket Implementations

impl<T> From for T
[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom for T where
    T: From<U>, 
[src]

type Error = !

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

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

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]