toml/ser/value/
map.rs

1use core::fmt::Write as _;
2
3use toml_writer::TomlWrite as _;
4
5use super::array::SerializeTupleVariant;
6use super::array::SerializeValueArray;
7use super::key::KeySerializer;
8use super::Error;
9use super::Style;
10use super::ValueSerializer;
11use crate::alloc_prelude::*;
12
13#[doc(hidden)]
14#[allow(clippy::large_enum_variant)]
15pub enum SerializeMap<'d> {
16    Datetime(SerializeDatetime<'d>),
17    Table(SerializeTable<'d>),
18}
19
20impl<'d> SerializeMap<'d> {
21    pub(crate) fn map(dst: &'d mut String, style: Style) -> Result<Self, Error> {
22        Ok(Self::Table(SerializeTable::map(dst, style)?))
23    }
24
25    pub(crate) fn struct_(
26        name: &'static str,
27        dst: &'d mut String,
28        style: Style,
29    ) -> Result<Self, Error> {
30        if toml_datetime::ser::is_datetime(name) {
31            Ok(Self::Datetime(SerializeDatetime::new(dst)))
32        } else {
33            Ok(Self::map(dst, style)?)
34        }
35    }
36}
37
38impl<'d> serde::ser::SerializeMap for SerializeMap<'d> {
39    type Ok = &'d mut String;
40    type Error = Error;
41
42    fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
43    where
44        T: serde::ser::Serialize + ?Sized,
45    {
46        match self {
47            Self::Datetime(s) => s.serialize_key(input),
48            Self::Table(s) => s.serialize_key(input),
49        }
50    }
51
52    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
53    where
54        T: serde::ser::Serialize + ?Sized,
55    {
56        match self {
57            Self::Datetime(s) => s.serialize_value(value),
58            Self::Table(s) => s.serialize_value(value),
59        }
60    }
61
62    fn end(self) -> Result<Self::Ok, Self::Error> {
63        match self {
64            Self::Datetime(s) => s.end(),
65            Self::Table(s) => s.end(),
66        }
67    }
68}
69
70impl<'d> serde::ser::SerializeStruct for SerializeMap<'d> {
71    type Ok = &'d mut String;
72    type Error = Error;
73
74    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
75    where
76        T: serde::ser::Serialize + ?Sized,
77    {
78        match self {
79            Self::Datetime(s) => s.serialize_field(key, value),
80            Self::Table(s) => s.serialize_field(key, value),
81        }
82    }
83
84    fn end(self) -> Result<Self::Ok, Self::Error> {
85        match self {
86            Self::Datetime(s) => s.end(),
87            Self::Table(s) => s.end(),
88        }
89    }
90}
91
92#[doc(hidden)]
93pub struct SerializeDatetime<'d> {
94    dst: &'d mut String,
95    inner: toml_datetime::ser::DatetimeSerializer,
96}
97
98impl<'d> SerializeDatetime<'d> {
99    pub(crate) fn new(dst: &'d mut String) -> Self {
100        Self {
101            dst,
102            inner: toml_datetime::ser::DatetimeSerializer::new(),
103        }
104    }
105}
106
107impl<'d> serde::ser::SerializeMap for SerializeDatetime<'d> {
108    type Ok = &'d mut String;
109    type Error = Error;
110
111    fn serialize_key<T>(&mut self, _input: &T) -> Result<(), Self::Error>
112    where
113        T: serde::ser::Serialize + ?Sized,
114    {
115        unreachable!("datetimes should only be serialized as structs, not maps")
116    }
117
118    fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
119    where
120        T: serde::ser::Serialize + ?Sized,
121    {
122        unreachable!("datetimes should only be serialized as structs, not maps")
123    }
124
125    fn end(self) -> Result<Self::Ok, Self::Error> {
126        unreachable!("datetimes should only be serialized as structs, not maps")
127    }
128}
129
130impl<'d> serde::ser::SerializeStruct for SerializeDatetime<'d> {
131    type Ok = &'d mut String;
132    type Error = Error;
133
134    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
135    where
136        T: serde::ser::Serialize + ?Sized,
137    {
138        self.inner.serialize_field(key, value).map_err(dt_err)?;
139
140        Ok(())
141    }
142
143    fn end(self) -> Result<Self::Ok, Self::Error> {
144        let value = self.inner.end().map_err(dt_err)?;
145        write!(self.dst, "{value}")?;
146        Ok(self.dst)
147    }
148}
149
150fn dt_err(err: toml_datetime::ser::SerializerError) -> Error {
151    match err {
152        toml_datetime::ser::SerializerError::InvalidFormat(err) => Error::new(err),
153        _ => Error::date_invalid(),
154    }
155}
156
157#[doc(hidden)]
158pub struct SerializeTable<'d> {
159    dst: &'d mut String,
160    seen_value: bool,
161    key: Option<String>,
162    style: Style,
163}
164
165impl<'d> SerializeTable<'d> {
166    pub(crate) fn map(dst: &'d mut String, style: Style) -> Result<Self, Error> {
167        dst.open_inline_table()?;
168        Ok(Self {
169            dst,
170            seen_value: false,
171            key: None,
172            style,
173        })
174    }
175
176    pub(crate) fn end(self) -> Result<&'d mut String, Error> {
177        if self.seen_value {
178            self.dst.space()?;
179        }
180        self.dst.close_inline_table()?;
181        Ok(self.dst)
182    }
183}
184
185impl<'d> serde::ser::SerializeMap for SerializeTable<'d> {
186    type Ok = &'d mut String;
187    type Error = Error;
188
189    fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
190    where
191        T: serde::ser::Serialize + ?Sized,
192    {
193        let mut encoded_key = String::new();
194        input.serialize(KeySerializer {
195            dst: &mut encoded_key,
196        })?;
197        self.key = Some(encoded_key);
198        Ok(())
199    }
200
201    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
202    where
203        T: serde::ser::Serialize + ?Sized,
204    {
205        let encoded_key = self
206            .key
207            .take()
208            .expect("always called after `serialize_key`");
209        let mut encoded_value = String::new();
210        let mut is_none = false;
211        let value_serializer =
212            MapValueSerializer::new(&mut encoded_value, &mut is_none, self.style);
213        let res = value.serialize(value_serializer);
214        match res {
215            Ok(_) => {
216                use core::fmt::Write as _;
217
218                if self.seen_value {
219                    self.dst.val_sep()?;
220                }
221                self.seen_value = true;
222                self.dst.space()?;
223                write!(self.dst, "{encoded_key}")?;
224                self.dst.space()?;
225                self.dst.keyval_sep()?;
226                self.dst.space()?;
227                write!(self.dst, "{encoded_value}")?;
228            }
229            Err(e) => {
230                if !(e == Error::unsupported_none() && is_none) {
231                    return Err(e);
232                }
233            }
234        }
235        Ok(())
236    }
237
238    fn end(self) -> Result<Self::Ok, Self::Error> {
239        self.end()
240    }
241}
242
243impl<'d> serde::ser::SerializeStruct for SerializeTable<'d> {
244    type Ok = &'d mut String;
245    type Error = Error;
246
247    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
248    where
249        T: serde::ser::Serialize + ?Sized,
250    {
251        let mut encoded_value = String::new();
252        let mut is_none = false;
253        let value_serializer =
254            MapValueSerializer::new(&mut encoded_value, &mut is_none, self.style);
255        let res = value.serialize(value_serializer);
256        match res {
257            Ok(_) => {
258                use core::fmt::Write as _;
259
260                if self.seen_value {
261                    self.dst.val_sep()?;
262                }
263                self.seen_value = true;
264                self.dst.space()?;
265                self.dst.key(key)?;
266                self.dst.space()?;
267                self.dst.keyval_sep()?;
268                self.dst.space()?;
269                write!(self.dst, "{encoded_value}")?;
270            }
271            Err(e) => {
272                if !(e == Error::unsupported_none() && is_none) {
273                    return Err(e);
274                }
275            }
276        }
277
278        Ok(())
279    }
280
281    fn end(self) -> Result<Self::Ok, Self::Error> {
282        self.end()
283    }
284}
285
286pub(crate) struct MapValueSerializer<'d> {
287    dst: &'d mut String,
288    is_none: &'d mut bool,
289    style: Style,
290}
291
292impl<'d> MapValueSerializer<'d> {
293    pub(crate) fn new(dst: &'d mut String, is_none: &'d mut bool, style: Style) -> Self {
294        Self {
295            dst,
296            is_none,
297            style,
298        }
299    }
300}
301
302impl<'d> serde::ser::Serializer for MapValueSerializer<'d> {
303    type Ok = &'d mut String;
304    type Error = Error;
305    type SerializeSeq = SerializeValueArray<'d>;
306    type SerializeTuple = SerializeValueArray<'d>;
307    type SerializeTupleStruct = SerializeValueArray<'d>;
308    type SerializeTupleVariant = SerializeTupleVariant<'d>;
309    type SerializeMap = SerializeMap<'d>;
310    type SerializeStruct = SerializeMap<'d>;
311    type SerializeStructVariant = SerializeStructVariant<'d>;
312
313    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
314        ValueSerializer::with_style(self.dst, self.style).serialize_bool(v)
315    }
316
317    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
318        ValueSerializer::with_style(self.dst, self.style).serialize_i8(v)
319    }
320
321    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
322        ValueSerializer::with_style(self.dst, self.style).serialize_i16(v)
323    }
324
325    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
326        ValueSerializer::with_style(self.dst, self.style).serialize_i32(v)
327    }
328
329    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
330        ValueSerializer::with_style(self.dst, self.style).serialize_i64(v)
331    }
332
333    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
334        ValueSerializer::with_style(self.dst, self.style).serialize_u8(v)
335    }
336
337    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
338        ValueSerializer::with_style(self.dst, self.style).serialize_u16(v)
339    }
340
341    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
342        ValueSerializer::with_style(self.dst, self.style).serialize_u32(v)
343    }
344
345    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
346        ValueSerializer::with_style(self.dst, self.style).serialize_u64(v)
347    }
348
349    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
350        ValueSerializer::with_style(self.dst, self.style).serialize_f32(v)
351    }
352
353    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
354        ValueSerializer::with_style(self.dst, self.style).serialize_f64(v)
355    }
356
357    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
358        ValueSerializer::with_style(self.dst, self.style).serialize_char(v)
359    }
360
361    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
362        ValueSerializer::with_style(self.dst, self.style).serialize_str(v)
363    }
364
365    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
366        ValueSerializer::with_style(self.dst, self.style).serialize_bytes(value)
367    }
368
369    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
370        *self.is_none = true;
371        Err(Error::unsupported_none())
372    }
373
374    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
375    where
376        T: serde::ser::Serialize + ?Sized,
377    {
378        ValueSerializer::with_style(self.dst, self.style).serialize_some(value)
379    }
380
381    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
382        ValueSerializer::with_style(self.dst, self.style).serialize_unit()
383    }
384
385    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
386        ValueSerializer::with_style(self.dst, self.style).serialize_unit_struct(name)
387    }
388
389    fn serialize_unit_variant(
390        self,
391        name: &'static str,
392        variant_index: u32,
393        variant: &'static str,
394    ) -> Result<Self::Ok, Self::Error> {
395        ValueSerializer::with_style(self.dst, self.style).serialize_unit_variant(
396            name,
397            variant_index,
398            variant,
399        )
400    }
401
402    fn serialize_newtype_struct<T>(
403        self,
404        _name: &'static str,
405        value: &T,
406    ) -> Result<Self::Ok, Self::Error>
407    where
408        T: serde::ser::Serialize + ?Sized,
409    {
410        value.serialize(self)
411    }
412
413    fn serialize_newtype_variant<T>(
414        self,
415        name: &'static str,
416        variant_index: u32,
417        variant: &'static str,
418        value: &T,
419    ) -> Result<Self::Ok, Self::Error>
420    where
421        T: serde::ser::Serialize + ?Sized,
422    {
423        ValueSerializer::with_style(self.dst, self.style).serialize_newtype_variant(
424            name,
425            variant_index,
426            variant,
427            value,
428        )
429    }
430
431    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
432        ValueSerializer::with_style(self.dst, self.style).serialize_seq(len)
433    }
434
435    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
436        ValueSerializer::with_style(self.dst, self.style).serialize_tuple(len)
437    }
438
439    fn serialize_tuple_struct(
440        self,
441        name: &'static str,
442        len: usize,
443    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
444        ValueSerializer::with_style(self.dst, self.style).serialize_tuple_struct(name, len)
445    }
446
447    fn serialize_tuple_variant(
448        self,
449        name: &'static str,
450        variant_index: u32,
451        variant: &'static str,
452        len: usize,
453    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
454        ValueSerializer::with_style(self.dst, self.style).serialize_tuple_variant(
455            name,
456            variant_index,
457            variant,
458            len,
459        )
460    }
461
462    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
463        ValueSerializer::with_style(self.dst, self.style).serialize_map(len)
464    }
465
466    fn serialize_struct(
467        self,
468        name: &'static str,
469        len: usize,
470    ) -> Result<Self::SerializeStruct, Self::Error> {
471        ValueSerializer::with_style(self.dst, self.style).serialize_struct(name, len)
472    }
473
474    fn serialize_struct_variant(
475        self,
476        name: &'static str,
477        variant_index: u32,
478        variant: &'static str,
479        len: usize,
480    ) -> Result<Self::SerializeStructVariant, Self::Error> {
481        ValueSerializer::with_style(self.dst, self.style).serialize_struct_variant(
482            name,
483            variant_index,
484            variant,
485            len,
486        )
487    }
488}
489
490pub struct SerializeStructVariant<'d> {
491    inner: SerializeTable<'d>,
492}
493
494impl<'d> SerializeStructVariant<'d> {
495    pub(crate) fn struct_(
496        dst: &'d mut String,
497        variant: &'static str,
498        _len: usize,
499        style: Style,
500    ) -> Result<Self, Error> {
501        dst.open_inline_table()?;
502        dst.space()?;
503        dst.key(variant)?;
504        dst.space()?;
505        dst.keyval_sep()?;
506        dst.space()?;
507        Ok(Self {
508            inner: SerializeTable::map(dst, style)?,
509        })
510    }
511}
512
513impl<'d> serde::ser::SerializeStructVariant for SerializeStructVariant<'d> {
514    type Ok = &'d mut String;
515    type Error = Error;
516
517    #[inline]
518    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
519    where
520        T: serde::ser::Serialize + ?Sized,
521    {
522        serde::ser::SerializeStruct::serialize_field(&mut self.inner, key, value)
523    }
524
525    #[inline]
526    fn end(self) -> Result<Self::Ok, Self::Error> {
527        let dst = serde::ser::SerializeStruct::end(self.inner)?;
528        dst.space()?;
529        dst.close_inline_table()?;
530        Ok(dst)
531    }
532}
toml/ser/value/map.rs

toml/ser/value/
map.rs
