air_interpreter_value/value/
de.rs

1/*
2 * Copyright 2024 Fluence Labs Limited
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/*
18 * This file is based on serde_json crate by Erick Tryzelaar and David Tolnay
19 * licensed under conditions of MIT License and Apache License, Version 2.0.
20 */
21
22use crate::value::JValue;
23use crate::{JsonString, Map};
24use core::fmt;
25use serde::de::{self, Deserialize, DeserializeSeed, MapAccess, SeqAccess, Visitor};
26use serde_json::Number;
27use std::vec::Vec;
28
29impl<'de> Deserialize<'de> for JValue {
30    #[inline]
31    fn deserialize<D>(deserializer: D) -> Result<JValue, D::Error>
32    where
33        D: serde::Deserializer<'de>,
34    {
35        struct ValueVisitor;
36
37        impl<'de> Visitor<'de> for ValueVisitor {
38            type Value = JValue;
39
40            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
41                formatter.write_str("any valid JSON value")
42            }
43
44            #[inline]
45            fn visit_bool<E>(self, value: bool) -> Result<JValue, E> {
46                Ok(JValue::Bool(value))
47            }
48
49            #[inline]
50            fn visit_i64<E>(self, value: i64) -> Result<JValue, E> {
51                Ok(JValue::Number(value.into()))
52            }
53
54            #[inline]
55            fn visit_u64<E>(self, value: u64) -> Result<JValue, E> {
56                Ok(JValue::Number(value.into()))
57            }
58
59            #[inline]
60            fn visit_f64<E>(self, value: f64) -> Result<JValue, E> {
61                Ok(Number::from_f64(value).map_or(JValue::Null, JValue::Number))
62            }
63
64            fn visit_str<E>(self, value: &str) -> Result<JValue, E>
65            where
66                E: serde::de::Error,
67            {
68                Ok(JValue::String(value.into()))
69            }
70
71            #[inline]
72            fn visit_none<E>(self) -> Result<JValue, E> {
73                Ok(JValue::Null)
74            }
75
76            #[inline]
77            fn visit_some<D>(self, deserializer: D) -> Result<JValue, D::Error>
78            where
79                D: serde::Deserializer<'de>,
80            {
81                Deserialize::deserialize(deserializer)
82            }
83
84            #[inline]
85            fn visit_unit<E>(self) -> Result<JValue, E> {
86                Ok(JValue::Null)
87            }
88
89            #[inline]
90            fn visit_seq<V>(self, mut visitor: V) -> Result<JValue, V::Error>
91            where
92                V: SeqAccess<'de>,
93            {
94                let mut vec = Vec::new();
95
96                while let Some(elem) = tri!(visitor.next_element()) {
97                    vec.push(elem);
98                }
99
100                Ok(JValue::Array(vec.into()))
101            }
102
103            fn visit_map<V>(self, mut visitor: V) -> Result<JValue, V::Error>
104            where
105                V: MapAccess<'de>,
106            {
107                match tri!(visitor.next_key_seed(KeyClassifier)) {
108                    Some(KeyClass::Map(first_key)) => {
109                        let mut values = Map::<JsonString, JValue>::new();
110
111                        values.insert(first_key, tri!(visitor.next_value()));
112                        while let Some((key, value)) = tri!(visitor.next_entry::<JsonString, _>()) {
113                            values.insert(key, value);
114                        }
115
116                        Ok(JValue::Object(values.into()))
117                    }
118                    None => Ok(JValue::Object(Map::new().into())),
119                }
120            }
121        }
122
123        deserializer.deserialize_any(ValueVisitor)
124    }
125}
126
127struct KeyClassifier;
128
129enum KeyClass {
130    Map(JsonString),
131}
132
133impl<'de> DeserializeSeed<'de> for KeyClassifier {
134    type Value = KeyClass;
135
136    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
137    where
138        D: serde::Deserializer<'de>,
139    {
140        deserializer.deserialize_str(self)
141    }
142}
143
144impl<'de> Visitor<'de> for KeyClassifier {
145    type Value = KeyClass;
146
147    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
148        formatter.write_str("a string key")
149    }
150
151    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
152    where
153        E: de::Error,
154    {
155        Ok(KeyClass::Map(s.into()))
156    }
157}
air_interpreter_value/value/de.rs

air_interpreter_value/value/
de.rs
