serde_hashkey/
de.rs

Help
1//! Deserialization for serde-hashkey.
2
3use serde::de::{self, IntoDeserializer};
4
5use crate::error::Error;
6use crate::float::{FloatPolicy, FloatRepr};
7use crate::key::{Float, Integer, Key};
8
9/// Deserialize the given type from a [Key].
10///
11/// # Examples
12///
13/// ```
14/// use serde_derive::{Deserialize, Serialize};
15/// use serde_hashkey::{from_key, to_key, Key};
16/// use std::collections::HashMap;
17///
18/// #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
19/// struct Author {
20///     name: String,
21///     age: u32,
22/// }
23///
24/// #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
25/// struct Book {
26///     title: String,
27///     author: Author,
28/// }
29///
30/// # fn main() -> serde_hashkey::Result<()> {
31/// let book = Book {
32///     title: String::from("Birds of a feather"),
33///     author: Author {
34///         name: String::from("Noah"),
35///         age: 42,
36///     },
37/// };
38///
39/// let key = to_key(&book)?;
40/// let book2 = from_key(&key)?;
41///
42/// assert_eq!(book, book2);
43/// # Ok(())
44/// # }
45/// ```
46///
47/// Using a non-standard float policy:
48///
49/// ```
50/// use serde_derive::{Deserialize, Serialize};
51/// use serde_hashkey::{from_key, to_key_with_ordered_float, OrderedFloat, Key};
52/// use std::collections::HashMap;
53///
54/// #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
55/// struct Author {
56///     name: String,
57///     age: u32,
58/// }
59///
60/// #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
61/// struct Book {
62///     title: String,
63///     author: Author,
64/// }
65///
66/// # fn main() -> serde_hashkey::Result<()> {
67/// let book = Book {
68///     title: String::from("Birds of a feather"),
69///     author: Author {
70///         name: String::from("Noah"),
71///         age: 42,
72///     },
73/// };
74///
75/// let key = to_key_with_ordered_float(&book)?;
76/// let book2 = from_key(&key)?;
77///
78/// assert_eq!(book, book2);
79/// # Ok(())
80/// # }
81/// ```
82pub fn from_key<T, F>(value: &Key<F>) -> Result<T, crate::error::Error>
83where
84    T: de::DeserializeOwned,
85    F: FloatPolicy,
86{
87    T::deserialize(Deserializer::new(value))
88}
89
90impl<'de, F> IntoDeserializer<'de, Error> for &'de Key<F>
91where
92    F: FloatPolicy,
93{
94    type Deserializer = Deserializer<'de, F>;
95
96    fn into_deserializer(self) -> Self::Deserializer {
97        Deserializer::new(self)
98    }
99}
100
101pub struct Deserializer<'de, F>
102where
103    F: FloatPolicy,
104{
105    value: &'de Key<F>,
106}
107
108impl<'de, F> Deserializer<'de, F>
109where
110    F: FloatPolicy,
111{
112    pub fn new(value: &'de Key<F>) -> Self {
113        Self { value }
114    }
115}
116
117impl<'de, F> de::Deserializer<'de> for Deserializer<'de, F>
118where
119    F: FloatPolicy,
120{
121    type Error = Error;
122
123    #[inline]
124    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
125    where
126        V: de::Visitor<'de>,
127    {
128        return match self.value {
129            Key::Unit => visitor.visit_unit(),
130            Key::Bool(b) => visitor.visit_bool(*b),
131            Key::Integer(Integer::U8(v)) => visitor.visit_u8(*v),
132            Key::Integer(Integer::U16(v)) => visitor.visit_u16(*v),
133            Key::Integer(Integer::U32(v)) => visitor.visit_u32(*v),
134            Key::Integer(Integer::U64(v)) => visitor.visit_u64(*v),
135            Key::Integer(Integer::U128(v)) => visitor.visit_u128(*v),
136            Key::Integer(Integer::I8(v)) => visitor.visit_i8(*v),
137            Key::Integer(Integer::I16(v)) => visitor.visit_i16(*v),
138            Key::Integer(Integer::I32(v)) => visitor.visit_i32(*v),
139            Key::Integer(Integer::I64(v)) => visitor.visit_i64(*v),
140            Key::Integer(Integer::I128(v)) => visitor.visit_i128(*v),
141            Key::Float(Float::F32(float)) => <F::F32 as FloatRepr<f32>>::visit(float, visitor),
142            Key::Float(Float::F64(float)) => <F::F64 as FloatRepr<f64>>::visit(float, visitor),
143            Key::String(s) => visitor.visit_str(s),
144            Key::Seq(array) => visitor.visit_seq(SeqDeserializer::new(array)),
145            Key::Map(m) => visitor.visit_map(MapDeserializer::new(m)),
146            Key::Bytes(bytes) => visitor.visit_borrowed_bytes(bytes),
147        };
148    }
149
150    #[inline]
151    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
152    where
153        V: de::Visitor<'de>,
154    {
155        match self.value {
156            Key::Unit => visitor.visit_none(),
157            _ => visitor.visit_some(self),
158        }
159    }
160
161    #[inline]
162    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Error>
163    where
164        V: de::Visitor<'de>,
165    {
166        visitor.visit_newtype_struct(self)
167    }
168
169    #[inline]
170    fn deserialize_enum<V>(
171        self,
172        _name: &str,
173        _variants: &'static [&'static str],
174        visitor: V,
175    ) -> Result<V::Value, Error>
176    where
177        V: de::Visitor<'de>,
178    {
179        let (variant, value) = match self.value {
180            Key::Map(value) => {
181                let mut iter = value.iter();
182
183                let (variant, value) = match iter.next() {
184                    Some(v) => v,
185                    None => {
186                        return Err(Error::Unexpected("map with a single key"));
187                    }
188                };
189
190                // enums are encoded in json as maps with a single key:value pair
191                if iter.next().is_some() {
192                    return Err(Error::Unexpected("map with a single key"));
193                }
194
195                (variant, Some(value))
196            }
197            Key::String(_) => (self.value, None),
198            _ => {
199                return Err(Error::Unexpected("string or map"));
200            }
201        };
202
203        visitor.visit_enum(EnumDeserializer { variant, value })
204    }
205
206    #[inline]
207    fn is_human_readable(&self) -> bool {
208        false
209    }
210
211    serde::forward_to_deserialize_any! {
212        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string unit
213        unit_struct seq tuple tuple_struct map struct identifier ignored_any
214        bytes byte_buf
215    }
216}
217
218struct EnumDeserializer<'de, F>
219where
220    F: FloatPolicy,
221{
222    variant: &'de Key<F>,
223    value: Option<&'de Key<F>>,
224}
225
226impl<'de, F> de::EnumAccess<'de> for EnumDeserializer<'de, F>
227where
228    F: FloatPolicy,
229{
230    type Error = Error;
231    type Variant = VariantDeserializer<'de, F>;
232
233    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
234    where
235        V: de::DeserializeSeed<'de>,
236    {
237        let variant = self.variant.into_deserializer();
238        let visitor = VariantDeserializer { value: self.value };
239        seed.deserialize(variant).map(|v| (v, visitor))
240    }
241}
242
243struct VariantDeserializer<'de, F>
244where
245    F: FloatPolicy,
246{
247    value: Option<&'de Key<F>>,
248}
249
250impl<'de, F> de::VariantAccess<'de> for VariantDeserializer<'de, F>
251where
252    F: FloatPolicy,
253{
254    type Error = Error;
255
256    fn unit_variant(self) -> Result<(), Error> {
257        match self.value {
258            Some(value) => de::Deserialize::deserialize(Deserializer::new(value)),
259            None => Ok(()),
260        }
261    }
262
263    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
264    where
265        T: de::DeserializeSeed<'de>,
266    {
267        match self.value {
268            Some(value) => seed.deserialize(Deserializer::new(value)),
269            None => Err(Error::UnexpectedVariant("newtype variant")),
270        }
271    }
272
273    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
274    where
275        V: de::Visitor<'de>,
276    {
277        match self.value {
278            Some(Key::Seq(values)) => {
279                de::Deserializer::deserialize_any(SeqDeserializer::new(values), visitor)
280            }
281            Some(_) => Err(Error::UnexpectedVariant("tuple variant")),
282            None => Err(Error::UnexpectedVariant("tuple variant")),
283        }
284    }
285
286    fn struct_variant<V>(
287        self,
288        _fields: &'static [&'static str],
289        visitor: V,
290    ) -> Result<V::Value, Error>
291    where
292        V: de::Visitor<'de>,
293    {
294        match self.value {
295            Some(Key::Map(v)) => {
296                de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
297            }
298            Some(_) => Err(Error::UnexpectedVariant("struct variant")),
299            _ => Err(Error::UnexpectedVariant("struct variant")),
300        }
301    }
302}
303
304struct SeqDeserializer<'de, F>
305where
306    F: FloatPolicy,
307{
308    values: &'de [Key<F>],
309}
310
311impl<'de, F> SeqDeserializer<'de, F>
312where
313    F: FloatPolicy,
314{
315    pub fn new(values: &'de [Key<F>]) -> Self {
316        Self { values }
317    }
318}
319
320impl<'de, F> serde::Deserializer<'de> for SeqDeserializer<'de, F>
321where
322    F: FloatPolicy,
323{
324    type Error = Error;
325
326    #[inline]
327    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
328    where
329        V: de::Visitor<'de>,
330    {
331        let len = self.values.len();
332
333        if len == 0 {
334            return visitor.visit_unit();
335        }
336
337        let ret = visitor.visit_seq(&mut self)?;
338
339        if self.values.is_empty() {
340            return Ok(ret);
341        }
342
343        Err(Error::InvalidLength)
344    }
345
346    serde::forward_to_deserialize_any! {
347        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
348        bytes byte_buf option unit unit_struct newtype_struct seq tuple
349        tuple_struct map struct enum identifier ignored_any
350    }
351}
352
353impl<'de, F> de::SeqAccess<'de> for SeqDeserializer<'de, F>
354where
355    F: FloatPolicy,
356{
357    type Error = Error;
358
359    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
360    where
361        T: de::DeserializeSeed<'de>,
362    {
363        let (first, rest) = match self.values.split_first() {
364            Some((first, rest)) => (first, rest),
365            None => return Ok(None),
366        };
367
368        self.values = rest;
369        let value = seed.deserialize(Deserializer::new(first))?;
370        Ok(Some(value))
371    }
372}
373
374struct MapDeserializer<'de, F>
375where
376    F: FloatPolicy,
377{
378    map: &'de [(Key<F>, Key<F>)],
379    value: Option<&'de Key<F>>,
380}
381
382impl<'de, F> MapDeserializer<'de, F>
383where
384    F: FloatPolicy,
385{
386    pub fn new(map: &'de [(Key<F>, Key<F>)]) -> Self {
387        Self { map, value: None }
388    }
389}
390
391impl<'de, F> serde::Deserializer<'de> for MapDeserializer<'de, F>
392where
393    F: FloatPolicy,
394{
395    type Error = Error;
396
397    #[inline]
398    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
399    where
400        V: de::Visitor<'de>,
401    {
402        visitor.visit_map(self)
403    }
404
405    serde::forward_to_deserialize_any! {
406        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
407        bytes byte_buf option unit unit_struct newtype_struct seq tuple
408        tuple_struct map struct enum identifier ignored_any
409    }
410}
411
412impl<'de, F> de::MapAccess<'de> for MapDeserializer<'de, F>
413where
414    F: FloatPolicy,
415{
416    type Error = Error;
417
418    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
419    where
420        K: de::DeserializeSeed<'de>,
421    {
422        let next = self.map.split_first();
423
424        match next {
425            Some(((key, value), map)) => {
426                self.value = Some(value);
427                self.map = map;
428                let value = seed.deserialize(key.into_deserializer())?;
429                Ok(Some(value))
430            }
431            None => Ok(None),
432        }
433    }
434
435    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
436    where
437        V: de::DeserializeSeed<'de>,
438    {
439        let value = match self.value.take() {
440            Some(value) => value,
441            None => return Err(Error::MissingValue),
442        };
443
444        seed.deserialize(Deserializer::new(value))
445    }
446}
serde_hashkey/de.rs

serde_hashkey/
de.rs
