toml_edit/ser/
map.rs

1use super::{Error, KeySerializer};
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: ?Sized>(&mut self, input: &T) -> Result<(), Self::Error>
28    where
29        T: serde::ser::Serialize,
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: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
38    where
39        T: serde::ser::Serialize,
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: ?Sized>(
60        &mut self,
61        key: &'static str,
62        value: &T,
63    ) -> Result<(), Self::Error>
64    where
65        T: serde::ser::Serialize,
66    {
67        match self {
68            Self::Datetime(s) => s.serialize_field(key, value),
69            Self::Table(s) => s.serialize_field(key, value),
70        }
71    }
72
73    fn end(self) -> Result<Self::Ok, Self::Error> {
74        match self {
75            Self::Datetime(s) => s.end().map(|items| items.into()),
76            Self::Table(s) => s.end().map(|items| items.into()),
77        }
78    }
79}
80
81#[doc(hidden)]
82pub struct SerializeDatetime {
83    value: Option<crate::Datetime>,
84}
85
86impl SerializeDatetime {
87    pub(crate) fn new() -> Self {
88        Self { value: None }
89    }
90}
91
92impl serde::ser::SerializeMap for SerializeDatetime {
93    type Ok = crate::Datetime;
94    type Error = Error;
95
96    fn serialize_key<T: ?Sized>(&mut self, _input: &T) -> Result<(), Self::Error>
97    where
98        T: serde::ser::Serialize,
99    {
100        unreachable!("datetimes should only be serialized as structs, not maps")
101    }
102
103    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
104    where
105        T: serde::ser::Serialize,
106    {
107        unreachable!("datetimes should only be serialized as structs, not maps")
108    }
109
110    fn end(self) -> Result<Self::Ok, Self::Error> {
111        unreachable!("datetimes should only be serialized as structs, not maps")
112    }
113}
114
115impl serde::ser::SerializeStruct for SerializeDatetime {
116    type Ok = crate::Datetime;
117    type Error = Error;
118
119    fn serialize_field<T: ?Sized>(
120        &mut self,
121        key: &'static str,
122        value: &T,
123    ) -> Result<(), Self::Error>
124    where
125        T: serde::ser::Serialize,
126    {
127        if key == toml_datetime::__unstable::FIELD {
128            self.value = Some(value.serialize(DatetimeFieldSerializer::default())?);
129        }
130
131        Ok(())
132    }
133
134    fn end(self) -> Result<Self::Ok, Self::Error> {
135        self.value.ok_or(Error::UnsupportedNone)
136    }
137}
138
139#[doc(hidden)]
140pub struct SerializeInlineTable {
141    items: crate::table::KeyValuePairs,
142    key: Option<crate::InternalString>,
143}
144
145impl SerializeInlineTable {
146    pub(crate) fn new() -> Self {
147        Self {
148            items: Default::default(),
149            key: Default::default(),
150        }
151    }
152
153    pub(crate) fn with_capacity(len: usize) -> Self {
154        let mut s = Self::new();
155        s.items.reserve(len);
156        s
157    }
158}
159
160impl serde::ser::SerializeMap for SerializeInlineTable {
161    type Ok = crate::InlineTable;
162    type Error = Error;
163
164    fn serialize_key<T: ?Sized>(&mut self, input: &T) -> Result<(), Self::Error>
165    where
166        T: serde::ser::Serialize,
167    {
168        self.key = None;
169        self.key = Some(input.serialize(KeySerializer)?);
170        Ok(())
171    }
172
173    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
174    where
175        T: serde::ser::Serialize,
176    {
177        let res = value.serialize(super::ValueSerializer {});
178        match res {
179            Ok(item) => {
180                let key = self.key.take().unwrap();
181                let kv = crate::table::TableKeyValue::new(
182                    crate::Key::new(&key),
183                    crate::Item::Value(item),
184                );
185                self.items.insert(key, kv);
186            }
187            Err(e) => {
188                if e != Error::UnsupportedNone {
189                    return Err(e);
190                }
191            }
192        }
193        Ok(())
194    }
195
196    fn end(self) -> Result<Self::Ok, Self::Error> {
197        Ok(crate::InlineTable::with_pairs(self.items))
198    }
199}
200
201impl serde::ser::SerializeStruct for SerializeInlineTable {
202    type Ok = crate::InlineTable;
203    type Error = Error;
204
205    fn serialize_field<T: ?Sized>(
206        &mut self,
207        key: &'static str,
208        value: &T,
209    ) -> Result<(), Self::Error>
210    where
211        T: serde::ser::Serialize,
212    {
213        let res = value.serialize(super::ValueSerializer {});
214        match res {
215            Ok(item) => {
216                let kv = crate::table::TableKeyValue::new(
217                    crate::Key::new(key),
218                    crate::Item::Value(item),
219                );
220                self.items.insert(crate::InternalString::from(key), kv);
221            }
222            Err(e) => {
223                if e != Error::UnsupportedNone {
224                    return Err(e);
225                }
226            }
227        };
228        Ok(())
229    }
230
231    fn end(self) -> Result<Self::Ok, Self::Error> {
232        Ok(crate::InlineTable::with_pairs(self.items))
233    }
234}
235
236#[derive(Default)]
237struct DatetimeFieldSerializer {}
238
239impl serde::ser::Serializer for DatetimeFieldSerializer {
240    type Ok = toml_datetime::Datetime;
241    type Error = Error;
242    type SerializeSeq = serde::ser::Impossible<Self::Ok, Self::Error>;
243    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
244    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
245    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
246    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
247    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
248    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
249
250    fn serialize_bool(self, _value: bool) -> Result<Self::Ok, Self::Error> {
251        Err(Error::DateInvalid)
252    }
253
254    fn serialize_i8(self, _value: i8) -> Result<Self::Ok, Self::Error> {
255        Err(Error::DateInvalid)
256    }
257
258    fn serialize_i16(self, _value: i16) -> Result<Self::Ok, Self::Error> {
259        Err(Error::DateInvalid)
260    }
261
262    fn serialize_i32(self, _value: i32) -> Result<Self::Ok, Self::Error> {
263        Err(Error::DateInvalid)
264    }
265
266    fn serialize_i64(self, _value: i64) -> Result<Self::Ok, Self::Error> {
267        Err(Error::DateInvalid)
268    }
269
270    fn serialize_u8(self, _value: u8) -> Result<Self::Ok, Self::Error> {
271        Err(Error::DateInvalid)
272    }
273
274    fn serialize_u16(self, _value: u16) -> Result<Self::Ok, Self::Error> {
275        Err(Error::DateInvalid)
276    }
277
278    fn serialize_u32(self, _value: u32) -> Result<Self::Ok, Self::Error> {
279        Err(Error::DateInvalid)
280    }
281
282    fn serialize_u64(self, _value: u64) -> Result<Self::Ok, Self::Error> {
283        Err(Error::DateInvalid)
284    }
285
286    fn serialize_f32(self, _value: f32) -> Result<Self::Ok, Self::Error> {
287        Err(Error::DateInvalid)
288    }
289
290    fn serialize_f64(self, _value: f64) -> Result<Self::Ok, Self::Error> {
291        Err(Error::DateInvalid)
292    }
293
294    fn serialize_char(self, _value: char) -> Result<Self::Ok, Self::Error> {
295        Err(Error::DateInvalid)
296    }
297
298    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
299        v.parse::<toml_datetime::Datetime>().map_err(Error::custom)
300    }
301
302    fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
303        Err(Error::DateInvalid)
304    }
305
306    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
307        Err(Error::DateInvalid)
308    }
309
310    fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
311    where
312        T: serde::ser::Serialize,
313    {
314        Err(Error::DateInvalid)
315    }
316
317    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
318        Err(Error::DateInvalid)
319    }
320
321    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
322        Err(Error::DateInvalid)
323    }
324
325    fn serialize_unit_variant(
326        self,
327        _name: &'static str,
328        _variant_index: u32,
329        _variant: &'static str,
330    ) -> Result<Self::Ok, Self::Error> {
331        Err(Error::DateInvalid)
332    }
333
334    fn serialize_newtype_struct<T: ?Sized>(
335        self,
336        _name: &'static str,
337        _value: &T,
338    ) -> Result<Self::Ok, Self::Error>
339    where
340        T: serde::ser::Serialize,
341    {
342        Err(Error::DateInvalid)
343    }
344
345    fn serialize_newtype_variant<T: ?Sized>(
346        self,
347        _name: &'static str,
348        _variant_index: u32,
349        _variant: &'static str,
350        _value: &T,
351    ) -> Result<Self::Ok, Self::Error>
352    where
353        T: serde::ser::Serialize,
354    {
355        Err(Error::DateInvalid)
356    }
357
358    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
359        Err(Error::DateInvalid)
360    }
361
362    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
363        Err(Error::DateInvalid)
364    }
365
366    fn serialize_tuple_struct(
367        self,
368        _name: &'static str,
369        _len: usize,
370    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
371        Err(Error::DateInvalid)
372    }
373
374    fn serialize_tuple_variant(
375        self,
376        _name: &'static str,
377        _variant_index: u32,
378        _variant: &'static str,
379        _len: usize,
380    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
381        Err(Error::DateInvalid)
382    }
383
384    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
385        Err(Error::DateInvalid)
386    }
387
388    fn serialize_struct(
389        self,
390        _name: &'static str,
391        _len: usize,
392    ) -> Result<Self::SerializeStruct, Self::Error> {
393        Err(Error::DateInvalid)
394    }
395
396    fn serialize_struct_variant(
397        self,
398        _name: &'static str,
399        _variant_index: u32,
400        _variant: &'static str,
401        _len: usize,
402    ) -> Result<Self::SerializeStructVariant, Self::Error> {
403        Err(Error::DateInvalid)
404    }
405}
toml_edit/ser/map.rs

toml_edit/ser/
map.rs
