toml 1.1.2+spec-1.1.0

A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use core::fmt::Write as _;

use toml_writer::TomlWrite as _;

use super::Buffer;
use super::Error;
use super::Table;
use super::style::Style;
use super::value::ValueSerializer;

#[doc(hidden)]
pub struct SerializeDocumentTupleVariant<'d> {
    buf: &'d mut Buffer,
    table: Table,
    seen_value: bool,
    style: Style,
}

impl<'d> SerializeDocumentTupleVariant<'d> {
    pub(crate) fn tuple(
        buf: &'d mut Buffer,
        mut table: Table,
        variant: &'static str,
        _len: usize,
        style: Style,
    ) -> Result<Self, Error> {
        let dst = table.body_mut();
        dst.key(variant)?;
        dst.space()?;
        dst.keyval_sep()?;
        dst.space()?;
        dst.open_array()?;
        Ok(Self {
            buf,
            table,
            seen_value: false,
            style,
        })
    }
}

impl<'d> serde_core::ser::SerializeTupleVariant for SerializeDocumentTupleVariant<'d> {
    type Ok = &'d mut Buffer;
    type Error = Error;

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
    where
        T: serde_core::ser::Serialize + ?Sized,
    {
        let dst = self.table.body_mut();

        if self.style.multiline_array {
            dst.newline()?;
            write!(dst, "    ")?;
        } else {
            if self.seen_value {
                dst.val_sep()?;
                dst.space()?;
            }
        }
        self.seen_value = true;
        value.serialize(ValueSerializer::with_style(dst, self.style))?;
        if self.style.multiline_array {
            dst.val_sep()?;
        }
        Ok(())
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        let dst = self.table.body_mut();
        if self.style.multiline_array && self.seen_value {
            dst.newline()?;
        }
        dst.close_array()?;
        dst.newline()?;
        self.buf.push(self.table);
        Ok(self.buf)
    }
}