toml_edit/ser/
map.rs

1use super::{Error, KeySerializer, SerializeValueArray, ValueSerializer};
2
3#[doc(hidden)]
4pub enum SerializeMap {
5    Datetime(SerializeDatetime),
6    Table(SerializeInlineTable),
7}
8
9impl SerializeMap {
10    pub(crate) fn table() -> Self {
11        Self::Table(SerializeInlineTable::new())
12    }
13
14    pub(crate) fn table_with_capacity(len: usize) -> Self {
15        Self::Table(SerializeInlineTable::with_capacity(len))
16    }
17
18    pub(crate) fn datetime() -> Self {
19        Self::Datetime(SerializeDatetime::new())
20    }
21}
22
23impl serde::ser::SerializeMap for SerializeMap {
24    type Ok = crate::Value;
25    type Error = Error;
26
27    fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
28    where
29        T: serde::ser::Serialize + ?Sized,
30    {
31        match self {
32            Self::Datetime(s) => s.serialize_key(input),
33            Self::Table(s) => s.serialize_key(input),
34        }
35    }
36
37    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
38    where
39        T: serde::ser::Serialize + ?Sized,
40    {
41        match self {
42            Self::Datetime(s) => s.serialize_value(value),
43            Self::Table(s) => s.serialize_value(value),
44        }
45    }
46
47    fn end(self) -> Result<Self::Ok, Self::Error> {
48        match self {
49            Self::Datetime(s) => s.end().map(|items| items.into()),
50            Self::Table(s) => s.end().map(|items| items.into()),
51        }
52    }
53}
54
55impl serde::ser::SerializeStruct for SerializeMap {
56    type Ok = crate::Value;
57    type Error = Error;
58
59    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
60    where
61        T: serde::ser::Serialize + ?Sized,
62    {
63        match self {
64            Self::Datetime(s) => s.serialize_field(key, value),
65            Self::Table(s) => s.serialize_field(key, value),
66        }
67    }
68
69    fn end(self) -> Result<Self::Ok, Self::Error> {
70        match self {
71            Self::Datetime(s) => s.end().map(|items| items.into()),
72            Self::Table(s) => s.end().map(|items| items.into()),
73        }
74    }
75}
76
77#[doc(hidden)]
78pub struct SerializeDatetime {
79    value: Option<crate::Datetime>,
80}
81
82impl SerializeDatetime {
83    pub(crate) fn new() -> Self {
84        Self { value: None }
85    }
86}
87
88impl serde::ser::SerializeMap for SerializeDatetime {
89    type Ok = crate::Datetime;
90    type Error = Error;
91
92    fn serialize_key<T>(&mut self, _input: &T) -> Result<(), Self::Error>
93    where
94        T: serde::ser::Serialize + ?Sized,
95    {
96        unreachable!("datetimes should only be serialized as structs, not maps")
97    }
98
99    fn serialize_value<T>(&mut self, _value: &T) -> Result<(), Self::Error>
100    where
101        T: serde::ser::Serialize + ?Sized,
102    {
103        unreachable!("datetimes should only be serialized as structs, not maps")
104    }
105
106    fn end(self) -> Result<Self::Ok, Self::Error> {
107        unreachable!("datetimes should only be serialized as structs, not maps")
108    }
109}
110
111impl serde::ser::SerializeStruct for SerializeDatetime {
112    type Ok = crate::Datetime;
113    type Error = Error;
114
115    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
116    where
117        T: serde::ser::Serialize + ?Sized,
118    {
119        if key == toml_datetime::__unstable::FIELD {
120            self.value = Some(value.serialize(DatetimeFieldSerializer::default())?);
121        }
122
123        Ok(())
124    }
125
126    fn end(self) -> Result<Self::Ok, Self::Error> {
127        self.value.ok_or(Error::UnsupportedNone)
128    }
129}
130
131#[doc(hidden)]
132pub struct SerializeInlineTable {
133    items: crate::table::KeyValuePairs,
134    key: Option<crate::Key>,
135}
136
137impl SerializeInlineTable {
138    pub(crate) fn new() -> Self {
139        Self {
140            items: Default::default(),
141            key: Default::default(),
142        }
143    }
144
145    pub(crate) fn with_capacity(len: usize) -> Self {
146        let mut s = Self::new();
147        s.items.reserve(len);
148        s
149    }
150}
151
152impl serde::ser::SerializeMap for SerializeInlineTable {
153    type Ok = crate::InlineTable;
154    type Error = Error;
155
156    fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
157    where
158        T: serde::ser::Serialize + ?Sized,
159    {
160        self.key = Some(input.serialize(KeySerializer)?);
161        Ok(())
162    }
163
164    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
165    where
166        T: serde::ser::Serialize + ?Sized,
167    {
168        let mut value_serializer = MapValueSerializer::new();
169        let res = value.serialize(&mut value_serializer);
170        match res {
171            Ok(item) => {
172                let key = self.key.take().unwrap();
173                let item = crate::Item::Value(item);
174                self.items.insert(key, item);
175            }
176            Err(e) => {
177                if !(e == Error::UnsupportedNone && value_serializer.is_none) {
178                    return Err(e);
179                }
180            }
181        }
182        Ok(())
183    }
184
185    fn end(self) -> Result<Self::Ok, Self::Error> {
186        Ok(crate::InlineTable::with_pairs(self.items))
187    }
188}
189
190impl serde::ser::SerializeStruct for SerializeInlineTable {
191    type Ok = crate::InlineTable;
192    type Error = Error;
193
194    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
195    where
196        T: serde::ser::Serialize + ?Sized,
197    {
198        let mut value_serializer = MapValueSerializer::new();
199        let res = value.serialize(&mut value_serializer);
200        match res {
201            Ok(item) => {
202                let item = crate::Item::Value(item);
203                self.items.insert(crate::Key::new(key), item);
204            }
205            Err(e) => {
206                if !(e == Error::UnsupportedNone && value_serializer.is_none) {
207                    return Err(e);
208                }
209            }
210        };
211        Ok(())
212    }
213
214    fn end(self) -> Result<Self::Ok, Self::Error> {
215        Ok(crate::InlineTable::with_pairs(self.items))
216    }
217}
218
219#[derive(Default)]
220struct DatetimeFieldSerializer {}
221
222impl serde::ser::Serializer for DatetimeFieldSerializer {
223    type Ok = toml_datetime::Datetime;
224    type Error = Error;
225    type SerializeSeq = serde::ser::Impossible<Self::Ok, Self::Error>;
226    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
227    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
228    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
229    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
230    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
231    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
232
233    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
234        Err(Error::DateInvalid)
235    }
236
237    fn serialize_i8(self, _value: i8) -> Result<Self::Ok, Self::Error> {
238        Err(Error::DateInvalid)
239    }
240
241    fn serialize_i16(self, _value: i16) -> Result<Self::Ok, Self::Error> {
242        Err(Error::DateInvalid)
243    }
244
245    fn serialize_i32(self, _value: i32) -> Result<Self::Ok, Self::Error> {
246        Err(Error::DateInvalid)
247    }
248
249    fn serialize_i64(self, _value: i64) -> Result<Self::Ok, Self::Error> {
250        Err(Error::DateInvalid)
251    }
252
253    fn serialize_u8(self, _value: u8) -> Result<Self::Ok, Self::Error> {
254        Err(Error::DateInvalid)
255    }
256
257    fn serialize_u16(self, _value: u16) -> Result<Self::Ok, Self::Error> {
258        Err(Error::DateInvalid)
259    }
260
261    fn serialize_u32(self, _value: u32) -> Result<Self::Ok, Self::Error> {
262        Err(Error::DateInvalid)
263    }
264
265    fn serialize_u64(self, _value: u64) -> Result<Self::Ok, Self::Error> {
266        Err(Error::DateInvalid)
267    }
268
269    fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
270        Err(Error::DateInvalid)
271    }
272
273    fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
274        Err(Error::DateInvalid)
275    }
276
277    fn serialize_char(self, _value: char) -> Result<Self::Ok, Self::Error> {
278        Err(Error::DateInvalid)
279    }
280
281    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
282        v.parse::<toml_datetime::Datetime>().map_err(Error::custom)
283    }
284
285    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
286        Err(Error::DateInvalid)
287    }
288
289    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
290        Err(Error::DateInvalid)
291    }
292
293    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
294    where
295        T: serde::ser::Serialize + ?Sized,
296    {
297        Err(Error::DateInvalid)
298    }
299
300    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
301        Err(Error::DateInvalid)
302    }
303
304    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
305        Err(Error::DateInvalid)
306    }
307
308    fn serialize_unit_variant(
309        self,
310        _name: &'static str,
311        _variant_index: u32,
312        _variant: &'static str,
313    ) -> Result<Self::Ok, Self::Error> {
314        Err(Error::DateInvalid)
315    }
316
317    fn serialize_newtype_struct<T>(
318        self,
319        _name: &'static str,
320        _value: &T,
321    ) -> Result<Self::Ok, Self::Error>
322    where
323        T: serde::ser::Serialize + ?Sized,
324    {
325        Err(Error::DateInvalid)
326    }
327
328    fn serialize_newtype_variant<T>(
329        self,
330        _name: &'static str,
331        _variant_index: u32,
332        _variant: &'static str,
333        _value: &T,
334    ) -> Result<Self::Ok, Self::Error>
335    where
336        T: serde::ser::Serialize + ?Sized,
337    {
338        Err(Error::DateInvalid)
339    }
340
341    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
342        Err(Error::DateInvalid)
343    }
344
345    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
346        Err(Error::DateInvalid)
347    }
348
349    fn serialize_tuple_struct(
350        self,
351        _name: &'static str,
352        _len: usize,
353    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
354        Err(Error::DateInvalid)
355    }
356
357    fn serialize_tuple_variant(
358        self,
359        _name: &'static str,
360        _variant_index: u32,
361        _variant: &'static str,
362        _len: usize,
363    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
364        Err(Error::DateInvalid)
365    }
366
367    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
368        Err(Error::DateInvalid)
369    }
370
371    fn serialize_struct(
372        self,
373        _name: &'static str,
374        _len: usize,
375    ) -> Result<Self::SerializeStruct, Self::Error> {
376        Err(Error::DateInvalid)
377    }
378
379    fn serialize_struct_variant(
380        self,
381        _name: &'static str,
382        _variant_index: u32,
383        _variant: &'static str,
384        _len: usize,
385    ) -> Result<Self::SerializeStructVariant, Self::Error> {
386        Err(Error::DateInvalid)
387    }
388}
389
390#[derive(Default)]
391struct MapValueSerializer {
392    is_none: bool,
393}
394
395impl MapValueSerializer {
396    fn new() -> Self {
397        Self { is_none: false }
398    }
399}
400
401impl serde::ser::Serializer for &mut MapValueSerializer {
402    type Ok = crate::Value;
403    type Error = Error;
404    type SerializeSeq = SerializeValueArray;
405    type SerializeTuple = SerializeValueArray;
406    type SerializeTupleStruct = SerializeValueArray;
407    type SerializeTupleVariant = SerializeTupleVariant;
408    type SerializeMap = SerializeMap;
409    type SerializeStruct = SerializeMap;
410    type SerializeStructVariant = SerializeStructVariant;
411
412    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
413        ValueSerializer::new().serialize_bool(v)
414    }
415
416    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
417        ValueSerializer::new().serialize_i8(v)
418    }
419
420    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
421        ValueSerializer::new().serialize_i16(v)
422    }
423
424    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
425        ValueSerializer::new().serialize_i32(v)
426    }
427
428    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
429        ValueSerializer::new().serialize_i64(v)
430    }
431
432    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
433        ValueSerializer::new().serialize_u8(v)
434    }
435
436    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
437        ValueSerializer::new().serialize_u16(v)
438    }
439
440    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
441        ValueSerializer::new().serialize_u32(v)
442    }
443
444    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
445        ValueSerializer::new().serialize_u64(v)
446    }
447
448    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
449        ValueSerializer::new().serialize_f32(v)
450    }
451
452    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
453        ValueSerializer::new().serialize_f64(v)
454    }
455
456    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
457        ValueSerializer::new().serialize_char(v)
458    }
459
460    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
461        ValueSerializer::new().serialize_str(v)
462    }
463
464    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
465        ValueSerializer::new().serialize_bytes(value)
466    }
467
468    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
469        self.is_none = true;
470        Err(Error::UnsupportedNone)
471    }
472
473    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
474    where
475        T: serde::ser::Serialize + ?Sized,
476    {
477        ValueSerializer::new().serialize_some(value)
478    }
479
480    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
481        ValueSerializer::new().serialize_unit()
482    }
483
484    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
485        ValueSerializer::new().serialize_unit_struct(name)
486    }
487
488    fn serialize_unit_variant(
489        self,
490        name: &'static str,
491        variant_index: u32,
492        variant: &'static str,
493    ) -> Result<Self::Ok, Self::Error> {
494        ValueSerializer::new().serialize_unit_variant(name, variant_index, variant)
495    }
496
497    fn serialize_newtype_struct<T>(
498        self,
499        name: &'static str,
500        value: &T,
501    ) -> Result<Self::Ok, Self::Error>
502    where
503        T: serde::ser::Serialize + ?Sized,
504    {
505        ValueSerializer::new().serialize_newtype_struct(name, value)
506    }
507
508    fn serialize_newtype_variant<T>(
509        self,
510        name: &'static str,
511        variant_index: u32,
512        variant: &'static str,
513        value: &T,
514    ) -> Result<Self::Ok, Self::Error>
515    where
516        T: serde::ser::Serialize + ?Sized,
517    {
518        ValueSerializer::new().serialize_newtype_variant(name, variant_index, variant, value)
519    }
520
521    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
522        ValueSerializer::new().serialize_seq(len)
523    }
524
525    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
526        ValueSerializer::new().serialize_tuple(len)
527    }
528
529    fn serialize_tuple_struct(
530        self,
531        name: &'static str,
532        len: usize,
533    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
534        ValueSerializer::new().serialize_tuple_struct(name, len)
535    }
536
537    fn serialize_tuple_variant(
538        self,
539        name: &'static str,
540        variant_index: u32,
541        variant: &'static str,
542        len: usize,
543    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
544        ValueSerializer::new().serialize_tuple_variant(name, variant_index, variant, len)
545    }
546
547    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
548        ValueSerializer::new().serialize_map(len)
549    }
550
551    fn serialize_struct(
552        self,
553        name: &'static str,
554        len: usize,
555    ) -> Result<Self::SerializeStruct, Self::Error> {
556        ValueSerializer::new().serialize_struct(name, len)
557    }
558
559    fn serialize_struct_variant(
560        self,
561        name: &'static str,
562        variant_index: u32,
563        variant: &'static str,
564        len: usize,
565    ) -> Result<Self::SerializeStructVariant, Self::Error> {
566        ValueSerializer::new().serialize_struct_variant(name, variant_index, variant, len)
567    }
568}
569
570pub(crate) type SerializeTupleVariant = SerializeVariant<SerializeValueArray>;
571pub(crate) type SerializeStructVariant = SerializeVariant<SerializeMap>;
572
573pub struct SerializeVariant<T> {
574    variant: &'static str,
575    inner: T,
576}
577
578impl SerializeVariant<SerializeValueArray> {
579    pub(crate) fn tuple(variant: &'static str, len: usize) -> Self {
580        Self {
581            variant,
582            inner: SerializeValueArray::with_capacity(len),
583        }
584    }
585}
586
587impl SerializeVariant<SerializeMap> {
588    pub(crate) fn struct_(variant: &'static str, len: usize) -> Self {
589        Self {
590            variant,
591            inner: SerializeMap::table_with_capacity(len),
592        }
593    }
594}
595
596impl serde::ser::SerializeTupleVariant for SerializeVariant<SerializeValueArray> {
597    type Ok = crate::Value;
598    type Error = Error;
599
600    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
601    where
602        T: serde::ser::Serialize + ?Sized,
603    {
604        serde::ser::SerializeSeq::serialize_element(&mut self.inner, value)
605    }
606
607    fn end(self) -> Result<Self::Ok, Self::Error> {
608        let inner = serde::ser::SerializeSeq::end(self.inner)?;
609        let mut items = crate::table::KeyValuePairs::new();
610        let value = crate::Item::Value(inner);
611        items.insert(crate::Key::new(self.variant), value);
612        Ok(crate::Value::InlineTable(crate::InlineTable::with_pairs(
613            items,
614        )))
615    }
616}
617
618impl serde::ser::SerializeStructVariant for SerializeVariant<SerializeMap> {
619    type Ok = crate::Value;
620    type Error = Error;
621
622    #[inline]
623    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
624    where
625        T: serde::ser::Serialize + ?Sized,
626    {
627        serde::ser::SerializeStruct::serialize_field(&mut self.inner, key, value)
628    }
629
630    #[inline]
631    fn end(self) -> Result<Self::Ok, Self::Error> {
632        let inner = serde::ser::SerializeStruct::end(self.inner)?;
633        let mut items = crate::table::KeyValuePairs::new();
634        let value = crate::Item::Value(inner);
635        items.insert(crate::Key::new(self.variant), value);
636        Ok(crate::Value::InlineTable(crate::InlineTable::with_pairs(
637            items,
638        )))
639    }
640}
toml_edit/ser/map.rs

toml_edit/ser/
map.rs
