toml_edit/ser/
map.rs

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

toml_edit/ser/
map.rs
