preserves/
de.rs

1//! Support for Serde deserialization of Preserves terms described by Rust data types.
2
3use serde::de::{DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
4use serde::Deserialize;
5
6use std::borrow::Cow;
7use std::io;
8use std::marker::PhantomData;
9
10use super::value::boundary as B;
11use super::value::reader::{BytesBinarySource, IOBinarySource, Reader};
12use super::value::{IOValue, IOValueDomainCodec, PackedReader, TextReader, ViaCodec};
13
14pub use super::error::Error;
15
16/// A [std::result::Result] type including [Error], the Preserves Serde deserialization error
17/// type, as its error.
18pub type Result<T> = std::result::Result<T, Error>;
19
20/// Serde deserializer for Preserves-encoded Rust data. Use [Deserializer::from_reader] to
21/// construct instances, or [from_bytes]/[from_text]/[from_read]/[from_reader] etc to
22/// deserialize single terms directly.
23pub struct Deserializer<'de, 'r, R: Reader<'de, IOValue>> {
24    /// The underlying Preserves [reader][crate::value::reader::Reader].
25    pub read: &'r mut R,
26    phantom: PhantomData<&'de ()>,
27}
28
29/// Deserialize a `T` from `bytes`, which must contain a Preserves [machine-oriented binary
30/// syntax][crate::value::packed] term corresponding to the Serde serialization of a `T`.
31pub fn from_bytes<'de, T>(bytes: &'de [u8]) -> Result<T>
32where
33    T: Deserialize<'de>,
34{
35    from_reader(&mut PackedReader::new(
36        &mut BytesBinarySource::new(bytes),
37        IOValueDomainCodec,
38    ))
39}
40
41/// Deserialize a `T` from `text`, which must contain a Preserves [text
42/// syntax][crate::value::text] term corresponding to the Serde serialization of a `T`.
43pub fn from_text<'de, T>(text: &'de str) -> Result<T>
44where
45    T: Deserialize<'de>,
46{
47    from_reader(&mut TextReader::new(
48        &mut BytesBinarySource::new(text.as_bytes()),
49        ViaCodec::new(IOValueDomainCodec),
50    ))
51}
52
53/// Deserialize a `T` from `read`, which must yield a Preserves [machine-oriented binary
54/// syntax][crate::value::packed] term corresponding to the Serde serialization of a `T`.
55pub fn from_read<'de, 'r, IOR: io::Read + io::Seek, T>(read: &'r mut IOR) -> Result<T>
56where
57    T: Deserialize<'de>,
58{
59    from_reader(&mut PackedReader::new(
60        &mut IOBinarySource::new(read),
61        IOValueDomainCodec,
62    ))
63}
64
65/// Deserialize a `T` from `read`, which must yield a Preserves term corresponding to the Serde
66/// serialization of a `T`.
67pub fn from_reader<'r, 'de, R: Reader<'de, IOValue>, T>(read: &'r mut R) -> Result<T>
68where
69    T: Deserialize<'de>,
70{
71    let mut de = Deserializer::from_reader(read);
72    let t = T::deserialize(&mut de)?;
73    Ok(t)
74}
75
76impl<'r, 'de, R: Reader<'de, IOValue>> Deserializer<'de, 'r, R> {
77    /// Construct a Deserializer from `read`, a Preserves [reader][crate::value::Reader].
78    pub fn from_reader(read: &'r mut R) -> Self {
79        Deserializer {
80            read,
81            phantom: PhantomData,
82        }
83    }
84}
85
86impl<'r, 'de, 'a, R: Reader<'de, IOValue>> serde::de::Deserializer<'de>
87    for &'a mut Deserializer<'de, 'r, R>
88{
89    type Error = Error;
90
91    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
92    where
93        V: Visitor<'de>,
94    {
95        // Won't support this here -- use value::de::Deserializer for this
96        Err(Error::CannotDeserializeAny)
97    }
98
99    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
100    where
101        V: Visitor<'de>,
102    {
103        visitor.visit_bool(self.read.next_boolean()?)
104    }
105
106    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
107    where
108        V: Visitor<'de>,
109    {
110        visitor.visit_i8(self.read.next_i8()?)
111    }
112
113    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
114    where
115        V: Visitor<'de>,
116    {
117        visitor.visit_i16(self.read.next_i16()?)
118    }
119
120    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
121    where
122        V: Visitor<'de>,
123    {
124        visitor.visit_i32(self.read.next_i32()?)
125    }
126
127    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
128    where
129        V: Visitor<'de>,
130    {
131        visitor.visit_i64(self.read.next_i64()?)
132    }
133
134    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
135    where
136        V: Visitor<'de>,
137    {
138        visitor.visit_u8(self.read.next_u8()?)
139    }
140
141    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
142    where
143        V: Visitor<'de>,
144    {
145        visitor.visit_u16(self.read.next_u16()?)
146    }
147
148    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
149    where
150        V: Visitor<'de>,
151    {
152        visitor.visit_u32(self.read.next_u32()?)
153    }
154
155    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
156    where
157        V: Visitor<'de>,
158    {
159        visitor.visit_u64(self.read.next_u64()?)
160    }
161
162    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
163    where
164        V: Visitor<'de>,
165    {
166        visitor.visit_f32(self.read.next_f64()? as f32)
167    }
168
169    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
170    where
171        V: Visitor<'de>,
172    {
173        visitor.visit_f64(self.read.next_f64()?)
174    }
175
176    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
177    where
178        V: Visitor<'de>,
179    {
180        visitor.visit_char(self.read.next_char()?)
181    }
182
183    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
184    where
185        V: Visitor<'de>,
186    {
187        match self.read.next_str()? {
188            Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
189            Cow::Owned(s) => visitor.visit_str(&s),
190        }
191    }
192
193    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
194    where
195        V: Visitor<'de>,
196    {
197        self.deserialize_str(visitor)
198    }
199
200    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
201    where
202        V: Visitor<'de>,
203    {
204        match self.read.next_bytestring()? {
205            Cow::Borrowed(bs) => visitor.visit_borrowed_bytes(bs),
206            Cow::Owned(bs) => visitor.visit_bytes(&bs),
207        }
208    }
209
210    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
211    where
212        V: Visitor<'de>,
213    {
214        visitor.visit_byte_buf(self.read.next_bytestring()?.into_owned())
215    }
216
217    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
218    where
219        V: Visitor<'de>,
220    {
221        if let Some(mut b) = self.read.open_option()? {
222            self.read.ensure_boundary(&mut b, &B::Item::RecordField)?;
223            let result = visitor.visit_some(&mut *self)?;
224            self.read.ensure_complete(b)?;
225            Ok(result)
226        } else {
227            Ok(visitor.visit_none::<Error>()?)
228        }
229    }
230
231    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
232    where
233        V: Visitor<'de>,
234    {
235        let b = self.read.open_simple_record("tuple", Some(0))?;
236        let result = visitor.visit_unit::<Error>()?;
237        self.read.ensure_complete(b)?;
238        Ok(result)
239    }
240
241    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
242    where
243        V: Visitor<'de>,
244    {
245        let b = self.read.open_simple_record(name, Some(0))?;
246        let result = visitor.visit_unit::<Error>()?;
247        self.read.ensure_complete(b)?;
248        Ok(result)
249    }
250
251    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
252    where
253        V: Visitor<'de>,
254    {
255        match super::value::magic::transmit_input_value(name, || {
256            Ok(self.read.demand_next(true)?)
257        })? {
258            Some(v) => visitor.visit_u64(v),
259            None => {
260                let mut b = self.read.open_simple_record(name, Some(1))?;
261                self.read.ensure_boundary(&mut b, &B::Item::RecordField)?;
262                let result = visitor.visit_newtype_struct(&mut *self)?;
263                self.read.ensure_complete(b)?;
264                Ok(result)
265            }
266        }
267    }
268
269    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
270    where
271        V: Visitor<'de>,
272    {
273        // Hack around serde's model: Deserialize *sets* as sequences,
274        // too, and reconstruct them as Rust Sets on the visitor side.
275        let i = self.read.open_sequence_or_set()?;
276        visitor.visit_seq(Seq::new(self, B::Type::default(), i))
277    }
278
279    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
280    where
281        V: Visitor<'de>,
282    {
283        let b = self.read.open_simple_record("tuple", Some(len))?;
284        let mut seq = Seq::new(self, b, B::Item::RecordField);
285        let result = visitor.visit_seq(&mut seq)?;
286        seq.skip_remainder()?;
287        Ok(result)
288    }
289
290    fn deserialize_tuple_struct<V>(
291        self,
292        name: &'static str,
293        len: usize,
294        visitor: V,
295    ) -> Result<V::Value>
296    where
297        V: Visitor<'de>,
298    {
299        let b = self.read.open_simple_record(name, Some(len))?;
300        let mut seq = Seq::new(self, b, B::Item::RecordField);
301        let result = visitor.visit_seq(&mut seq)?;
302        seq.skip_remainder()?;
303        Ok(result)
304    }
305
306    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
307    where
308        V: Visitor<'de>,
309    {
310        self.read.open_dictionary()?;
311        let mut seq = Seq::new(self, B::Type::default(), B::Item::DictionaryKey);
312        let result = visitor.visit_map(&mut seq)?;
313        Ok(result)
314    }
315
316    fn deserialize_struct<V>(
317        self,
318        name: &'static str,
319        fields: &'static [&'static str],
320        visitor: V,
321    ) -> Result<V::Value>
322    where
323        V: Visitor<'de>,
324    {
325        let b = self.read.open_simple_record(name, Some(fields.len()))?;
326        let mut seq = Seq::new(self, b, B::Item::RecordField);
327        let result = visitor.visit_seq(&mut seq)?;
328        seq.skip_remainder()?;
329        Ok(result)
330    }
331
332    fn deserialize_enum<V>(
333        self,
334        _name: &'static str,
335        _variants: &'static [&'static str],
336        visitor: V,
337    ) -> Result<V::Value>
338    where
339        V: Visitor<'de>,
340    {
341        visitor.visit_enum(self)
342    }
343
344    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
345    where
346        V: Visitor<'de>,
347    {
348        match self.read.next_symbol()? {
349            Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
350            Cow::Owned(s) => visitor.visit_str(&s),
351        }
352    }
353
354    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
355    where
356        V: Visitor<'de>,
357    {
358        visitor.visit_none()
359    }
360}
361
362#[doc(hidden)]
363pub struct Seq<'de, 'r, 'a, R: Reader<'de, IOValue>> {
364    b: B::Type,
365    i: B::Item,
366    de: &'a mut Deserializer<'de, 'r, R>,
367}
368
369impl<'de, 'r, 'a, R: Reader<'de, IOValue>> Seq<'de, 'r, 'a, R> {
370    fn new(de: &'a mut Deserializer<'de, 'r, R>, b: B::Type, i: B::Item) -> Self {
371        Seq { b, i, de }
372    }
373
374    fn skip_remainder(&mut self) -> Result<()> {
375        while self.de.read.expect_boundary(&mut self.b, &self.i)? {
376            self.de.read.skip_value()?;
377        }
378        Ok(())
379    }
380
381    fn next_item<T>(&mut self, seed: T) -> Result<Option<T::Value>>
382    where
383        T: DeserializeSeed<'de>,
384    {
385        if self.de.read.expect_boundary(&mut self.b, &self.i)? {
386            Ok(Some(seed.deserialize(&mut *self.de)?))
387        } else {
388            Ok(None)
389        }
390    }
391}
392
393impl<'de, 'r, 'a, R: Reader<'de, IOValue>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> {
394    type Error = Error;
395
396    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
397    where
398        T: DeserializeSeed<'de>,
399    {
400        Ok(self.next_item(seed)?)
401    }
402}
403
404impl<'de, 'r, 'a, R: Reader<'de, IOValue>> MapAccess<'de> for Seq<'de, 'r, 'a, R> {
405    type Error = Error;
406
407    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
408    where
409        K: DeserializeSeed<'de>,
410    {
411        self.i = B::Item::DictionaryKey;
412        self.next_item(seed)
413    }
414
415    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
416    where
417        V: DeserializeSeed<'de>,
418    {
419        self.i = B::Item::DictionaryValue;
420        match self.next_item(seed)? {
421            Some(item) => Ok(item),
422            None => Err(Error::MissingItem),
423        }
424    }
425}
426
427impl<'de, 'r, 'a, R: Reader<'de, IOValue>> EnumAccess<'de> for &'a mut Deserializer<'de, 'r, R> {
428    type Error = Error;
429    type Variant = Seq<'de, 'r, 'a, R>;
430
431    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
432    where
433        V: DeserializeSeed<'de>,
434    {
435        self.read.open_record(None)?;
436        let mut b = B::Type::default();
437        b.shift(Some(B::Item::RecordLabel));
438        self.read.boundary(&b)?;
439        let variant = seed.deserialize(&mut *self)?;
440        Ok((variant, Seq::new(self, b, B::Item::RecordField)))
441    }
442}
443
444impl<'de, 'r, 'a, R: Reader<'de, IOValue>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> {
445    type Error = Error;
446
447    fn unit_variant(mut self) -> Result<()> {
448        self.skip_remainder()
449    }
450
451    fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value>
452    where
453        T: DeserializeSeed<'de>,
454    {
455        match self.next_item(seed)? {
456            None => Err(Error::MissingItem),
457            Some(v) => {
458                self.skip_remainder()?;
459                Ok(v)
460            }
461        }
462    }
463
464    fn tuple_variant<V>(mut self, _len: usize, visitor: V) -> Result<V::Value>
465    where
466        V: Visitor<'de>,
467    {
468        let result = visitor.visit_seq(&mut self)?;
469        self.skip_remainder()?;
470        Ok(result)
471    }
472
473    fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
474    where
475        V: Visitor<'de>,
476    {
477        let result = visitor.visit_seq(&mut self)?;
478        self.skip_remainder()?;
479        Ok(result)
480    }
481}
preserves/de.rs

preserves/
de.rs
