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(serializer:DatetimeFieldSerializer::default())?);
129 }
130
131 Ok(())
132 }
133
134 fn end(self) -> Result<Self::Ok, Self::Error> {
135 self.value.ok_or(err: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: SerializeInlineTable = Self::new();
155 s.items.reserve(additional: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}
406