Struct `ValueSerializer`

pub struct ValueSerializer<'d> { /* private fields */ }

Serialization for TOML [values][crate::Value].

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 mut value = String::new();
serde::Serialize::serialize(
    &config,
    toml::ser::ValueSerializer::new(&mut value)
).unwrap();
println!("{}", value)

Implementations

`impl<'d> ValueSerializer<'d>`

fn new(dst: &'d mut String) -> Self

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.

Trait Implementations

`impl<'d> Serializer for ValueSerializer<'d>`

type Ok = &'d mut String;
type Error = Error;
type SerializeSeq = SerializeValueArray<'d>;
type SerializeTuple = SerializeValueArray<'d>;
type SerializeTupleStruct = SerializeValueArray<'d>;
type SerializeTupleVariant = SerializeTupleVariant<'d>;
type SerializeMap = SerializeMap<'d>;
type SerializeStruct = SerializeMap<'d>;
type SerializeStructVariant = SerializeStructVariant<'d>;
fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>
fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>
fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>
fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>
fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>
fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>
fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>
fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>
fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>
fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>
fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>
fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>
fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>
fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>
fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>
fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error>
fn serialize_none(self) -> Result<Self::Ok, Self::Error>
fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error> where T: Serialize + ?Sized,
fn serialize_unit(self) -> Result<Self::Ok, Self::Error>
fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error>
fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error>
fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> where T: Serialize + ?Sized,
fn serialize_newtype_variant<T>(self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> where T: Serialize + ?Sized,
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error>
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error>
fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error>
fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error>
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error>
fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error>
fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error>

Auto Trait Implementations

`impl<'d> !UnwindSafe for ValueSerializer<'d>`

`impl<'d> Freeze for ValueSerializer<'d>`

`impl<'d> RefUnwindSafe for ValueSerializer<'d>`

`impl<'d> Send for ValueSerializer<'d>`

`impl<'d> Sync for ValueSerializer<'d>`

`impl<'d> Unpin for ValueSerializer<'d>`

`impl<'d> UnsafeUnpin for ValueSerializer<'d>`

Blanket Implementations

`impl<T> Any for ValueSerializer<'d> where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for ValueSerializer<'d> where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for ValueSerializer<'d> where T: ?Sized,`

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

`impl<T> From<T> for ValueSerializer<'d>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for ValueSerializer<'d> where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

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

`impl<T, U> TryFrom for ValueSerializer<'d> where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for ValueSerializer<'d> where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>