Struct ValueSerializer

#[non_exhaustive]
pub struct ValueSerializer {}

Available on crate feature dep_toml_edit only.

Serialization for TOML values.

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.

Examples

use serde::Serialize;

#[derive(Serialize)]
struct Config {
    database: Database,
}

#[derive(Serialize)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

let config = Config {
    database: Database {
        ip: "192.168.1.1".to_string(),
        port: vec![8001, 8002, 8003],
        connection_max: 5000,
        enabled: false,
    },
};

let value = serde::Serialize::serialize(
    &config,
    toml_edit::ser::ValueSerializer::new()
).unwrap();
println!("{}", value)

Implementations

impl ValueSerializer

pub fn new() -> ValueSerializer

Creates a new serializer generate a TOML document.

Trait Implementations

impl Default for ValueSerializer

fn default() -> ValueSerializer

Returns the “default value” for a type.

impl Serializer for ValueSerializer

type Ok = Value

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 = SerializeValueArray

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

type SerializeTuple = SerializeValueArray

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

type SerializeTupleStruct = SerializeValueArray

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

type SerializeTupleVariant = SerializeVariant<SerializeValueArray>

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

type SerializeMap = SerializeMap

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

type SerializeStruct = SerializeMap

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

type SerializeStructVariant = SerializeVariant<SerializeMap>

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

fn serialize_bool( self, v: bool, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a bool value.

fn serialize_i8( self, v: i8, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize an i8 value.

fn serialize_i16( self, v: i16, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize an i16 value.

fn serialize_i32( self, v: i32, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize an i32 value.

fn serialize_i64( self, v: i64, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize an i64 value.

fn serialize_u8( self, v: u8, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a u8 value.

fn serialize_u16( self, v: u16, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a u16 value.

fn serialize_u32( self, v: u32, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a u32 value.

fn serialize_u64( self, v: u64, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a u64 value.

fn serialize_f32( self, v: f32, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize an f32 value.

fn serialize_f64( self, v: f64, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize an f64 value.

fn serialize_char( self, v: char, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a character.

fn serialize_str( self, v: &str, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a &str.

fn serialize_bytes( self, value: &[u8], ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a chunk of raw byte data.

fn serialize_none( self, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a None value.

fn serialize_some<T>( self, value: &T, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

where T: Serialize + ?Sized,

Serialize a Some(T) value.

fn serialize_unit( self, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer as Serializer>::Error>

Serialize a () value.

fn serialize_unit_struct( self, name: &'static str, ) -> Result<<ValueSerializer as Serializer>::Ok, <ValueSerializer 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<<ValueSerializer as Serializer>::Ok, <ValueSerializer 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<<ValueSerializer as Serializer>::Ok, <ValueSerializer 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<<ValueSerializer as Serializer>::Ok, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeSeq, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeTuple, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeTupleStruct, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeTupleVariant, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeMap, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeStruct, <ValueSerializer 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<<ValueSerializer as Serializer>::SerializeStructVariant, <ValueSerializer 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.