rune/runtime/value/
serde.rs

Help
1use core::fmt;
2
3use crate::alloc;
4use crate::alloc::prelude::*;
5use crate::runtime::{self, Bytes, Inline, Object, OwnedTuple, Repr, RttiKind, Vec};
6use crate::TypeHash;
7
8use serde::de::{self, Deserialize as _, Error as _};
9use serde::ser::{self, Error as _, SerializeMap as _, SerializeSeq as _};
10
11use super::Value;
12
13/// Deserialize implementation for value pointers.
14impl<'de> de::Deserialize<'de> for Value {
15    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
16    where
17        D: de::Deserializer<'de>,
18    {
19        deserializer.deserialize_any(VmVisitor)
20    }
21}
22
23/// Serialize implementation for value pointers.
24impl ser::Serialize for Value {
25    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
26    where
27        S: ser::Serializer,
28    {
29        match self.as_ref() {
30            Repr::Inline(value) => match *value {
31                Inline::Empty => Err(ser::Error::custom("cannot serialize empty values")),
32                Inline::Unit => serializer.serialize_unit(),
33                Inline::Bool(value) => serializer.serialize_bool(value),
34                Inline::Char(value) => serializer.serialize_char(value),
35                Inline::Unsigned(value) => serializer.serialize_u64(value),
36                Inline::Signed(value) => serializer.serialize_i64(value),
37                Inline::Float(value) => serializer.serialize_f64(value),
38                Inline::Type(..) => Err(ser::Error::custom("cannot serialize types")),
39                Inline::Ordering(..) => Err(ser::Error::custom("cannot serialize orderings")),
40                Inline::Hash(..) => Err(ser::Error::custom("cannot serialize type hashes")),
41            },
42            Repr::Dynamic(value) => match value.rtti().kind {
43                RttiKind::Empty => Err(ser::Error::custom(format!(
44                    "cannot serialize empty struct {}",
45                    value.rtti().item
46                ))),
47                RttiKind::Tuple => Err(ser::Error::custom(format!(
48                    "cannot serialize tuple struct {}",
49                    value.rtti().item
50                ))),
51                RttiKind::Struct => Err(ser::Error::custom(format!(
52                    "cannot serialize struct {}",
53                    value.rtti().item
54                ))),
55            },
56            Repr::Any(value) => match value.type_hash() {
57                Option::<Value>::HASH => {
58                    let option = value
59                        .borrow_ref::<Option<Value>>()
60                        .map_err(S::Error::custom)?;
61                    <Option<Value>>::serialize(&option, serializer)
62                }
63                String::HASH => {
64                    let string = value.borrow_ref::<String>().map_err(S::Error::custom)?;
65                    serializer.serialize_str(string.as_str())
66                }
67                Bytes::HASH => {
68                    let bytes = value.borrow_ref::<Bytes>().map_err(S::Error::custom)?;
69                    serializer.serialize_bytes(bytes.as_slice())
70                }
71                runtime::Vec::HASH => {
72                    let vec = value.borrow_ref::<Vec>().map_err(S::Error::custom)?;
73                    let mut serializer = serializer.serialize_seq(Some(vec.len()))?;
74
75                    for value in vec.iter() {
76                        serializer.serialize_element(value)?;
77                    }
78
79                    serializer.end()
80                }
81                OwnedTuple::HASH => {
82                    let tuple = value.borrow_ref::<OwnedTuple>().map_err(S::Error::custom)?;
83                    let mut serializer = serializer.serialize_seq(Some(tuple.len()))?;
84
85                    for value in tuple.iter() {
86                        serializer.serialize_element(value)?;
87                    }
88
89                    serializer.end()
90                }
91                Object::HASH => {
92                    let object = value.borrow_ref::<Object>().map_err(S::Error::custom)?;
93                    let mut serializer = serializer.serialize_map(Some(object.len()))?;
94
95                    for (key, value) in object.iter() {
96                        serializer.serialize_entry(key, value)?;
97                    }
98
99                    serializer.end()
100                }
101                _ => Err(ser::Error::custom("cannot serialize external references")),
102            },
103        }
104    }
105}
106
107struct VmVisitor;
108
109impl<'de> de::Visitor<'de> for VmVisitor {
110    type Value = Value;
111
112    #[inline]
113    fn expecting(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
114        fmt.write_str("any valid value")
115    }
116
117    #[inline]
118    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
119    where
120        E: de::Error,
121    {
122        let v = v.try_to_owned().map_err(E::custom)?;
123        Value::try_from(v).map_err(E::custom)
124    }
125
126    #[inline]
127    fn visit_string<E>(self, v: ::rust_alloc::string::String) -> Result<Self::Value, E>
128    where
129        E: de::Error,
130    {
131        let v = alloc::String::try_from(v).map_err(E::custom)?;
132        Value::try_from(v).map_err(E::custom)
133    }
134
135    #[inline]
136    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
137    where
138        E: de::Error,
139    {
140        let v = alloc::Vec::try_from(v).map_err(E::custom)?;
141        let v = Bytes::from_vec(v);
142        Value::try_from(v).map_err(E::custom)
143    }
144
145    #[inline]
146    fn visit_byte_buf<E>(self, v: ::rust_alloc::vec::Vec<u8>) -> Result<Self::Value, E>
147    where
148        E: de::Error,
149    {
150        let v = alloc::Vec::try_from(v).map_err(E::custom)?;
151        let v = Bytes::from_vec(v);
152        Value::try_from(v).map_err(E::custom)
153    }
154
155    #[inline]
156    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
157    where
158        E: de::Error,
159    {
160        Ok(Value::from(v as i64))
161    }
162
163    #[inline]
164    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
165    where
166        E: de::Error,
167    {
168        Ok(Value::from(v as i64))
169    }
170
171    #[inline]
172    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
173    where
174        E: de::Error,
175    {
176        Ok(Value::from(v as i64))
177    }
178
179    #[inline]
180    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
181    where
182        E: de::Error,
183    {
184        Ok(Value::from(v))
185    }
186
187    #[inline]
188    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
189    where
190        E: de::Error,
191    {
192        Ok(Value::from(v as i64))
193    }
194
195    #[inline]
196    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
197    where
198        E: de::Error,
199    {
200        Ok(Value::from(v as i64))
201    }
202
203    #[inline]
204    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
205    where
206        E: de::Error,
207    {
208        Ok(Value::from(v as i64))
209    }
210
211    #[inline]
212    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
213    where
214        E: de::Error,
215    {
216        Ok(Value::from(v as i64))
217    }
218
219    #[inline]
220    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
221    where
222        E: de::Error,
223    {
224        Ok(Value::from(v as i64))
225    }
226
227    #[inline]
228    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
229    where
230        E: de::Error,
231    {
232        Ok(Value::from(v as i64))
233    }
234
235    #[inline]
236    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
237    where
238        E: de::Error,
239    {
240        Ok(Value::from(v as f64))
241    }
242
243    #[inline]
244    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
245    where
246        E: de::Error,
247    {
248        Ok(Value::from(v))
249    }
250
251    #[inline]
252    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
253    where
254        E: de::Error,
255    {
256        Ok(Value::from(v))
257    }
258
259    #[inline]
260    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
261    where
262        D: serde::Deserializer<'de>,
263    {
264        let some = Some(Value::deserialize(deserializer)?);
265        Value::try_from(some).map_err(D::Error::custom)
266    }
267
268    #[inline]
269    fn visit_none<E>(self) -> Result<Self::Value, E>
270    where
271        E: de::Error,
272    {
273        Value::try_from(None).map_err(E::custom)
274    }
275
276    #[inline]
277    fn visit_unit<E>(self) -> Result<Self::Value, E>
278    where
279        E: de::Error,
280    {
281        Ok(Value::unit())
282    }
283
284    #[inline]
285    fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
286    where
287        V: de::SeqAccess<'de>,
288    {
289        let mut vec = if let Some(hint) = visitor.size_hint() {
290            alloc::Vec::try_with_capacity(hint).map_err(V::Error::custom)?
291        } else {
292            alloc::Vec::new()
293        };
294
295        while let Some(elem) = visitor.next_element()? {
296            vec.try_push(elem).map_err(V::Error::custom)?;
297        }
298
299        let vec = Vec::from(vec);
300        Value::try_from(vec).map_err(V::Error::custom)
301    }
302
303    #[inline]
304    fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
305    where
306        V: de::MapAccess<'de>,
307    {
308        let mut object = Object::new();
309
310        while let Some((key, value)) = visitor.next_entry()? {
311            object.insert(key, value).map_err(V::Error::custom)?;
312        }
313
314        Value::try_from(object).map_err(V::Error::custom)
315    }
316}
rune/runtime/value/serde.rs

rune/runtime/value/
serde.rs
