preserves/value/
de.rs

1//! Support Serde deserialization of Rust data types from Preserves *values* (not syntax).
2
3use crate::error::{Error, ExpectedKind, Received};
4use crate::value::repr::Double;
5use crate::value::{IOValue, Map, NestedValue, UnwrappedIOValue, Value};
6use serde::de::{DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
7use serde::Deserialize;
8use std::iter::Iterator;
9
10pub type Result<T> = std::result::Result<T, Error>;
11
12/// Serde deserializer for constructing Rust data from an in-memory Preserves value. Use
13/// [Deserializer::from_value] to construct instances, or [from_value] to deserialize single
14/// values directly.
15pub struct Deserializer<'de> {
16    input: &'de IOValue,
17}
18
19/// Deserialize a `T` from `v`, a Preserves [IOValue].
20pub fn from_value<'a, T>(v: &'a IOValue) -> Result<T>
21where
22    T: Deserialize<'a>,
23{
24    let mut de = Deserializer::from_value(v);
25    let t = T::deserialize(&mut de)?;
26    Ok(t)
27}
28
29impl<'de> Deserializer<'de> {
30    /// Construct a Deserializer from `v`, an [IOValue].
31    pub fn from_value(v: &'de IOValue) -> Self {
32        Deserializer { input: v }
33    }
34
35    fn check<'a, T, F>(&'a mut self, f: F, k: ExpectedKind) -> Result<T>
36    where
37        F: FnOnce(&'de UnwrappedIOValue) -> Option<T>,
38    {
39        f(self.input.value()).ok_or_else(|| {
40            Error::Expected(k, Received::ReceivedOtherValue(format!("{:?}", self.input)))
41        })
42    }
43}
44
45impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de> {
46    type Error = Error;
47
48    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
49    where
50        V: Visitor<'de>,
51    {
52        let v = self.input.value();
53        match v {
54            Value::Boolean(b) => visitor.visit_bool(*b),
55            Value::Double(Double(d)) => visitor.visit_f64(*d),
56            Value::String(ref s) => visitor.visit_str(&s),
57            Value::ByteString(_) => self.deserialize_bytes(visitor),
58            Value::Record(_) => {
59                if v.is_simple_record("tuple", Some(0)) {
60                    self.deserialize_unit(visitor)
61                } else if v.is_simple_record("UnicodeScalar", Some(1)) {
62                    self.deserialize_char(visitor)
63                } else if v.is_simple_record("None", Some(0)) || v.is_simple_record("Some", Some(1))
64                {
65                    self.deserialize_option(visitor)
66                } else if v.is_simple_record("tuple", None) {
67                    visitor.visit_seq(VecSeq::new(
68                        self,
69                        v.as_simple_record("tuple", None).unwrap().iter(),
70                    ))
71                } else {
72                    Err(Error::CannotDeserializeAny)
73                }
74            }
75            Value::Sequence(ref v) => visitor.visit_seq(VecSeq::new(self, v.iter())),
76            Value::Dictionary(ref d) => visitor.visit_map(DictMap::new(self, d)),
77            _ => match v.as_i64() {
78                Some(i) => visitor.visit_i64(i),
79                None => match v.as_u64() {
80                    Some(u) => visitor.visit_u64(u),
81                    None => match v.as_signedinteger() {
82                        Some(n) => Err(Error::NumberOutOfRange(n.into())),
83                        None => Err(Error::CannotDeserializeAny),
84                    },
85                },
86            },
87        }
88    }
89
90    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
91    where
92        V: Visitor<'de>,
93    {
94        visitor.visit_bool(self.input.value().to_boolean()?)
95    }
96
97    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
98    where
99        V: Visitor<'de>,
100    {
101        visitor.visit_i8(self.input.value().to_i8()?)
102    }
103
104    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
105    where
106        V: Visitor<'de>,
107    {
108        visitor.visit_i16(self.input.value().to_i16()?)
109    }
110
111    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
112    where
113        V: Visitor<'de>,
114    {
115        visitor.visit_i32(self.input.value().to_i32()?)
116    }
117
118    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
119    where
120        V: Visitor<'de>,
121    {
122        visitor.visit_i64(self.input.value().to_i64()?)
123    }
124
125    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
126    where
127        V: Visitor<'de>,
128    {
129        visitor.visit_u8(self.input.value().to_u8()?)
130    }
131
132    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
133    where
134        V: Visitor<'de>,
135    {
136        visitor.visit_u16(self.input.value().to_u16()?)
137    }
138
139    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
140    where
141        V: Visitor<'de>,
142    {
143        visitor.visit_u32(self.input.value().to_u32()?)
144    }
145
146    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
147    where
148        V: Visitor<'de>,
149    {
150        visitor.visit_u64(self.input.value().to_u64()?)
151    }
152
153    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
154    where
155        V: Visitor<'de>,
156    {
157        visitor.visit_f32(self.input.value().to_f64()? as f32)
158    }
159
160    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
161    where
162        V: Visitor<'de>,
163    {
164        visitor.visit_f64(self.input.value().to_f64()?)
165    }
166
167    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
168    where
169        V: Visitor<'de>,
170    {
171        visitor.visit_char(self.input.value().to_char()?)
172    }
173
174    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
175    where
176        V: Visitor<'de>,
177    {
178        let s: &'de str = &self.input.value().to_string()?;
179        visitor.visit_borrowed_str(s)
180    }
181
182    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
183    where
184        V: Visitor<'de>,
185    {
186        self.deserialize_str(visitor)
187    }
188
189    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
190    where
191        V: Visitor<'de>,
192    {
193        let bs: &'de [u8] = &self.input.value().to_bytestring()?;
194        visitor.visit_borrowed_bytes(bs)
195    }
196
197    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
198    where
199        V: Visitor<'de>,
200    {
201        visitor.visit_byte_buf(self.input.value().to_bytestring()?.clone())
202    }
203
204    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
205    where
206        V: Visitor<'de>,
207    {
208        match self.input.value().to_option()? {
209            None => visitor.visit_none(),
210            Some(v) => {
211                self.input = v;
212                visitor.visit_some(self)
213            }
214        }
215    }
216
217    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
218    where
219        V: Visitor<'de>,
220    {
221        let _fs = self.input.value().to_simple_record("tuple", Some(0))?;
222        visitor.visit_unit()
223    }
224
225    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
226    where
227        V: Visitor<'de>,
228    {
229        let _fs = self.input.value().to_simple_record(name, Some(0))?;
230        visitor.visit_unit()
231    }
232
233    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
234    where
235        V: Visitor<'de>,
236    {
237        match super::magic::transmit_input_value(name, || Ok(self.input.clone()))? {
238            Some(v) => visitor.visit_u64(v),
239            None => {
240                let fs = self.input.value().to_simple_record(name, Some(1))?;
241                self.input = &fs[0];
242                visitor.visit_newtype_struct(self)
243            }
244        }
245    }
246
247    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
248    where
249        V: Visitor<'de>,
250    {
251        match self.input.value().as_sequence() {
252            Some(vs) => visitor.visit_seq(VecSeq::new(self, vs.iter())),
253            None => {
254                // Hack around serde's model: Deserialize *sets* as
255                // sequences, too, and reconstruct them as Rust Sets
256                // on the visitor side.
257                visitor.visit_seq(VecSeq::new(self, self.input.value().to_set()?.iter()))
258            }
259        }
260    }
261
262    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
263    where
264        V: Visitor<'de>,
265    {
266        let fs = self.input.value().to_simple_record("tuple", Some(len))?;
267        visitor.visit_seq(VecSeq::new(self, fs.iter()))
268    }
269
270    fn deserialize_tuple_struct<V>(
271        self,
272        name: &'static str,
273        len: usize,
274        visitor: V,
275    ) -> Result<V::Value>
276    where
277        V: Visitor<'de>,
278    {
279        let fs = self.input.value().to_simple_record(name, Some(len))?;
280        visitor.visit_seq(VecSeq::new(self, fs.iter()))
281    }
282
283    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
284    where
285        V: Visitor<'de>,
286    {
287        let d = self.input.value().to_dictionary()?;
288        visitor.visit_map(DictMap::new(self, d))
289    }
290
291    fn deserialize_struct<V>(
292        self,
293        name: &'static str,
294        fields: &'static [&'static str],
295        visitor: V,
296    ) -> Result<V::Value>
297    where
298        V: Visitor<'de>,
299    {
300        let fs = self
301            .input
302            .value()
303            .to_simple_record(name, Some(fields.len()))?;
304        visitor.visit_seq(VecSeq::new(self, fs.iter()))
305    }
306
307    fn deserialize_enum<V>(
308        self,
309        _name: &'static str,
310        _variants: &'static [&'static str],
311        visitor: V,
312    ) -> Result<V::Value>
313    where
314        V: Visitor<'de>,
315    {
316        visitor.visit_enum(self)
317    }
318
319    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
320    where
321        V: Visitor<'de>,
322    {
323        visitor.visit_str(&self.input.value().to_symbol()?)
324    }
325
326    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
327    where
328        V: Visitor<'de>,
329    {
330        visitor.visit_none()
331    }
332}
333
334#[doc(hidden)]
335pub struct VecSeq<'a, 'de: 'a, I: Iterator<Item = &'de IOValue>> {
336    iter: I,
337    de: &'a mut Deserializer<'de>,
338}
339
340impl<'de, 'a, I: Iterator<Item = &'de IOValue>> VecSeq<'a, 'de, I> {
341    fn new(de: &'a mut Deserializer<'de>, iter: I) -> Self {
342        VecSeq { iter, de }
343    }
344}
345
346impl<'de, 'a, I: Iterator<Item = &'de IOValue>> SeqAccess<'de> for VecSeq<'a, 'de, I> {
347    type Error = Error;
348
349    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
350    where
351        T: DeserializeSeed<'de>,
352    {
353        match self.iter.next() {
354            None => Ok(None),
355            Some(v) => {
356                self.de.input = v;
357                Ok(Some(seed.deserialize(&mut *self.de)?))
358            }
359        }
360    }
361}
362
363#[doc(hidden)]
364pub struct DictMap<'a, 'de: 'a> {
365    pending: Option<&'de IOValue>,
366    iter: Box<dyn Iterator<Item = (&'de IOValue, &'de IOValue)> + 'a>,
367    de: &'a mut Deserializer<'de>,
368}
369
370impl<'de, 'a> DictMap<'a, 'de> {
371    fn new(de: &'a mut Deserializer<'de>, d: &'de Map<IOValue, IOValue>) -> Self {
372        DictMap {
373            pending: None,
374            iter: Box::new(d.iter()),
375            de,
376        }
377    }
378}
379
380impl<'de, 'a> MapAccess<'de> for DictMap<'a, 'de> {
381    type Error = Error;
382
383    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
384    where
385        K: DeserializeSeed<'de>,
386    {
387        match self.iter.next() {
388            None => Ok(None),
389            Some((k, v)) => {
390                self.pending = Some(v);
391                self.de.input = k;
392                Ok(Some(seed.deserialize(&mut *self.de)?))
393            }
394        }
395    }
396
397    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
398    where
399        V: DeserializeSeed<'de>,
400    {
401        let v = self.pending.unwrap();
402        self.pending = None;
403        self.de.input = v;
404        Ok(seed.deserialize(&mut *self.de)?)
405    }
406}
407
408impl<'a, 'de> EnumAccess<'de> for &'a mut Deserializer<'de> {
409    type Error = Error;
410    type Variant = Self;
411
412    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
413    where
414        V: DeserializeSeed<'de>,
415    {
416        let r = self.check(|v| v.as_record(None), ExpectedKind::Record(None))?;
417        let v = self.input;
418        self.input = r.label();
419        let variant = seed.deserialize(&mut *self)?;
420        self.input = v;
421        Ok((variant, self))
422    }
423}
424
425impl<'a, 'de> VariantAccess<'de> for &'a mut Deserializer<'de> {
426    type Error = Error;
427
428    fn unit_variant(self) -> Result<()> {
429        Ok(())
430    }
431
432    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
433    where
434        T: DeserializeSeed<'de>,
435    {
436        let r = self.check(|v| v.as_record(Some(1)), ExpectedKind::Record(Some(1)))?;
437        self.input = &r.fields()[0];
438        seed.deserialize(&mut *self)
439    }
440
441    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
442    where
443        V: Visitor<'de>,
444    {
445        visitor.visit_seq(VecSeq::new(
446            self,
447            self.input.value().as_record(None).unwrap().fields().iter(),
448        ))
449    }
450
451    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
452    where
453        V: Visitor<'de>,
454    {
455        visitor.visit_seq(VecSeq::new(
456            self,
457            self.input
458                .value()
459                .as_record(Some(fields.len()))
460                .unwrap()
461                .fields()
462                .iter(),
463        ))
464    }
465}
preserves/value/de.rs

preserves/value/
de.rs
