toml/ser/document/
map.rs

1use core::fmt::Write as _;
2
3use toml_writer::TomlWrite as _;
4
5use super::array_of_tables::ArrayOfTablesSerializer;
6use super::style::Style;
7use super::value::KeySerializer;
8use super::value::ValueSerializer;
9use super::Buffer;
10use super::Error;
11use super::SerializationStrategy;
12use super::Serializer;
13use super::Table;
14use crate::alloc_prelude::*;
15
16#[doc(hidden)]
17pub struct SerializeDocumentTable<'d> {
18    buf: &'d mut Buffer,
19    table: Table,
20    key: Option<String>,
21    style: Style,
22}
23
24impl<'d> SerializeDocumentTable<'d> {
25    pub(crate) fn map(buf: &'d mut Buffer, table: Table, style: Style) -> Result<Self, Error> {
26        Ok(Self {
27            buf,
28            table,
29            key: None,
30            style,
31        })
32    }
33
34    fn end(self) -> Result<&'d mut Buffer, Error> {
35        self.buf.push(self.table);
36        Ok(self.buf)
37    }
38}
39
40impl<'d> serde::ser::SerializeMap for SerializeDocumentTable<'d> {
41    type Ok = &'d mut Buffer;
42    type Error = Error;
43
44    fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
45    where
46        T: serde::ser::Serialize + ?Sized,
47    {
48        let mut encoded_key = String::new();
49        input.serialize(KeySerializer {
50            dst: &mut encoded_key,
51        })?;
52        self.key = Some(encoded_key);
53        Ok(())
54    }
55
56    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
57    where
58        T: serde::ser::Serialize + ?Sized,
59    {
60        let encoded_key = self
61            .key
62            .take()
63            .expect("always called after `serialize_key`");
64        match SerializationStrategy::from(value) {
65            SerializationStrategy::Value => {
66                let dst = self.table.body_mut();
67
68                write!(dst, "{encoded_key}")?;
69                dst.space()?;
70                dst.keyval_sep()?;
71                dst.space()?;
72                let value_serializer = ValueSerializer::with_style(dst, self.style);
73                let dst = value.serialize(value_serializer)?;
74                dst.newline()?;
75            }
76            SerializationStrategy::ArrayOfTables => {
77                self.table.has_children(true);
78                let value_serializer = ArrayOfTablesSerializer::new(
79                    self.buf,
80                    self.table.clone(),
81                    encoded_key,
82                    self.style,
83                );
84                value.serialize(value_serializer)?;
85            }
86            SerializationStrategy::Table | SerializationStrategy::Unknown => {
87                let child = self.buf.child_table(&mut self.table, encoded_key);
88                let value_serializer = Serializer::with_table(self.buf, child, self.style);
89                value.serialize(value_serializer)?;
90            }
91            SerializationStrategy::Skip => {
92                // silently drop these key-value pairs
93            }
94        }
95        Ok(())
96    }
97
98    fn end(self) -> Result<Self::Ok, Self::Error> {
99        self.end()
100    }
101}
102
103impl<'d> serde::ser::SerializeStruct for SerializeDocumentTable<'d> {
104    type Ok = &'d mut Buffer;
105    type Error = Error;
106
107    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
108    where
109        T: serde::ser::Serialize + ?Sized,
110    {
111        match SerializationStrategy::from(value) {
112            SerializationStrategy::Value => {
113                let dst = self.table.body_mut();
114
115                dst.key(key)?;
116                dst.space()?;
117                dst.keyval_sep()?;
118                dst.space()?;
119                let value_serializer = ValueSerializer::with_style(dst, self.style);
120                let dst = value.serialize(value_serializer)?;
121                dst.newline()?;
122            }
123            SerializationStrategy::ArrayOfTables => {
124                self.table.has_children(true);
125                let value_serializer = ArrayOfTablesSerializer::new(
126                    self.buf,
127                    self.table.clone(),
128                    key.to_owned(),
129                    self.style,
130                );
131                value.serialize(value_serializer)?;
132            }
133            SerializationStrategy::Table | SerializationStrategy::Unknown => {
134                let child = self.buf.child_table(&mut self.table, key.to_owned());
135                let value_serializer = Serializer::with_table(self.buf, child, self.style);
136                value.serialize(value_serializer)?;
137            }
138            SerializationStrategy::Skip => {
139                // silently drop these key-value pairs
140            }
141        }
142
143        Ok(())
144    }
145
146    fn end(self) -> Result<Self::Ok, Self::Error> {
147        self.end()
148    }
149}
150
151impl<'d> serde::ser::SerializeStructVariant for SerializeDocumentTable<'d> {
152    type Ok = &'d mut Buffer;
153    type Error = Error;
154
155    #[inline]
156    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
157    where
158        T: serde::ser::Serialize + ?Sized,
159    {
160        serde::ser::SerializeStruct::serialize_field(self, key, value)
161    }
162
163    #[inline]
164    fn end(self) -> Result<Self::Ok, Self::Error> {
165        self.end()
166    }
167}
toml/ser/document/map.rs

toml/ser/document/
map.rs
