oak_json/language/
de.rs

1use serde::de::{self, Deserializer, SeqAccess, Visitor};
2use std::fmt;
3
4use crate::ast::{JsonArray, JsonField, JsonObject, JsonRoot, JsonValueNode};
5use oak_core::OakError;
6
7/// JSON 反序列化实现
8pub fn deserialize<'de, D>(deserializer: D) -> Result<JsonValueNode, D::Error>
9where
10    D: Deserializer<'de>,
11{
12    deserializer.deserialize_any(JsonDeserializer {})
13}
14
15struct JsonDeserializer;
16
17impl<'de> Visitor<'de> for JsonDeserializer {
18    type Value = JsonValueNode;
19
20    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
21        formatter.write_str("a valid JSON value")
22    }
23
24    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
25    where
26        E: de::Error,
27    {
28        Ok(JsonValueNode::Boolean(crate::ast::JsonBoolean { span: (0..0).into(), value: v }))
29    }
30
31    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
32    where
33        E: de::Error,
34    {
35        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
36    }
37
38    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
39    where
40        E: de::Error,
41    {
42        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
43    }
44
45    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
46    where
47        E: de::Error,
48    {
49        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
50    }
51
52    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
53    where
54        E: de::Error,
55    {
56        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
57    }
58
59    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
60    where
61        E: de::Error,
62    {
63        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
64    }
65
66    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
67    where
68        E: de::Error,
69    {
70        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
71    }
72
73    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
74    where
75        E: de::Error,
76    {
77        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
78    }
79
80    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
81    where
82        E: de::Error,
83    {
84        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
85    }
86
87    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
88    where
89        E: de::Error,
90    {
91        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v as f64 }))
92    }
93
94    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
95    where
96        E: de::Error,
97    {
98        Ok(JsonValueNode::Number(crate::ast::JsonNumber { span: (0..0).into(), value: v }))
99    }
100
101    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
102    where
103        E: de::Error,
104    {
105        Ok(JsonValueNode::String(crate::ast::JsonString { span: (0..0).into(), value: v.to_string() }))
106    }
107
108    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
109    where
110        E: de::Error,
111    {
112        Ok(JsonValueNode::String(crate::ast::JsonString { span: (0..0).into(), value: v.to_string() }))
113    }
114
115    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
116    where
117        E: de::Error,
118    {
119        Ok(JsonValueNode::String(crate::ast::JsonString { span: (0..0).into(), value: v }))
120    }
121
122    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
123    where
124        E: de::Error,
125    {
126        Ok(JsonValueNode::String(crate::ast::JsonString { span: (0..0).into(), value: String::from_utf8_lossy(v).to_string() }))
127    }
128
129    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
130    where
131        E: de::Error,
132    {
133        Ok(JsonValueNode::String(crate::ast::JsonString { span: (0..0).into(), value: String::from_utf8_lossy(&v).to_string() }))
134    }
135
136    fn visit_none<E>(self) -> Result<Self::Value, E>
137    where
138        E: de::Error,
139    {
140        Ok(JsonValueNode::Null(crate::ast::JsonNull { span: (0..0).into() }))
141    }
142
143    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
144    where
145        D: Deserializer<'de>,
146    {
147        deserializer.deserialize_any(self)
148    }
149
150    fn visit_unit<E>(self) -> Result<Self::Value, E>
151    where
152        E: de::Error,
153    {
154        Ok(JsonValueNode::Null(crate::ast::JsonNull { span: (0..0).into() }))
155    }
156
157    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
158    where
159        D: Deserializer<'de>,
160    {
161        deserializer.deserialize_any(self)
162    }
163
164    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
165    where
166        A: SeqAccess<'de>,
167    {
168        let mut elements = Vec::new();
169        while let Some(elem) = seq.next_element()? {
170            elements.push(elem);
171        }
172        Ok(JsonValueNode::Array(JsonArray { span: (0..0).into(), elements }))
173    }
174
175    fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
176    where
177        M: de::MapAccess<'de>,
178    {
179        let mut fields = Vec::new();
180        while let Some((key, value)) = map.next_entry()? {
181            let json_string = crate::ast::JsonString { span: (0..0).into(), value: key };
182            fields.push(JsonField { span: (0..0).into(), name: json_string, value });
183        }
184        Ok(JsonValueNode::Object(JsonObject { fields, span: (0..0).into() }))
185    }
186
187    fn visit_enum<A>(self, _variant: A) -> Result<Self::Value, A::Error>
188    where
189        A: de::EnumAccess<'de>,
190    {
191        Err(de::Error::custom("enums are not supported"))
192    }
193}
194
195/// Deserializes a JSON string into a Rust type.
196pub fn from_str<'de, T>(json: &'de str) -> Result<T, OakError>
197where
198    T: serde::Deserialize<'de>,
199{
200    // 直接使用 serde_json 来反序列化 JSON 字符串
201    serde_json::from_str(json).map_err(|e| OakError::custom_error(format!("{:?}", e)))
202}
203
204struct JsonValueDeserializer {
205    value: JsonValueNode,
206}
207
208impl JsonValueDeserializer {
209    fn new(value: JsonValueNode) -> Self {
210        Self { value }
211    }
212}
213
214impl<'de> serde::de::Deserializer<'de> for JsonValueDeserializer {
215    type Error = OakError;
216
217    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
218    where
219        V: serde::de::Visitor<'de>,
220    {
221        match self.value {
222            JsonValueNode::Null(_) => visitor.visit_none(),
223            JsonValueNode::Boolean(b) => visitor.visit_bool(b.value),
224            JsonValueNode::Number(n) => visitor.visit_f64(n.value),
225            JsonValueNode::String(s) => visitor.visit_str(&s.value),
226            JsonValueNode::Array(seq) => visitor.visit_seq(JsonArrayAccess::new(seq.elements)),
227            JsonValueNode::Object(map) => visitor.visit_map(JsonMapAccess::new(map.fields)),
228        }
229    }
230
231    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
232    where
233        V: serde::de::Visitor<'de>,
234    {
235        self.deserialize_any(visitor)
236    }
237
238    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
239    where
240        V: serde::de::Visitor<'de>,
241    {
242        self.deserialize_any(visitor)
243    }
244
245    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
246    where
247        V: serde::de::Visitor<'de>,
248    {
249        self.deserialize_any(visitor)
250    }
251
252    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
253    where
254        V: serde::de::Visitor<'de>,
255    {
256        self.deserialize_any(visitor)
257    }
258
259    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
260    where
261        V: serde::de::Visitor<'de>,
262    {
263        self.deserialize_any(visitor)
264    }
265
266    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
267    where
268        V: serde::de::Visitor<'de>,
269    {
270        self.deserialize_any(visitor)
271    }
272
273    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
274    where
275        V: serde::de::Visitor<'de>,
276    {
277        self.deserialize_any(visitor)
278    }
279
280    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
281    where
282        V: serde::de::Visitor<'de>,
283    {
284        self.deserialize_any(visitor)
285    }
286
287    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
288    where
289        V: serde::de::Visitor<'de>,
290    {
291        self.deserialize_any(visitor)
292    }
293
294    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
295    where
296        V: serde::de::Visitor<'de>,
297    {
298        self.deserialize_any(visitor)
299    }
300
301    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
302    where
303        V: serde::de::Visitor<'de>,
304    {
305        self.deserialize_any(visitor)
306    }
307
308    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
309    where
310        V: serde::de::Visitor<'de>,
311    {
312        self.deserialize_any(visitor)
313    }
314
315    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
316    where
317        V: serde::de::Visitor<'de>,
318    {
319        self.deserialize_any(visitor)
320    }
321
322    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
323    where
324        V: serde::de::Visitor<'de>,
325    {
326        self.deserialize_any(visitor)
327    }
328
329    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
330    where
331        V: serde::de::Visitor<'de>,
332    {
333        self.deserialize_any(visitor)
334    }
335
336    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
337    where
338        V: serde::de::Visitor<'de>,
339    {
340        self.deserialize_any(visitor)
341    }
342
343    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
344    where
345        V: serde::de::Visitor<'de>,
346    {
347        self.deserialize_any(visitor)
348    }
349
350    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
351    where
352        V: serde::de::Visitor<'de>,
353    {
354        self.deserialize_any(visitor)
355    }
356
357    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
358    where
359        V: serde::de::Visitor<'de>,
360    {
361        self.deserialize_any(visitor)
362    }
363
364    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
365    where
366        V: serde::de::Visitor<'de>,
367    {
368        self.deserialize_any(visitor)
369    }
370
371    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
372    where
373        V: serde::de::Visitor<'de>,
374    {
375        self.deserialize_any(visitor)
376    }
377
378    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
379    where
380        V: serde::de::Visitor<'de>,
381    {
382        self.deserialize_any(visitor)
383    }
384
385    fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
386    where
387        V: serde::de::Visitor<'de>,
388    {
389        self.deserialize_any(visitor)
390    }
391
392    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
393    where
394        V: serde::de::Visitor<'de>,
395    {
396        self.deserialize_any(visitor)
397    }
398
399    fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
400    where
401        V: serde::de::Visitor<'de>,
402    {
403        self.deserialize_any(visitor)
404    }
405
406    fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], _visitor: V) -> Result<V::Value, Self::Error>
407    where
408        V: serde::de::Visitor<'de>,
409    {
410        Err(OakError::custom_error("Enums are not supported"))
411    }
412
413    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
414    where
415        V: serde::de::Visitor<'de>,
416    {
417        self.deserialize_any(visitor)
418    }
419
420    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
421    where
422        V: serde::de::Visitor<'de>,
423    {
424        self.deserialize_any(visitor)
425    }
426}
427
428struct JsonArrayAccess {
429    elements: Vec<JsonValueNode>,
430    index: usize,
431}
432
433impl JsonArrayAccess {
434    fn new(elements: Vec<JsonValueNode>) -> Self {
435        Self { elements, index: 0 }
436    }
437}
438
439impl<'de> serde::de::SeqAccess<'de> for JsonArrayAccess {
440    type Error = OakError;
441
442    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
443    where
444        T: serde::de::DeserializeSeed<'de>,
445    {
446        if self.index < self.elements.len() {
447            let value = self.elements[self.index].clone();
448            self.index += 1;
449            seed.deserialize(JsonValueDeserializer::new(value)).map(Some)
450        }
451        else {
452            Ok(None)
453        }
454    }
455
456    fn size_hint(&self) -> Option<usize> {
457        Some(self.elements.len() - self.index)
458    }
459}
460
461struct JsonMapAccess {
462    fields: Vec<JsonField>,
463    index: usize,
464}
465
466impl JsonMapAccess {
467    fn new(fields: Vec<JsonField>) -> Self {
468        Self { fields, index: 0 }
469    }
470}
471
472impl<'de> serde::de::MapAccess<'de> for JsonMapAccess {
473    type Error = OakError;
474
475    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
476    where
477        K: serde::de::DeserializeSeed<'de>,
478    {
479        if self.index < self.fields.len() {
480            let key = self.fields[self.index].name.value.clone();
481            seed.deserialize(serde::de::value::StrDeserializer::new(&key)).map(Some)
482        }
483        else {
484            Ok(None)
485        }
486    }
487
488    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
489    where
490        V: serde::de::DeserializeSeed<'de>,
491    {
492        let value = self.fields[self.index].value.clone();
493        self.index += 1;
494        seed.deserialize(JsonValueDeserializer::new(value))
495    }
496
497    fn size_hint(&self) -> Option<usize> {
498        Some(self.fields.len() - self.index)
499    }
500}
oak_json/language/de.rs

oak_json/language/
de.rs
