1 | use super::{Error, KeySerializer}; |
2 | |
3 | #[doc (hidden)] |
4 | pub enum SerializeMap { |
5 | Datetime(SerializeDatetime), |
6 | Table(SerializeInlineTable), |
7 | } |
8 | |
9 | impl 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 | |
23 | impl 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 | |
55 | impl 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)] |
82 | pub struct SerializeDatetime { |
83 | value: Option<crate::Datetime>, |
84 | } |
85 | |
86 | impl SerializeDatetime { |
87 | pub(crate) fn new() -> Self { |
88 | Self { value: None } |
89 | } |
90 | } |
91 | |
92 | impl 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 | |
115 | impl 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)] |
140 | pub struct SerializeInlineTable { |
141 | items: crate::table::KeyValuePairs, |
142 | key: Option<crate::InternalString>, |
143 | } |
144 | |
145 | impl 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 | |
160 | impl 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 | |
201 | impl 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)] |
237 | struct DatetimeFieldSerializer {} |
238 | |
239 | impl 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 | |