toml/ser/ser_value/
mod.rs

Help
1mod array;
2mod map;
3
4use super::Error;
5
6/// Serialization for TOML [values][crate::Value].
7///
8/// This structure implements serialization support for TOML to serialize an
9/// arbitrary type to TOML. Note that the TOML format does not support all
10/// datatypes in Rust, such as enums, tuples, and tuple structs. These types
11/// will generate an error when serialized.
12///
13/// Currently a serializer always writes its output to an in-memory `String`,
14/// which is passed in when creating the serializer itself.
15///
16/// # Examples
17///
18/// ```
19/// use serde::Serialize;
20///
21/// #[derive(Serialize)]
22/// struct Config {
23///     database: Database,
24/// }
25///
26/// #[derive(Serialize)]
27/// struct Database {
28///     ip: String,
29///     port: Vec<u16>,
30///     connection_max: u32,
31///     enabled: bool,
32/// }
33///
34/// let config = Config {
35///     database: Database {
36///         ip: "192.168.1.1".to_string(),
37///         port: vec![8001, 8002, 8003],
38///         connection_max: 5000,
39///         enabled: false,
40///     },
41/// };
42///
43/// let mut value = String::new();
44/// serde::Serialize::serialize(
45///     &config,
46///     toml::ser::ValueSerializer::new(&mut value)
47/// ).unwrap();
48/// println!("{}", value)
49/// ```
50#[cfg(feature = "display")]
51pub struct ValueSerializer<'d> {
52    dst: &'d mut String,
53}
54
55impl<'d> ValueSerializer<'d> {
56    /// Creates a new serializer which will emit TOML into the buffer provided.
57    ///
58    /// The serializer can then be used to serialize a type after which the data
59    /// will be present in `dst`.
60    pub fn new(dst: &'d mut String) -> Self {
61        Self { dst }
62    }
63}
64
65impl<'d> serde::ser::Serializer for ValueSerializer<'d> {
66    type Ok = ();
67    type Error = Error;
68    type SerializeSeq = array::SerializeValueArray<'d>;
69    type SerializeTuple = array::SerializeValueArray<'d>;
70    type SerializeTupleStruct = array::SerializeValueArray<'d>;
71    type SerializeTupleVariant = array::SerializeValueArray<'d>;
72    type SerializeMap = map::SerializeValueTable<'d>;
73    type SerializeStruct = map::SerializeValueTable<'d>;
74    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
75
76    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
77        write_value(
78            self.dst,
79            toml_edit::ser::ValueSerializer::new().serialize_bool(v),
80        )
81    }
82
83    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
84        write_value(
85            self.dst,
86            toml_edit::ser::ValueSerializer::new().serialize_i8(v),
87        )
88    }
89
90    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
91        write_value(
92            self.dst,
93            toml_edit::ser::ValueSerializer::new().serialize_i16(v),
94        )
95    }
96
97    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
98        write_value(
99            self.dst,
100            toml_edit::ser::ValueSerializer::new().serialize_i32(v),
101        )
102    }
103
104    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
105        write_value(
106            self.dst,
107            toml_edit::ser::ValueSerializer::new().serialize_i64(v),
108        )
109    }
110
111    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
112        write_value(
113            self.dst,
114            toml_edit::ser::ValueSerializer::new().serialize_u8(v),
115        )
116    }
117
118    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
119        write_value(
120            self.dst,
121            toml_edit::ser::ValueSerializer::new().serialize_u16(v),
122        )
123    }
124
125    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
126        write_value(
127            self.dst,
128            toml_edit::ser::ValueSerializer::new().serialize_u32(v),
129        )
130    }
131
132    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
133        write_value(
134            self.dst,
135            toml_edit::ser::ValueSerializer::new().serialize_u64(v),
136        )
137    }
138
139    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
140        write_value(
141            self.dst,
142            toml_edit::ser::ValueSerializer::new().serialize_f32(v),
143        )
144    }
145
146    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
147        write_value(
148            self.dst,
149            toml_edit::ser::ValueSerializer::new().serialize_f64(v),
150        )
151    }
152
153    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
154        write_value(
155            self.dst,
156            toml_edit::ser::ValueSerializer::new().serialize_char(v),
157        )
158    }
159
160    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
161        write_value(
162            self.dst,
163            toml_edit::ser::ValueSerializer::new().serialize_str(v),
164        )
165    }
166
167    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
168        write_value(
169            self.dst,
170            toml_edit::ser::ValueSerializer::new().serialize_bytes(v),
171        )
172    }
173
174    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
175        write_value(
176            self.dst,
177            toml_edit::ser::ValueSerializer::new().serialize_none(),
178        )
179    }
180
181    fn serialize_some<T>(self, v: &T) -> Result<Self::Ok, Self::Error>
182    where
183        T: serde::ser::Serialize + ?Sized,
184    {
185        write_value(
186            self.dst,
187            toml_edit::ser::ValueSerializer::new().serialize_some(v),
188        )
189    }
190
191    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
192        write_value(
193            self.dst,
194            toml_edit::ser::ValueSerializer::new().serialize_unit(),
195        )
196    }
197
198    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
199        write_value(
200            self.dst,
201            toml_edit::ser::ValueSerializer::new().serialize_unit_struct(name),
202        )
203    }
204
205    fn serialize_unit_variant(
206        self,
207        name: &'static str,
208        variant_index: u32,
209        variant: &'static str,
210    ) -> Result<Self::Ok, Self::Error> {
211        write_value(
212            self.dst,
213            toml_edit::ser::ValueSerializer::new().serialize_unit_variant(
214                name,
215                variant_index,
216                variant,
217            ),
218        )
219    }
220
221    fn serialize_newtype_struct<T>(self, name: &'static str, v: &T) -> Result<Self::Ok, Self::Error>
222    where
223        T: serde::ser::Serialize + ?Sized,
224    {
225        write_value(
226            self.dst,
227            toml_edit::ser::ValueSerializer::new().serialize_newtype_struct(name, v),
228        )
229    }
230
231    fn serialize_newtype_variant<T>(
232        self,
233        name: &'static str,
234        variant_index: u32,
235        variant: &'static str,
236        value: &T,
237    ) -> Result<Self::Ok, Self::Error>
238    where
239        T: serde::ser::Serialize + ?Sized,
240    {
241        write_value(
242            self.dst,
243            toml_edit::ser::ValueSerializer::new().serialize_newtype_variant(
244                name,
245                variant_index,
246                variant,
247                value,
248            ),
249        )
250    }
251
252    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
253        let ser = toml_edit::ser::ValueSerializer::new()
254            .serialize_seq(len)
255            .map_err(Error::wrap)?;
256        let ser = array::SerializeValueArray::new(self, ser);
257        Ok(ser)
258    }
259
260    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
261        self.serialize_seq(Some(len))
262    }
263
264    fn serialize_tuple_struct(
265        self,
266        _name: &'static str,
267        len: usize,
268    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
269        self.serialize_seq(Some(len))
270    }
271
272    fn serialize_tuple_variant(
273        self,
274        _name: &'static str,
275        _variant_index: u32,
276        _variant: &'static str,
277        len: usize,
278    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
279        self.serialize_seq(Some(len))
280    }
281
282    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
283        let ser = toml_edit::ser::ValueSerializer::new()
284            .serialize_map(len)
285            .map_err(Error::wrap)?;
286        let ser = map::SerializeValueTable::new(self, ser);
287        Ok(ser)
288    }
289
290    fn serialize_struct(
291        self,
292        _name: &'static str,
293        len: usize,
294    ) -> Result<Self::SerializeStruct, Self::Error> {
295        self.serialize_map(Some(len))
296    }
297
298    fn serialize_struct_variant(
299        self,
300        name: &'static str,
301        _variant_index: u32,
302        _variant: &'static str,
303        _len: usize,
304    ) -> Result<Self::SerializeStructVariant, Self::Error> {
305        Err(Error::unsupported_type(Some(name)))
306    }
307}
308
309pub(crate) fn write_value(
310    dst: &mut String,
311    value: Result<toml_edit::Value, crate::edit::ser::Error>,
312) -> Result<(), Error> {
313    use std::fmt::Write;
314
315    let value = value.map_err(Error::wrap)?;
316
317    write!(dst, "{value}").unwrap();
318
319    Ok(())
320}
toml/ser/ser_value/mod.rs

toml/ser/ser_value/
mod.rs
