Struct otter_api_tests::otter_support::crates::toml::ser::Serializer

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

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

impl<'a> Serializer<'a>

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.

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

pub fn pretty_string(&mut self, value: bool) -> &mut Serializer<'a>

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

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

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

Set the indent for pretty arrays

See Serializer::pretty_array for more details.

pub fn pretty_array_trailing_comma(
    &mut self,
    value: bool
) -> &mut Serializer<'a>

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>

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.

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.

type SerializeTuple = SerializeSeq<'a, 'b>

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

type SerializeTupleStruct = SerializeSeq<'a, 'b>

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

type SerializeTupleVariant = SerializeSeq<'a, 'b>

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

type SerializeMap = SerializeTable<'a, 'b>

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

type SerializeStruct = SerializeTable<'a, 'b>

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

type SerializeStructVariant = Impossible<(), Error>

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

fn serialize_bool(
    self,
    v: bool
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a bool value.

fn serialize_i8(
    self,
    v: i8
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize an i8 value.

fn serialize_i16(
    self,
    v: i16
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize an i16 value.

fn serialize_i32(
    self,
    v: i32
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize an i32 value.

fn serialize_i64(
    self,
    v: i64
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize an i64 value.

fn serialize_u8(
    self,
    v: u8
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a u8 value.

fn serialize_u16(
    self,
    v: u16
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a u16 value.

fn serialize_u32(
    self,
    v: u32
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a u32 value.

fn serialize_u64(
    self,
    v: u64
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a u64 value.

fn serialize_f32(
    self,
    v: f32
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize an f32 value.

fn serialize_f64(
    self,
    v: f64
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize an f64 value.

fn serialize_char(
    self,
    v: char
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a character.

fn serialize_str(
    self,
    value: &str
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a &str.

fn serialize_bytes(
    self,
    value: &[u8]
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a chunk of raw byte data.

fn serialize_none(
    self
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a None value.

fn serialize_some<T>(
    self,
    value: &T
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error> where
    T: Serialize + ?Sized, 

Serialize a Some(T) value.

fn serialize_unit(
    self
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

Serialize a () value.

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

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

fn serialize_unit_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error>

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

fn serialize_newtype_struct<T>(
    self,
    _name: &'static str,
    value: &T
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error> where
    T: Serialize + ?Sized, 

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_newtype_variant<T>(
    self,
    _name: &'static str,
    _variant_index: u32,
    _variant: &'static str,
    _value: &T
) -> Result<(), <&'b mut Serializer<'a> as Serializer>::Error> where
    T: Serialize + ?Sized, 

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

fn serialize_seq(
    self,
    len: Option<usize>
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeSeq, <&'b mut Serializer<'a> as Serializer>::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.

fn serialize_tuple(
    self,
    len: usize
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeTuple, <&'b mut Serializer<'a> as Serializer>::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.

fn serialize_tuple_struct(
    self,
    _name: &'static str,
    len: usize
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeTupleStruct, <&'b mut Serializer<'a> as Serializer>::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.

fn serialize_tuple_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    _variant: &'static str,
    len: usize
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeTupleVariant, <&'b mut Serializer<'a> as Serializer>::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.

fn serialize_map(
    self,
    _len: Option<usize>
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeMap, <&'b mut Serializer<'a> as Serializer>::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.

fn serialize_struct(
    self,
    name: &'static str,
    _len: usize
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeStruct, <&'b mut Serializer<'a> as Serializer>::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.

fn serialize_struct_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    _variant: &'static str,
    _len: usize
) -> Result<<&'b mut Serializer<'a> as Serializer>::SerializeStructVariant, <&'b mut Serializer<'a> as Serializer>::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.

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

Serialize an i128 value.

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

Serialize a u128 value.

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.

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.

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.

fn is_human_readable(&self) -> bool

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