1use crate::ast::{JsonArray, JsonBoolean, JsonField, JsonNull, JsonNumber, JsonObject, JsonString, JsonValue};
2use oak_core::OakError as Error;
3use serde::{
4 de::{self, Visitor},
5 ser::{self, Serialize},
6};
7
8pub struct Serializer;
9
10pub fn to_value<T: Serialize>(value: &T) -> Result<JsonValue, Error> {
11 value.serialize(Serializer)
12}
13
14pub fn from_value<T: de::DeserializeOwned>(value: JsonValue) -> Result<T, Error> {
15 T::deserialize(value)
16}
17
18impl ser::Serializer for Serializer {
19 type Ok = JsonValue;
20 type Error = Error;
21
22 type SerializeSeq = SerializeArray;
23 type SerializeTuple = SerializeArray;
24 type SerializeTupleStruct = SerializeArray;
25 type SerializeTupleVariant = SerializeVariant;
26 type SerializeMap = SerializeObject;
27 type SerializeStruct = SerializeObject;
28 type SerializeStructVariant = SerializeVariant;
29
30 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
31 Ok(JsonValue::Boolean(JsonBoolean { value: v, span: (0..0).into() }))
32 }
33
34 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
35 self.serialize_f64(v as f64)
36 }
37 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
38 self.serialize_f64(v as f64)
39 }
40 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
41 self.serialize_f64(v as f64)
42 }
43 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
44 self.serialize_f64(v as f64)
45 }
46 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
47 self.serialize_f64(v as f64)
48 }
49 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
50 self.serialize_f64(v as f64)
51 }
52 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
53 self.serialize_f64(v as f64)
54 }
55 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
56 self.serialize_f64(v as f64)
57 }
58 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
59 self.serialize_f64(v as f64)
60 }
61 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
62 Ok(JsonValue::Number(JsonNumber { value: v, span: (0..0).into() }))
63 }
64
65 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
66 self.serialize_str(&v.to_string())
67 }
68
69 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
70 Ok(JsonValue::String(JsonString { value: v.to_string(), span: (0..0).into() }))
71 }
72
73 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
74 let elements = v.iter().map(|&b| JsonValue::Number(JsonNumber { value: b as f64, span: (0..0).into() })).collect();
75 Ok(JsonValue::Array(JsonArray { elements, span: (0..0).into() }))
76 }
77
78 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
79 Ok(JsonValue::Null(JsonNull { span: (0..0).into() }))
80 }
81
82 fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
83 value.serialize(self)
84 }
85
86 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
87 self.serialize_none()
88 }
89
90 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
91 self.serialize_unit()
92 }
93
94 fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
95 self.serialize_str(variant)
96 }
97
98 fn serialize_newtype_struct<T: ?Sized + Serialize>(self, _name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
99 value.serialize(self)
100 }
101
102 fn serialize_newtype_variant<T: ?Sized + Serialize>(self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
103 let mut fields = Vec::new();
104 fields.push(JsonField { name: JsonString { value: variant.to_string(), span: (0..0).into() }, value: value.serialize(self)?, span: (0..0).into() });
105 Ok(JsonValue::Object(JsonObject { fields, span: (0..0).into() }))
106 }
107
108 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
109 Ok(SerializeArray { elements: Vec::with_capacity(len.unwrap_or(0)) })
110 }
111
112 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
113 self.serialize_seq(Some(len))
114 }
115
116 fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
117 self.serialize_seq(Some(len))
118 }
119
120 fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
121 Ok(SerializeVariant { name: variant.to_string(), elements: Vec::with_capacity(len) })
122 }
123
124 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
125 Ok(SerializeObject { fields: Vec::with_capacity(len.unwrap_or(0)), current_key: None })
126 }
127
128 fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
129 self.serialize_map(Some(len))
130 }
131
132 fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
133 Ok(SerializeVariant { name: variant.to_string(), elements: Vec::with_capacity(len) })
134 }
135}
136
137pub struct SerializeArray {
138 elements: Vec<JsonValue>,
139}
140
141impl ser::SerializeSeq for SerializeArray {
142 type Ok = JsonValue;
143 type Error = Error;
144
145 fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
146 self.elements.push(value.serialize(Serializer)?);
147 Ok(())
148 }
149
150 fn end(self) -> Result<Self::Ok, Self::Error> {
151 Ok(JsonValue::Array(JsonArray { elements: self.elements, span: (0..0).into() }))
152 }
153}
154
155impl ser::SerializeTuple for SerializeArray {
156 type Ok = JsonValue;
157 type Error = Error;
158
159 fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
160 ser::SerializeSeq::serialize_element(self, value)
161 }
162
163 fn end(self) -> Result<Self::Ok, Self::Error> {
164 ser::SerializeSeq::end(self)
165 }
166}
167
168impl ser::SerializeTupleStruct for SerializeArray {
169 type Ok = JsonValue;
170 type Error = Error;
171
172 fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
173 ser::SerializeSeq::serialize_element(self, value)
174 }
175
176 fn end(self) -> Result<Self::Ok, Self::Error> {
177 ser::SerializeSeq::end(self)
178 }
179}
180
181pub struct SerializeObject {
182 fields: Vec<JsonField>,
183 current_key: Option<String>,
184}
185
186impl ser::SerializeMap for SerializeObject {
187 type Ok = JsonValue;
188 type Error = Error;
189
190 fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
191 self.current_key = Some(key.serialize(KeySerializer)?);
192 Ok(())
193 }
194
195 fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
196 let key = self.current_key.take().ok_or_else(|| <Self::Error as ser::Error>::custom("serialize_value called before serialize_key"))?;
197 self.fields.push(JsonField { name: JsonString { value: key, span: (0..0).into() }, value: value.serialize(Serializer)?, span: (0..0).into() });
198 Ok(())
199 }
200
201 fn end(self) -> Result<Self::Ok, Self::Error> {
202 Ok(JsonValue::Object(JsonObject { fields: self.fields, span: (0..0).into() }))
203 }
204}
205
206impl ser::SerializeStruct for SerializeObject {
207 type Ok = JsonValue;
208 type Error = Error;
209
210 fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
211 self.fields.push(JsonField { name: JsonString { value: key.to_string(), span: (0..0).into() }, value: value.serialize(Serializer)?, span: (0..0).into() });
212 Ok(())
213 }
214
215 fn end(self) -> Result<Self::Ok, Self::Error> {
216 Ok(JsonValue::Object(JsonObject { fields: self.fields, span: (0..0).into() }))
217 }
218}
219
220pub struct SerializeVariant {
221 name: String,
222 elements: Vec<JsonValue>,
223}
224
225impl ser::SerializeTupleVariant for SerializeVariant {
226 type Ok = JsonValue;
227 type Error = Error;
228
229 fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
230 self.elements.push(value.serialize(Serializer)?);
231 Ok(())
232 }
233
234 fn end(self) -> Result<Self::Ok, Self::Error> {
235 let mut fields = Vec::new();
236 fields.push(JsonField { name: JsonString { value: self.name, span: (0..0).into() }, value: JsonValue::Array(JsonArray { elements: self.elements, span: (0..0).into() }), span: (0..0).into() });
237 Ok(JsonValue::Object(JsonObject { fields, span: (0..0).into() }))
238 }
239}
240
241impl ser::SerializeStructVariant for SerializeVariant {
242 type Ok = JsonValue;
243 type Error = Error;
244
245 fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
246 self.elements.push(JsonValue::Object(JsonObject { fields: vec![JsonField { name: JsonString { value: key.to_string(), span: (0..0).into() }, value: value.serialize(Serializer)?, span: (0..0).into() }], span: (0..0).into() }));
247 Ok(())
248 }
249
250 fn end(self) -> Result<Self::Ok, Self::Error> {
251 let mut fields = Vec::new();
252 fields.push(JsonField { name: JsonString { value: self.name, span: (0..0).into() }, value: JsonValue::Array(JsonArray { elements: self.elements, span: (0..0).into() }), span: (0..0).into() });
253 Ok(JsonValue::Object(JsonObject { fields, span: (0..0).into() }))
254 }
255}
256
257struct KeySerializer;
258
259impl ser::Serializer for KeySerializer {
260 type Ok = String;
261 type Error = Error;
262 type SerializeSeq = ser::Impossible<String, Error>;
263 type SerializeTuple = ser::Impossible<String, Error>;
264 type SerializeTupleStruct = ser::Impossible<String, Error>;
265 type SerializeTupleVariant = ser::Impossible<String, Error>;
266 type SerializeMap = ser::Impossible<String, Error>;
267 type SerializeStruct = ser::Impossible<String, Error>;
268 type SerializeStructVariant = ser::Impossible<String, Error>;
269
270 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
271 Ok(v.to_string())
272 }
273 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
274 Ok(v.to_string())
275 }
276 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
277 Ok(v.to_string())
278 }
279 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
280 Ok(v.to_string())
281 }
282 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
283 Ok(v.to_string())
284 }
285 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
286 Ok(v.to_string())
287 }
288 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
289 Ok(v.to_string())
290 }
291 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
292 Ok(v.to_string())
293 }
294 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
295 Ok(v.to_string())
296 }
297 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
298 Ok(v.to_string())
299 }
300 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
301 Ok(v.to_string())
302 }
303 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
304 Ok(v.to_string())
305 }
306 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
307 Ok(v.to_string())
308 }
309 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
310 Err(<Error as ser::Error>::custom("bytes cannot be a map key"))
311 }
312 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
313 Err(<Error as ser::Error>::custom("none cannot be a map key"))
314 }
315 fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> Result<Self::Ok, Self::Error> {
316 Err(<Error as ser::Error>::custom("some cannot be a map key"))
317 }
318 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
319 Err(<Error as ser::Error>::custom("unit cannot be a map key"))
320 }
321 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
322 Err(<Error as ser::Error>::custom("unit struct cannot be a map key"))
323 }
324 fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
325 Ok(variant.to_string())
326 }
327 fn serialize_newtype_struct<T: ?Sized + Serialize>(self, _name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
328 value.serialize(self)
329 }
330 fn serialize_newtype_variant<T: ?Sized + Serialize>(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T) -> Result<Self::Ok, Self::Error> {
331 Err(<Error as ser::Error>::custom("variant cannot be a map key"))
332 }
333 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
334 Err(<Error as ser::Error>::custom("seq cannot be a map key"))
335 }
336 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
337 Err(<Error as ser::Error>::custom("tuple cannot be a map key"))
338 }
339 fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
340 Err(<Error as ser::Error>::custom("tuple struct cannot be a map key"))
341 }
342 fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
343 Err(<Error as ser::Error>::custom("tuple variant cannot be a map key"))
344 }
345 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
346 Err(<Error as ser::Error>::custom("map cannot be a map key"))
347 }
348 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error> {
349 Err(<Error as ser::Error>::custom("struct cannot be a map key"))
350 }
351 fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
352 Err(<Error as ser::Error>::custom("struct variant cannot be a map key"))
353 }
354}
355
356impl<'de> de::Deserializer<'de> for JsonValue {
357 type Error = Error;
358
359 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
360 where
361 V: Visitor<'de>,
362 {
363 match self {
364 JsonValue::Null(_) => visitor.visit_unit(),
365 JsonValue::Boolean(b) => visitor.visit_bool(b.value),
366 JsonValue::Number(n) => visitor.visit_f64(n.value),
367 JsonValue::String(s) => visitor.visit_string(s.value),
368 JsonValue::Array(a) => visitor.visit_seq(SeqDeserializer::new(a.elements)),
369 JsonValue::Object(o) => visitor.visit_map(MapDeserializer::new(o.fields)),
370 }
371 }
372
373 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
374 where
375 V: Visitor<'de>,
376 {
377 match self {
378 JsonValue::Null(_) => visitor.visit_none(),
379 _ => visitor.visit_some(self),
380 }
381 }
382
383 fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
384 where
385 V: Visitor<'de>,
386 {
387 match self {
388 JsonValue::String(s) => visitor.visit_enum(EnumDeserializer::new(s.value, None)),
389 JsonValue::Object(o) => {
390 if o.fields.len() != 1 {
391 return Err(<Error as de::Error>::custom(format!("Expected object with 1 field for enum, found {}", o.fields.len())));
392 }
393 let field = &o.fields[0];
394 visitor.visit_enum(EnumDeserializer::new(field.name.value.clone(), Some(field.value.clone())))
395 }
396 _ => Err(<Error as de::Error>::custom(format!("Expected string or object for enum, found {:?}", self))),
397 }
398 }
399
400 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
401 where
402 V: Visitor<'de>,
403 {
404 visitor.visit_newtype_struct(self)
405 }
406
407 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
408 where
409 V: Visitor<'de>,
410 {
411 self.deserialize_any(visitor)
412 }
413 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
414 where
415 V: Visitor<'de>,
416 {
417 self.deserialize_any(visitor)
418 }
419 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
420 where
421 V: Visitor<'de>,
422 {
423 self.deserialize_any(visitor)
424 }
425 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
426 where
427 V: Visitor<'de>,
428 {
429 self.deserialize_any(visitor)
430 }
431 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
432 where
433 V: Visitor<'de>,
434 {
435 self.deserialize_any(visitor)
436 }
437 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
438 where
439 V: Visitor<'de>,
440 {
441 self.deserialize_any(visitor)
442 }
443 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
444 where
445 V: Visitor<'de>,
446 {
447 self.deserialize_any(visitor)
448 }
449 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
450 where
451 V: Visitor<'de>,
452 {
453 self.deserialize_any(visitor)
454 }
455 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
456 where
457 V: Visitor<'de>,
458 {
459 self.deserialize_any(visitor)
460 }
461 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
462 where
463 V: Visitor<'de>,
464 {
465 self.deserialize_any(visitor)
466 }
467 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
468 where
469 V: Visitor<'de>,
470 {
471 self.deserialize_any(visitor)
472 }
473 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
474 where
475 V: Visitor<'de>,
476 {
477 self.deserialize_any(visitor)
478 }
479 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
480 where
481 V: Visitor<'de>,
482 {
483 self.deserialize_any(visitor)
484 }
485 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
486 where
487 V: Visitor<'de>,
488 {
489 self.deserialize_any(visitor)
490 }
491 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
492 where
493 V: Visitor<'de>,
494 {
495 self.deserialize_any(visitor)
496 }
497 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
498 where
499 V: Visitor<'de>,
500 {
501 self.deserialize_any(visitor)
502 }
503 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
504 where
505 V: Visitor<'de>,
506 {
507 self.deserialize_any(visitor)
508 }
509 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
510 where
511 V: Visitor<'de>,
512 {
513 self.deserialize_any(visitor)
514 }
515 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
516 where
517 V: Visitor<'de>,
518 {
519 self.deserialize_any(visitor)
520 }
521 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
522 where
523 V: Visitor<'de>,
524 {
525 self.deserialize_any(visitor)
526 }
527 fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
528 where
529 V: Visitor<'de>,
530 {
531 self.deserialize_any(visitor)
532 }
533 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
534 where
535 V: Visitor<'de>,
536 {
537 self.deserialize_any(visitor)
538 }
539 fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
540 where
541 V: Visitor<'de>,
542 {
543 self.deserialize_any(visitor)
544 }
545 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
546 where
547 V: Visitor<'de>,
548 {
549 self.deserialize_any(visitor)
550 }
551 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
552 where
553 V: Visitor<'de>,
554 {
555 self.deserialize_any(visitor)
556 }
557}
558
559struct SeqDeserializer {
560 iter: std::vec::IntoIter<JsonValue>,
561}
562
563impl SeqDeserializer {
564 fn new(elements: Vec<JsonValue>) -> Self {
565 Self { iter: elements.into_iter() }
566 }
567}
568
569impl<'de> de::SeqAccess<'de> for SeqDeserializer {
570 type Error = Error;
571
572 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
573 where
574 T: de::DeserializeSeed<'de>,
575 {
576 match self.iter.next() {
577 Some(value) => seed.deserialize(value).map(Some),
578 None => Ok(None),
579 }
580 }
581}
582
583struct MapDeserializer {
584 iter: std::vec::IntoIter<JsonField>,
585 value: Option<JsonValue>,
586}
587
588impl MapDeserializer {
589 fn new(fields: Vec<JsonField>) -> Self {
590 Self { iter: fields.into_iter(), value: None }
591 }
592}
593
594impl<'de> de::MapAccess<'de> for MapDeserializer {
595 type Error = Error;
596
597 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
598 where
599 K: de::DeserializeSeed<'de>,
600 {
601 match self.iter.next() {
602 Some(field) => {
603 self.value = Some(field.value);
604 seed.deserialize(JsonValue::String(field.name)).map(Some)
605 }
606 None => Ok(None),
607 }
608 }
609
610 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
611 where
612 V: de::DeserializeSeed<'de>,
613 {
614 match self.value.take() {
615 Some(value) => seed.deserialize(value),
616 None => Err(<Error as de::Error>::custom("next_value_seed called before next_key_seed")),
617 }
618 }
619}
620
621struct EnumDeserializer {
622 variant: String,
623 value: Option<JsonValue>,
624}
625
626impl EnumDeserializer {
627 fn new(variant: String, value: Option<JsonValue>) -> Self {
628 Self { variant, value }
629 }
630}
631
632impl<'de> de::EnumAccess<'de> for EnumDeserializer {
633 type Error = Error;
634 type Variant = VariantDeserializer;
635
636 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
637 where
638 V: de::DeserializeSeed<'de>,
639 {
640 let variant = seed.deserialize(de::value::StrDeserializer::<Error>::new(&self.variant))?;
641 Ok((variant, VariantDeserializer { value: self.value }))
642 }
643}
644
645struct VariantDeserializer {
646 value: Option<JsonValue>,
647}
648
649impl<'de> de::VariantAccess<'de> for VariantDeserializer {
650 type Error = Error;
651
652 fn unit_variant(self) -> Result<(), Self::Error> {
653 match self.value {
654 Some(_) => Err(<Error as de::Error>::custom("Expected unit variant")),
655 None => Ok(()),
656 }
657 }
658
659 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
660 where
661 T: de::DeserializeSeed<'de>,
662 {
663 match self.value {
664 Some(value) => seed.deserialize(value),
665 None => Err(<Error as de::Error>::custom("Expected newtype variant")),
666 }
667 }
668
669 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
670 where
671 V: Visitor<'de>,
672 {
673 match self.value {
674 Some(JsonValue::Array(a)) => visitor.visit_seq(SeqDeserializer::new(a.elements)),
675 _ => Err(<Error as de::Error>::custom("Expected tuple variant")),
676 }
677 }
678
679 fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
680 where
681 V: Visitor<'de>,
682 {
683 match self.value {
684 Some(JsonValue::Object(o)) => visitor.visit_map(MapDeserializer::new(o.fields)),
685 _ => Err(<Error as de::Error>::custom("Expected struct variant")),
686 }
687 }
688}