toml_edit/ser/
map.rs

Help
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 table() -> Self {
16        Self::Table(SerializeInlineTable::new())
17    }
18
19    pub(crate) fn table_with_capacity(len: usize) -> Self {
20        Self::Table(SerializeInlineTable::with_capacity(len))
21    }
22
23    pub(crate) fn datetime() -> Self {
24        Self::Datetime(SerializeDatetime::new())
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 new() -> Self {
144        Self {
145            items: Default::default(),
146            key: Default::default(),
147        }
148    }
149
150    pub(crate) fn with_capacity(len: usize) -> Self {
151        let mut s = Self::new();
152        s.items.reserve(len);
153        s
154    }
155}
156
157impl serde::ser::SerializeMap for SerializeInlineTable {
158    type Ok = crate::InlineTable;
159    type Error = Error;
160
161    fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
162    where
163        T: serde::ser::Serialize + ?Sized,
164    {
165        self.key = Some(input.serialize(KeySerializer)?);
166        Ok(())
167    }
168
169    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
170    where
171        T: serde::ser::Serialize + ?Sized,
172    {
173        let mut is_none = false;
174        let value_serializer = MapValueSerializer::new(&mut is_none);
175        let res = value.serialize(value_serializer);
176        match res {
177            Ok(item) => {
178                let key = self.key.take().unwrap();
179                let item = crate::Item::Value(item);
180                self.items.insert(key, item);
181            }
182            Err(e) => {
183                if !(e == Error::unsupported_none() && is_none) {
184                    return Err(e);
185                }
186            }
187        }
188        Ok(())
189    }
190
191    fn end(self) -> Result<Self::Ok, Self::Error> {
192        Ok(crate::InlineTable::with_pairs(self.items))
193    }
194}
195
196impl serde::ser::SerializeStruct for SerializeInlineTable {
197    type Ok = crate::InlineTable;
198    type Error = Error;
199
200    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
201    where
202        T: serde::ser::Serialize + ?Sized,
203    {
204        let mut is_none = false;
205        let value_serializer = MapValueSerializer::new(&mut is_none);
206        let res = value.serialize(value_serializer);
207        match res {
208            Ok(item) => {
209                let item = crate::Item::Value(item);
210                self.items.insert(crate::Key::new(key), item);
211            }
212            Err(e) => {
213                if !(e == Error::unsupported_none() && is_none) {
214                    return Err(e);
215                }
216            }
217        };
218        Ok(())
219    }
220
221    fn end(self) -> Result<Self::Ok, Self::Error> {
222        Ok(crate::InlineTable::with_pairs(self.items))
223    }
224}
225
226#[derive(Default)]
227struct DatetimeFieldSerializer {}
228
229impl serde::ser::Serializer for DatetimeFieldSerializer {
230    type Ok = toml_datetime::Datetime;
231    type Error = Error;
232    type SerializeSeq = serde::ser::Impossible<Self::Ok, Self::Error>;
233    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
234    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
235    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
236    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
237    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
238    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
239
240    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
241        Err(Error::date_invalid())
242    }
243
244    fn serialize_i8(self, _value: i8) -> Result<Self::Ok, Self::Error> {
245        Err(Error::date_invalid())
246    }
247
248    fn serialize_i16(self, _value: i16) -> Result<Self::Ok, Self::Error> {
249        Err(Error::date_invalid())
250    }
251
252    fn serialize_i32(self, _value: i32) -> Result<Self::Ok, Self::Error> {
253        Err(Error::date_invalid())
254    }
255
256    fn serialize_i64(self, _value: i64) -> Result<Self::Ok, Self::Error> {
257        Err(Error::date_invalid())
258    }
259
260    fn serialize_u8(self, _value: u8) -> Result<Self::Ok, Self::Error> {
261        Err(Error::date_invalid())
262    }
263
264    fn serialize_u16(self, _value: u16) -> Result<Self::Ok, Self::Error> {
265        Err(Error::date_invalid())
266    }
267
268    fn serialize_u32(self, _value: u32) -> Result<Self::Ok, Self::Error> {
269        Err(Error::date_invalid())
270    }
271
272    fn serialize_u64(self, _value: u64) -> Result<Self::Ok, Self::Error> {
273        Err(Error::date_invalid())
274    }
275
276    fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
277        Err(Error::date_invalid())
278    }
279
280    fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
281        Err(Error::date_invalid())
282    }
283
284    fn serialize_char(self, _value: char) -> Result<Self::Ok, Self::Error> {
285        Err(Error::date_invalid())
286    }
287
288    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
289        v.parse::<toml_datetime::Datetime>().map_err(Error::custom)
290    }
291
292    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
293        Err(Error::date_invalid())
294    }
295
296    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
297        Err(Error::date_invalid())
298    }
299
300    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
301    where
302        T: serde::ser::Serialize + ?Sized,
303    {
304        Err(Error::date_invalid())
305    }
306
307    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
308        Err(Error::date_invalid())
309    }
310
311    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
312        Err(Error::date_invalid())
313    }
314
315    fn serialize_unit_variant(
316        self,
317        _name: &'static str,
318        _variant_index: u32,
319        _variant: &'static str,
320    ) -> Result<Self::Ok, Self::Error> {
321        Err(Error::date_invalid())
322    }
323
324    fn serialize_newtype_struct<T>(
325        self,
326        _name: &'static str,
327        _value: &T,
328    ) -> Result<Self::Ok, Self::Error>
329    where
330        T: serde::ser::Serialize + ?Sized,
331    {
332        Err(Error::date_invalid())
333    }
334
335    fn serialize_newtype_variant<T>(
336        self,
337        _name: &'static str,
338        _variant_index: u32,
339        _variant: &'static str,
340        _value: &T,
341    ) -> Result<Self::Ok, Self::Error>
342    where
343        T: serde::ser::Serialize + ?Sized,
344    {
345        Err(Error::date_invalid())
346    }
347
348    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
349        Err(Error::date_invalid())
350    }
351
352    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
353        Err(Error::date_invalid())
354    }
355
356    fn serialize_tuple_struct(
357        self,
358        _name: &'static str,
359        _len: usize,
360    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
361        Err(Error::date_invalid())
362    }
363
364    fn serialize_tuple_variant(
365        self,
366        _name: &'static str,
367        _variant_index: u32,
368        _variant: &'static str,
369        _len: usize,
370    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
371        Err(Error::date_invalid())
372    }
373
374    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
375        Err(Error::date_invalid())
376    }
377
378    fn serialize_struct(
379        self,
380        _name: &'static str,
381        _len: usize,
382    ) -> Result<Self::SerializeStruct, Self::Error> {
383        Err(Error::date_invalid())
384    }
385
386    fn serialize_struct_variant(
387        self,
388        _name: &'static str,
389        _variant_index: u32,
390        _variant: &'static str,
391        _len: usize,
392    ) -> Result<Self::SerializeStructVariant, Self::Error> {
393        Err(Error::date_invalid())
394    }
395}
396
397struct MapValueSerializer<'d> {
398    is_none: &'d mut bool,
399}
400
401impl<'d> MapValueSerializer<'d> {
402    fn new(is_none: &'d mut bool) -> Self {
403        Self { is_none }
404    }
405}
406
407impl serde::ser::Serializer for MapValueSerializer<'_> {
408    type Ok = crate::Value;
409    type Error = Error;
410    type SerializeSeq = SerializeValueArray;
411    type SerializeTuple = SerializeValueArray;
412    type SerializeTupleStruct = SerializeValueArray;
413    type SerializeTupleVariant = SerializeTupleVariant;
414    type SerializeMap = SerializeMap;
415    type SerializeStruct = SerializeMap;
416    type SerializeStructVariant = SerializeStructVariant;
417
418    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
419        ValueSerializer::new().serialize_bool(v)
420    }
421
422    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
423        ValueSerializer::new().serialize_i8(v)
424    }
425
426    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
427        ValueSerializer::new().serialize_i16(v)
428    }
429
430    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
431        ValueSerializer::new().serialize_i32(v)
432    }
433
434    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
435        ValueSerializer::new().serialize_i64(v)
436    }
437
438    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
439        ValueSerializer::new().serialize_u8(v)
440    }
441
442    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
443        ValueSerializer::new().serialize_u16(v)
444    }
445
446    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
447        ValueSerializer::new().serialize_u32(v)
448    }
449
450    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
451        ValueSerializer::new().serialize_u64(v)
452    }
453
454    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
455        ValueSerializer::new().serialize_f32(v)
456    }
457
458    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
459        ValueSerializer::new().serialize_f64(v)
460    }
461
462    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
463        ValueSerializer::new().serialize_char(v)
464    }
465
466    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
467        ValueSerializer::new().serialize_str(v)
468    }
469
470    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
471        ValueSerializer::new().serialize_bytes(value)
472    }
473
474    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
475        *self.is_none = true;
476        Err(Error::unsupported_none())
477    }
478
479    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
480    where
481        T: serde::ser::Serialize + ?Sized,
482    {
483        ValueSerializer::new().serialize_some(value)
484    }
485
486    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
487        ValueSerializer::new().serialize_unit()
488    }
489
490    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
491        ValueSerializer::new().serialize_unit_struct(name)
492    }
493
494    fn serialize_unit_variant(
495        self,
496        name: &'static str,
497        variant_index: u32,
498        variant: &'static str,
499    ) -> Result<Self::Ok, Self::Error> {
500        ValueSerializer::new().serialize_unit_variant(name, variant_index, variant)
501    }
502
503    fn serialize_newtype_struct<T>(
504        self,
505        _name: &'static str,
506        value: &T,
507    ) -> Result<Self::Ok, Self::Error>
508    where
509        T: serde::ser::Serialize + ?Sized,
510    {
511        value.serialize(self)
512    }
513
514    fn serialize_newtype_variant<T>(
515        self,
516        name: &'static str,
517        variant_index: u32,
518        variant: &'static str,
519        value: &T,
520    ) -> Result<Self::Ok, Self::Error>
521    where
522        T: serde::ser::Serialize + ?Sized,
523    {
524        ValueSerializer::new().serialize_newtype_variant(name, variant_index, variant, value)
525    }
526
527    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
528        ValueSerializer::new().serialize_seq(len)
529    }
530
531    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
532        ValueSerializer::new().serialize_tuple(len)
533    }
534
535    fn serialize_tuple_struct(
536        self,
537        name: &'static str,
538        len: usize,
539    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
540        ValueSerializer::new().serialize_tuple_struct(name, len)
541    }
542
543    fn serialize_tuple_variant(
544        self,
545        name: &'static str,
546        variant_index: u32,
547        variant: &'static str,
548        len: usize,
549    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
550        ValueSerializer::new().serialize_tuple_variant(name, variant_index, variant, len)
551    }
552
553    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
554        ValueSerializer::new().serialize_map(len)
555    }
556
557    fn serialize_struct(
558        self,
559        name: &'static str,
560        len: usize,
561    ) -> Result<Self::SerializeStruct, Self::Error> {
562        ValueSerializer::new().serialize_struct(name, len)
563    }
564
565    fn serialize_struct_variant(
566        self,
567        name: &'static str,
568        variant_index: u32,
569        variant: &'static str,
570        len: usize,
571    ) -> Result<Self::SerializeStructVariant, Self::Error> {
572        ValueSerializer::new().serialize_struct_variant(name, variant_index, variant, len)
573    }
574}
575
576pub struct SerializeStructVariant {
577    variant: &'static str,
578    inner: SerializeInlineTable,
579}
580
581impl SerializeStructVariant {
582    pub(crate) fn struct_(variant: &'static str, len: usize) -> Self {
583        Self {
584            variant,
585            inner: SerializeInlineTable::with_capacity(len),
586        }
587    }
588}
589
590impl serde::ser::SerializeStructVariant for SerializeStructVariant {
591    type Ok = crate::Value;
592    type Error = Error;
593
594    #[inline]
595    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
596    where
597        T: serde::ser::Serialize + ?Sized,
598    {
599        serde::ser::SerializeStruct::serialize_field(&mut self.inner, key, value)
600    }
601
602    #[inline]
603    fn end(self) -> Result<Self::Ok, Self::Error> {
604        let inner = serde::ser::SerializeStruct::end(self.inner)?.into();
605        let mut items = crate::table::KeyValuePairs::new();
606        let value = crate::Item::Value(inner);
607        items.insert(crate::Key::new(self.variant), value);
608        Ok(crate::Value::InlineTable(crate::InlineTable::with_pairs(
609            items,
610        )))
611    }
612}
toml_edit/ser/map.rs

toml_edit/ser/
map.rs
