oak_json/language/
serde_impl.rs

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

oak_json/language/
serde_impl.rs
