yrs/encoding/serde/
de.rs

1use crate::any::Any;
2use crate::encoding::read::Error;
3use serde::de::value::{MapAccessDeserializer, MapDeserializer, SeqDeserializer};
4use serde::de::{IntoDeserializer, MapAccess, SeqAccess, Visitor};
5use serde::{Deserialize, Deserializer};
6use std::any::type_name;
7use std::collections::HashMap;
8use std::convert::{TryFrom, TryInto};
9use std::fmt::{Display, Formatter};
10use std::sync::Arc;
11
12pub fn from_any<'de, T: Deserialize<'de>>(any: &'de Any) -> Result<T, Error> {
13    let deserializer = AnyDeserializer { value: any };
14    T::deserialize(deserializer)
15}
16
17impl<'de> Deserialize<'de> for Any {
18    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
19    where
20        D: Deserializer<'de>,
21    {
22        struct AnyVisitor;
23        impl<'de> Visitor<'de> for AnyVisitor {
24            type Value = Any;
25
26            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
27                formatter.write_str("enum Any")
28            }
29
30            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
31            where
32                E: serde::de::Error,
33            {
34                Ok(Any::from(v))
35            }
36
37            fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
38            where
39                E: serde::de::Error,
40            {
41                Ok(Any::Number(v as f64))
42            }
43
44            fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
45            where
46                E: serde::de::Error,
47            {
48                Ok(Any::from(v))
49            }
50
51            fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
52            where
53                E: serde::de::Error,
54            {
55                Ok(Any::from(v))
56            }
57
58            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
59            where
60                E: serde::de::Error,
61            {
62                Ok(Any::from(v))
63            }
64
65            fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
66            where
67                E: serde::de::Error,
68            {
69                Ok(Any::Number(v as f64))
70            }
71
72            fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
73            where
74                E: serde::de::Error,
75            {
76                Ok(Any::from(v))
77            }
78
79            fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
80            where
81                E: serde::de::Error,
82            {
83                Ok(Any::from(v))
84            }
85
86            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
87            where
88                E: serde::de::Error,
89            {
90                match Any::try_from(v) {
91                    Ok(any) => Ok(any),
92                    Err(v) => Err(serde::de::Error::custom(format!(
93                        "Value {} out of range for i64",
94                        v
95                    ))),
96                }
97            }
98
99            fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
100            where
101                E: serde::de::Error,
102            {
103                Ok(Any::from(v))
104            }
105
106            fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
107            where
108                E: serde::de::Error,
109            {
110                Ok(Any::from(v))
111            }
112
113            fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
114            where
115                E: serde::de::Error,
116            {
117                Ok(Any::from(v.to_string()))
118            }
119
120            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
121            where
122                E: serde::de::Error,
123            {
124                Ok(Any::from(v))
125            }
126
127            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
128            where
129                E: serde::de::Error,
130            {
131                Ok(Any::from(v))
132            }
133
134            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
135            where
136                E: serde::de::Error,
137            {
138                Ok(Any::from(v))
139            }
140
141            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
142            where
143                E: serde::de::Error,
144            {
145                Ok(Any::from(v))
146            }
147
148            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
149            where
150                E: serde::de::Error,
151            {
152                Ok(Any::from(v))
153            }
154
155            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
156            where
157                E: serde::de::Error,
158            {
159                Ok(Any::from(v))
160            }
161
162            fn visit_none<E>(self) -> Result<Self::Value, E>
163            where
164                E: serde::de::Error,
165            {
166                Ok(Any::Null)
167            }
168
169            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
170            where
171                D: Deserializer<'de>,
172            {
173                Any::deserialize(deserializer)
174            }
175
176            fn visit_unit<E>(self) -> Result<Self::Value, E>
177            where
178                E: serde::de::Error,
179            {
180                Ok(Any::Null)
181            }
182
183            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
184            where
185                A: SeqAccess<'de>,
186            {
187                let mut vec = Vec::new();
188
189                while let Some(value) = seq.next_element()? {
190                    vec.push(value);
191                }
192
193                Ok(Any::Array(vec.into()))
194            }
195
196            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
197            where
198                A: MapAccess<'de>,
199            {
200                let mut any_map = HashMap::new();
201                while let Some((key, value)) = map.next_entry()? {
202                    any_map.insert(key, value);
203                }
204
205                Ok(Any::Map(Arc::new(any_map)))
206            }
207        }
208
209        deserializer.deserialize_any(AnyVisitor)
210    }
211}
212
213pub struct AnyDeserializer<'a> {
214    value: &'a Any,
215}
216
217impl<'de, 'a: 'de> IntoDeserializer<'de, Error> for &'a Any {
218    type Deserializer = AnyDeserializer<'de>;
219
220    fn into_deserializer(self) -> Self::Deserializer {
221        AnyDeserializer { value: self }
222    }
223}
224
225impl serde::de::Error for Error {
226    fn custom<T>(msg: T) -> Self
227    where
228        T: Display,
229    {
230        Error::Custom(msg.to_string())
231    }
232}
233
234impl<'de> Deserializer<'de> for AnyDeserializer<'de> {
235    type Error = Error;
236
237    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
238    where
239        V: Visitor<'de>,
240    {
241        match self.value {
242            Any::Null => self.deserialize_unit(visitor),
243            Any::Undefined => self.deserialize_unit(visitor),
244            Any::Bool(_) => self.deserialize_bool(visitor),
245            Any::Number(_) => self.deserialize_f64(visitor),
246            Any::BigInt(_) => self.deserialize_i64(visitor),
247            Any::String(_) => self.deserialize_string(visitor),
248            Any::Buffer(_) => self.deserialize_byte_buf(visitor),
249            Any::Array(_) => self.deserialize_seq(visitor),
250            Any::Map(_) => self.deserialize_map(visitor),
251        }
252    }
253
254    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
255    where
256        V: Visitor<'de>,
257    {
258        match self.value {
259            Any::Bool(b) => visitor.visit_bool(*b),
260            _ => Err(Error::TypeMismatch(type_name::<bool>())),
261        }
262    }
263
264    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
265    where
266        V: Visitor<'de>,
267    {
268        let value = match self.value {
269            Any::Number(i) => {
270                if i.fract() == 0.0 {
271                    *i as i64
272                } else {
273                    return Err(Error::type_mismatch::<i8>());
274                }
275            }
276            Any::BigInt(i) => *i,
277            _ => return Err(Error::type_mismatch::<i8>()),
278        }
279        .try_into()
280        .map_err(|_| Error::UnexpectedValue)?;
281        visitor.visit_i8(value)
282    }
283
284    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
285    where
286        V: Visitor<'de>,
287    {
288        let value = match self.value {
289            Any::Number(i) => {
290                if i.fract() == 0.0 {
291                    *i as i64
292                } else {
293                    return Err(Error::type_mismatch::<i16>());
294                }
295            }
296            Any::BigInt(i) => *i,
297            _ => return Err(Error::type_mismatch::<i16>()),
298        }
299        .try_into()
300        .map_err(|_| Error::UnexpectedValue)?;
301        visitor.visit_i16(value)
302    }
303
304    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
305    where
306        V: Visitor<'de>,
307    {
308        let value = match self.value {
309            Any::Number(i) => {
310                if i.fract() == 0.0 {
311                    *i as i64
312                } else {
313                    return Err(Error::type_mismatch::<i32>());
314                }
315            }
316            Any::BigInt(i) => *i,
317            _ => return Err(Error::type_mismatch::<i32>()),
318        }
319        .try_into()
320        .map_err(|_| Error::UnexpectedValue)?;
321        visitor.visit_i32(value)
322    }
323
324    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
325    where
326        V: Visitor<'de>,
327    {
328        let value = match self.value {
329            Any::Number(i) => {
330                if i.fract() == 0.0 {
331                    *i as i64
332                } else {
333                    return Err(Error::type_mismatch::<i64>());
334                }
335            }
336            Any::BigInt(i) => *i,
337            _ => return Err(Error::type_mismatch::<i64>()),
338        };
339        visitor.visit_i64(value)
340    }
341
342    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
343    where
344        V: Visitor<'de>,
345    {
346        let value = match self.value {
347            Any::Number(i) => {
348                if i.fract() == 0.0 {
349                    *i as i64
350                } else {
351                    return Err(Error::type_mismatch::<u8>());
352                }
353            }
354            Any::BigInt(i) => *i,
355            _ => return Err(Error::type_mismatch::<u8>()),
356        }
357        .try_into()
358        .map_err(|_| Error::UnexpectedValue)?;
359        visitor.visit_u8(value)
360    }
361
362    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
363    where
364        V: Visitor<'de>,
365    {
366        let value = match self.value {
367            Any::Number(i) => {
368                if i.fract() == 0.0 {
369                    *i as i64
370                } else {
371                    return Err(Error::type_mismatch::<u16>());
372                }
373            }
374            Any::BigInt(i) => *i,
375            _ => return Err(Error::type_mismatch::<u16>()),
376        }
377        .try_into()
378        .map_err(|_| Error::UnexpectedValue)?;
379        visitor.visit_u16(value)
380    }
381
382    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
383    where
384        V: Visitor<'de>,
385    {
386        let value = match self.value {
387            Any::Number(i) => {
388                if i.fract() == 0.0 {
389                    *i as i64
390                } else {
391                    return Err(Error::type_mismatch::<u32>());
392                }
393            }
394            Any::BigInt(i) => *i,
395            _ => return Err(Error::type_mismatch::<u32>()),
396        }
397        .try_into()
398        .map_err(|_| Error::UnexpectedValue)?;
399        visitor.visit_u32(value)
400    }
401
402    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
403    where
404        V: Visitor<'de>,
405    {
406        let value = match self.value {
407            Any::Number(i) => {
408                if i.fract() == 0.0 {
409                    *i as i64
410                } else {
411                    return Err(Error::type_mismatch::<u64>());
412                }
413            }
414            Any::BigInt(i) => *i,
415            _ => return Err(Error::type_mismatch::<u64>()),
416        }
417        .try_into()
418        .map_err(|_| Error::UnexpectedValue)?;
419        visitor.visit_u64(value)
420    }
421
422    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
423    where
424        V: Visitor<'de>,
425    {
426        match self.value {
427            Any::Number(f) => visitor.visit_f32(*f as f32),
428            Any::BigInt(f) => visitor.visit_f32(*f as f32),
429            _ => Err(Error::type_mismatch::<f32>()),
430        }
431    }
432
433    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
434    where
435        V: Visitor<'de>,
436    {
437        match self.value {
438            Any::Number(f) => visitor.visit_f64(*f),
439            Any::BigInt(f) => visitor.visit_f64(*f as f64),
440            _ => Err(Error::type_mismatch::<f64>()),
441        }
442    }
443
444    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
445    where
446        V: Visitor<'de>,
447    {
448        match self.value {
449            Any::String(s) => {
450                let mut chars = s.chars();
451                // Match on first two characters
452                match (chars.next(), chars.next()) {
453                    (Some(c), None) => visitor.visit_char(c),
454                    _ => Err(Error::type_mismatch::<char>()),
455                }
456            }
457            _ => Err(Error::type_mismatch::<char>()),
458        }
459    }
460
461    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
462    where
463        V: Visitor<'de>,
464    {
465        match self.value {
466            Any::String(s) => visitor.visit_borrowed_str(s),
467            _ => Err(Error::type_mismatch::<&str>()),
468        }
469    }
470
471    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
472    where
473        V: Visitor<'de>,
474    {
475        match self.value {
476            Any::String(s) => visitor.visit_string(s.to_string()),
477            _ => Err(Error::type_mismatch::<String>()),
478        }
479    }
480
481    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
482    where
483        V: Visitor<'de>,
484    {
485        match self.value {
486            Any::Buffer(b) => visitor.visit_borrowed_bytes(b),
487            _ => Err(Error::type_mismatch::<&[u8]>()),
488        }
489    }
490
491    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
492    where
493        V: Visitor<'de>,
494    {
495        match self.value {
496            Any::Buffer(b) => visitor.visit_bytes(b),
497            _ => Err(Error::type_mismatch::<Vec<u8>>()),
498        }
499    }
500
501    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
502    where
503        V: Visitor<'de>,
504    {
505        match self.value {
506            Any::Null | Any::Undefined => visitor.visit_none(),
507            _ => visitor.visit_some(self),
508        }
509    }
510
511    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
512    where
513        V: Visitor<'de>,
514    {
515        match self.value {
516            Any::Null | Any::Undefined => visitor.visit_unit(),
517            _ => Err(Error::type_mismatch::<()>()),
518        }
519    }
520
521    fn deserialize_unit_struct<V>(
522        self,
523        _name: &'static str,
524        visitor: V,
525    ) -> Result<V::Value, Self::Error>
526    where
527        V: Visitor<'de>,
528    {
529        self.deserialize_unit(visitor)
530    }
531
532    fn deserialize_newtype_struct<V>(
533        self,
534        _name: &'static str,
535        visitor: V,
536    ) -> Result<V::Value, Self::Error>
537    where
538        V: Visitor<'de>,
539    {
540        visitor.visit_newtype_struct(self)
541    }
542
543    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
544    where
545        V: Visitor<'de>,
546    {
547        match self.value {
548            Any::Array(a) => visitor.visit_seq(SeqDeserializer::new(a.iter())),
549            _ => visitor.visit_some(self),
550        }
551    }
552
553    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
554    where
555        V: Visitor<'de>,
556    {
557        self.deserialize_seq(visitor)
558    }
559
560    fn deserialize_tuple_struct<V>(
561        self,
562        _name: &'static str,
563        _len: usize,
564        visitor: V,
565    ) -> Result<V::Value, Self::Error>
566    where
567        V: Visitor<'de>,
568    {
569        self.deserialize_seq(visitor)
570    }
571
572    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
573    where
574        V: Visitor<'de>,
575    {
576        match self.value {
577            Any::Map(m) => visitor.visit_map(MapDeserializer::new(
578                m.iter().map(|(key, value)| (key.as_str(), value)),
579            )),
580            _ => Err(Error::type_mismatch::<V::Value>()),
581        }
582    }
583
584    fn deserialize_struct<V>(
585        self,
586        _name: &'static str,
587        _fields: &'static [&'static str],
588        visitor: V,
589    ) -> Result<V::Value, Self::Error>
590    where
591        V: Visitor<'de>,
592    {
593        self.deserialize_map(visitor)
594    }
595
596    fn deserialize_enum<V>(
597        self,
598        _name: &'static str,
599        _variants: &'static [&'static str],
600        visitor: V,
601    ) -> Result<V::Value, Self::Error>
602    where
603        V: Visitor<'de>,
604    {
605        match self.value {
606            Any::String(s) => visitor.visit_enum(s.into_deserializer()),
607            Any::Map(m) => visitor.visit_enum(MapAccessDeserializer::new(MapDeserializer::new(
608                m.iter().map(|(key, value)| (key.as_str(), value)),
609            ))),
610            _ => Err(Error::type_mismatch::<V::Value>()),
611        }
612    }
613
614    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
615    where
616        V: Visitor<'de>,
617    {
618        self.deserialize_str(visitor)
619    }
620
621    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
622    where
623        V: Visitor<'de>,
624    {
625        self.deserialize_any(visitor)
626    }
627}
628
629#[cfg(test)]
630mod test {
631    use super::*;
632    use crate::any::Any;
633    use serde::Deserialize;
634    use std::collections::HashMap;
635
636    #[test]
637    fn test_deserialize_any_from_bool() {
638        assert_eq!(
639            serde_json::from_str::<Any>("true").unwrap(),
640            Any::from(true)
641        );
642    }
643
644    #[test]
645    fn test_deserialize_any_from_float() {
646        assert_eq!(
647            serde_json::from_str::<Any>("18.812036").unwrap(),
648            Any::from(18.812036f64)
649        );
650    }
651
652    #[test]
653    fn test_deserialize_any_from_int() {
654        assert_eq!(serde_json::from_str::<Any>("18").unwrap(), Any::from(18));
655    }
656
657    #[test]
658    fn test_deserialize_any_from_int_unrepresentable() {
659        assert!(serde_json::from_str::<Any>(&u64::MAX.to_string()).is_err());
660    }
661
662    #[test]
663    fn test_deserialize_any_from_string() {
664        assert_eq!(
665            serde_json::from_str::<Any>("\"string\"").unwrap(),
666            Any::from("string")
667        );
668    }
669
670    #[test]
671    fn test_deserialize_any_from_null() {
672        assert_eq!(serde_json::from_str::<Any>("null").unwrap(), Any::Null);
673    }
674
675    #[test]
676    fn test_deserialize_any_from_array() {
677        assert_eq!(
678            serde_json::from_str::<Any>("[true, -101]").unwrap(),
679            Any::from(vec![Any::from(true), Any::from(-101)])
680        );
681    }
682
683    #[test]
684    fn test_deserialize_any_from_map() {
685        assert_eq!(
686            serde_json::from_str::<Any>("{\"key1\":true,\"key2\":-12307.2138}").unwrap(),
687            Any::from(HashMap::from([
688                ("key1".into(), Any::from(true)),
689                ("key2".into(), Any::from(-12307.2138f64))
690            ]))
691        );
692    }
693
694    #[test]
695    fn test_deserialize_any_from_nested_map() {
696        assert_eq!(
697            serde_json::from_str::<Any>("{\"key1\":true,\"key2\":1.1,\"key3\":{\"key4\":true,\"key5\":1},\"key6\":[true,1,null]}").unwrap(),
698            Any::from(HashMap::from([
699                    ("key1".into(), Any::from(true)),
700                    ("key2".into(), Any::from(1.1f64)),
701                    ("key3".into(), Any::from(
702                        HashMap::from([
703                            ("key4".into(), Any::from(true)),
704                            ("key5".into(), Any::from(1))
705                        ])
706                    )),
707                    ("key6".into(), Any::from(vec![Any::from(true), Any::from(1), Any::Null]))
708                ])
709            )
710        );
711    }
712
713    #[test]
714    fn test_any_deserializer_many_fields() {
715        #[derive(Debug, Deserialize, PartialEq)]
716        struct Test {
717            bool: bool,
718            int: i64,
719            negative_int: i64,
720            max_int: i64,
721            min_int: i64,
722            real_number: f64,
723            max_number: f64,
724            min_number: f64,
725            null: Option<bool>,
726            some: Option<bool>,
727            undefined: Option<bool>,
728            nested: Nested,
729            enum_a: StringEnum,
730            enum_b: StringEnum,
731        }
732
733        #[derive(Debug, Deserialize, PartialEq)]
734        struct Nested {
735            int: i16,
736            other: f32,
737        }
738
739        #[derive(Debug, Deserialize, PartialEq)]
740        enum StringEnum {
741            VariantA,
742            VariantB,
743        }
744
745        let any = Any::from(HashMap::from([
746            ("bool".to_string(), Any::from(true)),
747            ("int".to_string(), Any::from(1)),
748            ("negative_int".to_string(), Any::from(-1)),
749            ("max_int".to_string(), Any::from(i64::MAX)),
750            ("min_int".to_string(), Any::from(i64::MIN)),
751            ("real_number".to_string(), Any::from(-123.2387f64)),
752            ("max_number".to_string(), Any::from(f64::MIN)),
753            ("min_number".to_string(), Any::from(f64::MAX)),
754            ("null".to_string(), Any::Null),
755            ("some".to_string(), Any::from(false)),
756            ("undefined".to_string(), Any::Undefined),
757            (
758                "nested".to_string(),
759                Any::from(HashMap::from([
760                    ("int".to_string(), Any::from(100)),
761                    ("other".to_string(), Any::from(100.0)),
762                ])),
763            ),
764            ("enum_a".to_string(), "VariantA".into()),
765            ("enum_b".to_string(), "VariantB".into()),
766        ]));
767
768        assert_eq!(
769            Test {
770                bool: true,
771                int: 1,
772                negative_int: -1,
773                max_int: i64::MAX,
774                min_int: i64::MIN,
775                real_number: -123.2387f64,
776                max_number: f64::MIN,
777                min_number: f64::MAX,
778                null: None,
779                some: Some(false),
780                undefined: None,
781                nested: Nested {
782                    int: 100,
783                    other: 100.0
784                },
785                enum_a: StringEnum::VariantA,
786                enum_b: StringEnum::VariantB
787            },
788            from_any(&any).unwrap()
789        )
790    }
791
792    #[test]
793    fn test_deserialize_any_to_any() {
794        let any = Any::from(HashMap::from([
795            ("bool".to_string(), Any::from(true)),
796            ("int".to_string(), Any::from(1)),
797            ("negative_int".to_string(), Any::from(-1)),
798            ("max_int".to_string(), Any::from(i64::MAX)),
799            ("min_int".to_string(), Any::from(i64::MIN)),
800            ("real_number".to_string(), Any::from(-123.2387f64)),
801            ("max_number".to_string(), Any::from(f64::MIN)),
802            ("min_number".to_string(), Any::from(f64::MAX)),
803            ("null".to_string(), Any::Null),
804            ("some".to_string(), Any::from(false)),
805            (
806                "nested".to_string(),
807                Any::from(HashMap::from([
808                    ("int".to_string(), Any::from(1i64 << 54)),
809                    ("other".to_string(), Any::from(100.0)),
810                ])),
811            ),
812            ("enum_a".to_string(), "VariantA".into()),
813            ("enum_b".to_string(), "VariantB".into()),
814        ]));
815
816        assert_eq!(any, from_any(&any.clone()).unwrap())
817    }
818
819    #[test]
820    fn test_any_deserializer_multiple_borrows() {
821        #[derive(Debug, Deserialize, PartialEq)]
822        struct Test<'a> {
823            str: &'a str,
824            bytes: &'a [u8],
825        }
826
827        let any = Any::from(HashMap::from([
828            ("str".to_string(), Any::from("String")),
829            ("bytes".to_string(), b"Bytes".to_vec().into()),
830        ]));
831
832        assert_eq!(
833            Test {
834                str: "String",
835                bytes: b"Bytes"
836            },
837            from_any(&any).unwrap()
838        )
839    }
840
841    #[test]
842    fn test_any_deserializer_nested_array() {
843        #[derive(Debug, Deserialize, PartialEq)]
844        struct Test {
845            array: Vec<Vec<bool>>,
846        }
847
848        let any: Any = HashMap::from([(
849            "array".to_string(),
850            Any::from(vec![
851                Any::from(vec![Any::Bool(true), Any::Bool(false)]),
852                Any::from(vec![Any::Bool(true)]),
853            ]),
854        )])
855        .into();
856
857        assert_eq!(
858            Test {
859                array: vec![vec![true, false], vec![true]]
860            },
861            from_any(&any).unwrap()
862        )
863    }
864
865    #[test]
866    fn test_any_deserializer_undefined() {
867        #[derive(Debug, Deserialize, PartialEq)]
868        struct Test {
869            undefined: Option<bool>,
870        }
871
872        let any: Any = HashMap::from([("undefined".to_string(), Any::Undefined)]).into();
873
874        assert_eq!(Test { undefined: None }, from_any(&any).unwrap())
875    }
876
877    #[test]
878    fn test_any_deserializer_int_does_not_fit_error() {
879        #[derive(Debug, Deserialize, PartialEq)]
880        struct Test {
881            test: i8,
882        }
883
884        let any: Any = HashMap::from([("test".to_string(), Any::BigInt(1000))]).into();
885
886        assert!(matches!(
887            from_any::<Test>(&any).unwrap_err(),
888            Error::UnexpectedValue,
889        ))
890    }
891
892    #[test]
893    fn test_any_deserializer_type_mismatch_error() {
894        #[derive(Debug, Deserialize, PartialEq)]
895        struct Test {
896            test: i8,
897        }
898
899        let any: Any = HashMap::from([("test".to_string(), Any::Number(1000.1f64))]).into();
900
901        let error = from_any::<Test>(&any).unwrap_err();
902        match error {
903            Error::TypeMismatch("i8") => { /* ok */ }
904            other => panic!("unexpected error {}", other),
905        }
906    }
907}
yrs/encoding/serde/de.rs

yrs/encoding/serde/
de.rs
