oak_json/language/
serde_impl.rs

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

oak_json/language/
serde_impl.rs
