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
sourceimpl<'a> Serializer<'a>
impl<'a> Serializer<'a>
sourcepub fn new(dst: &'a mut String) -> 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
.
sourcepub fn pretty(dst: &'a mut String) -> Serializer<'a>
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. SeeSerializer::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
sourcepub fn pretty_string(&mut self, value: bool) -> &mut Self
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
'''
sourcepub fn pretty_string_literal(&mut self, value: bool) -> &mut Self
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
"""
sourcepub fn pretty_array(&mut self, value: bool) -> &mut Self
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",
]
sourcepub fn pretty_array_indent(&mut self, value: usize) -> &mut Self
pub fn pretty_array_indent(&mut self, value: usize) -> &mut Self
Set the indent for pretty arrays
See Serializer::pretty_array
for more details.
sourcepub fn pretty_array_trailing_comma(&mut self, value: bool) -> &mut Self
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
sourceimpl<'a, 'b> Serializer for &'b mut Serializer<'a>
impl<'a, 'b> Serializer for &'b mut Serializer<'a>
type Ok = ()
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 SerializeSeq = SerializeSeq<'a, 'b>
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 SerializeTuple = SerializeSeq<'a, 'b>
Type returned from serialize_tuple
for serializing the content of
the tuple. Read more
type SerializeTupleStruct = SerializeSeq<'a, 'b>
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 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 SerializeMap = SerializeTable<'a, 'b>
Type returned from serialize_map
for serializing the content of the
map. Read more
type SerializeStruct = SerializeTable<'a, 'b>
type SerializeStruct = SerializeTable<'a, 'b>
Type returned from serialize_struct
for serializing the content of
the struct. Read more
type SerializeStructVariant = Impossible<(), Error>
type SerializeStructVariant = Impossible<(), Error>
Type returned from serialize_struct_variant
for serializing the
content of the struct variant. Read more
sourcefn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error>
fn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error>
Serialize a chunk of raw byte data. Read more
sourcefn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error>
fn serialize_unit_struct(self, _name: &'static str) -> Result<(), Self::Error>
Serialize a unit struct like struct Unit
or PhantomData<T>
. Read more
sourcefn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
) -> Result<(), Self::Error>
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
sourcefn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
) -> Result<(), Self::Error> where
T: Serialize,
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
sourcefn serialize_newtype_variant<T: ?Sized>(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_value: &T
) -> Result<(), 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::Error> where
T: Serialize,
Serialize a newtype variant like E::N
in enum E { N(u8) }
. Read more
sourcefn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Self::Error>
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
sourcefn serialize_tuple(
self,
len: usize
) -> Result<Self::SerializeTuple, Self::Error>
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
sourcefn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
) -> Result<Self::SerializeTupleStruct, Self::Error>
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
sourcefn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
len: usize
) -> Result<Self::SerializeTupleVariant, Self::Error>
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
sourcefn serialize_map(
self,
_len: Option<usize>
) -> Result<Self::SerializeMap, Self::Error>
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
sourcefn serialize_struct(
self,
name: &'static str,
_len: usize
) -> Result<Self::SerializeStruct, Self::Error>
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
sourcefn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
_variant: &'static str,
_len: usize
) -> Result<Self::SerializeStructVariant, Self::Error>
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
sourcefn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>
fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>
Serialize an i128
value. Read more
sourcefn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>
fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>
Serialize a u128
value. Read more
sourcefn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
I: IntoIterator,
<I as IntoIterator>::Item: Serialize,
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
sourcefn 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_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
sourcefn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where
T: Display + ?Sized,
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
sourcefn is_human_readable(&self) -> bool
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
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more