imbl_value/
de.rs

1use core::fmt;
2use core::str::FromStr;
3use imbl::Vector;
4use serde::de::{
5    self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
6    SeqAccess, Unexpected, VariantAccess, Visitor,
7};
8use serde::forward_to_deserialize_any;
9use serde_json::Error;
10use serde_json::Number;
11use std::ops::Deref;
12use std::sync::Arc;
13
14use crate::Value;
15use crate::{InOMap as Map, InternedString};
16
17impl<'de> Deserialize<'de> for Value {
18    #[inline]
19    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
20    where
21        D: serde::Deserializer<'de>,
22    {
23        struct ValueVisitor;
24
25        impl<'de> Visitor<'de> for ValueVisitor {
26            type Value = Value;
27
28            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
29                formatter.write_str("any valid JSON value")
30            }
31
32            #[inline]
33            fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
34                Ok(Value::Bool(value))
35            }
36
37            #[inline]
38            fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
39                Ok(Value::Number(value.into()))
40            }
41
42            #[inline]
43            fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
44                Ok(Value::Number(value.into()))
45            }
46
47            #[inline]
48            fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
49                Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
50            }
51
52            #[inline]
53            fn visit_str<E>(self, value: &str) -> Result<Value, E>
54            where
55                E: serde::de::Error,
56            {
57                self.visit_string(String::from(value))
58            }
59
60            #[inline]
61            fn visit_string<E>(self, value: String) -> Result<Value, E> {
62                Ok(Value::String(Arc::new(value)))
63            }
64
65            #[inline]
66            fn visit_none<E>(self) -> Result<Value, E> {
67                Ok(Value::Null)
68            }
69
70            #[inline]
71            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
72            where
73                D: serde::Deserializer<'de>,
74            {
75                Deserialize::deserialize(deserializer)
76            }
77
78            #[inline]
79            fn visit_unit<E>(self) -> Result<Value, E> {
80                Ok(Value::Null)
81            }
82
83            #[inline]
84            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
85            where
86                V: SeqAccess<'de>,
87            {
88                let mut vec = Vector::new();
89
90                while let Some(elem) = visitor.next_element()? {
91                    vec.push_back(elem);
92                }
93
94                Ok(Value::Array(vec))
95            }
96
97            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
98            where
99                V: MapAccess<'de>,
100            {
101                match visitor.next_key_seed(KeyClassifier)? {
102                    Some(KeyClass::Map(first_key)) => {
103                        let mut values = Map::new();
104
105                        values.insert(first_key, visitor.next_value()?);
106                        while let Some((key, value)) = visitor.next_entry()? {
107                            values.insert(key, value);
108                        }
109
110                        Ok(Value::Object(values))
111                    }
112                    None => Ok(Value::Object(Map::new())),
113                }
114            }
115        }
116
117        deserializer.deserialize_any(ValueVisitor)
118    }
119}
120
121impl FromStr for Value {
122    type Err = Error;
123    fn from_str(s: &str) -> Result<Value, Error> {
124        serde_json::from_str(s)
125    }
126}
127
128macro_rules! deserialize_number {
129    ($method:ident) => {
130        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
131        where
132            V: Visitor<'de>,
133        {
134            match self {
135                Value::Number(n) => n.$method(visitor),
136                _ => self.deserialize_any(visitor),
137            }
138        }
139    };
140}
141
142fn visit_array<'de, V>(array: Vector<Value>, visitor: V) -> Result<V::Value, Error>
143where
144    V: Visitor<'de>,
145{
146    let len = array.len();
147    let mut deserializer = SeqDeserializer::new(array);
148    let seq = visitor.visit_seq(&mut deserializer)?;
149    let remaining = deserializer.iter.len();
150    if remaining == 0 {
151        Ok(seq)
152    } else {
153        Err(serde::de::Error::invalid_length(
154            len,
155            &"fewer elements in array",
156        ))
157    }
158}
159
160fn visit_object<'de, V>(object: Map<InternedString, Value>, visitor: V) -> Result<V::Value, Error>
161where
162    V: Visitor<'de>,
163{
164    let len = object.len();
165    let mut deserializer = MapDeserializer::new(object);
166    let map = visitor.visit_map(&mut deserializer)?;
167    let remaining = deserializer.iter.len();
168    if remaining == 0 {
169        Ok(map)
170    } else {
171        Err(serde::de::Error::invalid_length(
172            len,
173            &"fewer elements in map",
174        ))
175    }
176}
177
178impl<'de> serde::Deserializer<'de> for Value {
179    type Error = Error;
180
181    #[inline]
182    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
183    where
184        V: Visitor<'de>,
185    {
186        match self {
187            Value::Null => visitor.visit_unit(),
188            Value::Bool(v) => visitor.visit_bool(v),
189            Value::Number(n) => n.deserialize_any(visitor),
190            Value::String(v) => match Arc::try_unwrap(v) {
191                Err(v) => visitor.visit_str(v.as_str()),
192                Ok(v) => visitor.visit_string(v),
193            },
194            Value::Array(v) => visit_array(v, visitor),
195            Value::Object(v) => visit_object(v, visitor),
196        }
197    }
198
199    deserialize_number!(deserialize_i8);
200    deserialize_number!(deserialize_i16);
201    deserialize_number!(deserialize_i32);
202    deserialize_number!(deserialize_i64);
203    deserialize_number!(deserialize_i128);
204    deserialize_number!(deserialize_u8);
205    deserialize_number!(deserialize_u16);
206    deserialize_number!(deserialize_u32);
207    deserialize_number!(deserialize_u64);
208    deserialize_number!(deserialize_u128);
209    deserialize_number!(deserialize_f32);
210    deserialize_number!(deserialize_f64);
211
212    #[inline]
213    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
214    where
215        V: Visitor<'de>,
216    {
217        match self {
218            Value::Null => visitor.visit_none(),
219            _ => visitor.visit_some(self),
220        }
221    }
222
223    #[inline]
224    fn deserialize_enum<V>(
225        self,
226        _name: &str,
227        _variants: &'static [&'static str],
228        visitor: V,
229    ) -> Result<V::Value, Error>
230    where
231        V: Visitor<'de>,
232    {
233        let (variant, value) = match self {
234            Value::Object(value) => {
235                let mut iter = value.into_iter();
236                let (variant, value) = match iter.next() {
237                    Some(v) => v,
238                    None => {
239                        return Err(serde::de::Error::invalid_value(
240                            Unexpected::Map,
241                            &"map with a single key",
242                        ));
243                    }
244                };
245                // enums are encoded in json as maps with a single key:value pair
246                if iter.next().is_some() {
247                    return Err(serde::de::Error::invalid_value(
248                        Unexpected::Map,
249                        &"map with a single key",
250                    ));
251                }
252                (variant, Some(value))
253            }
254            Value::String(variant) => (
255                InternedString::intern({
256                    struct ArcStr(Arc<String>);
257                    impl fmt::Display for ArcStr {
258                        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
259                            fmt::Display::fmt(&self.0, f)
260                        }
261                    }
262                    impl From<ArcStr> for String {
263                        fn from(value: ArcStr) -> Self {
264                            Arc::try_unwrap(value.0).unwrap_or_else(|v| v.deref().to_owned())
265                        }
266                    }
267                    ArcStr(variant)
268                }),
269                None,
270            ),
271            other => {
272                return Err(serde::de::Error::invalid_type(
273                    other.unexpected(),
274                    &"string or map",
275                ));
276            }
277        };
278
279        visitor.visit_enum(EnumDeserializer { variant, value })
280    }
281
282    #[inline]
283    fn deserialize_newtype_struct<V>(
284        self,
285        name: &'static str,
286        visitor: V,
287    ) -> Result<V::Value, Error>
288    where
289        V: Visitor<'de>,
290    {
291        let _ = name;
292        visitor.visit_newtype_struct(self)
293    }
294
295    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
296    where
297        V: Visitor<'de>,
298    {
299        match self {
300            Value::Bool(v) => visitor.visit_bool(v),
301            _ => Err(self.invalid_type(&visitor)),
302        }
303    }
304
305    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
306    where
307        V: Visitor<'de>,
308    {
309        self.deserialize_string(visitor)
310    }
311
312    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
313    where
314        V: Visitor<'de>,
315    {
316        self.deserialize_string(visitor)
317    }
318
319    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
320    where
321        V: Visitor<'de>,
322    {
323        match self {
324            Value::String(v) => match Arc::try_unwrap(v) {
325                Err(v) => visitor.visit_str(v.as_str()),
326                Ok(v) => visitor.visit_string(v),
327            },
328            _ => Err(self.invalid_type(&visitor)),
329        }
330    }
331
332    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
333    where
334        V: Visitor<'de>,
335    {
336        self.deserialize_byte_buf(visitor)
337    }
338
339    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
340    where
341        V: Visitor<'de>,
342    {
343        match self {
344            Value::String(v) => match Arc::try_unwrap(v) {
345                Err(v) => visitor.visit_str(v.as_str()),
346                Ok(v) => visitor.visit_string(v),
347            },
348            Value::Array(v) => visit_array(v, visitor),
349            _ => Err(self.invalid_type(&visitor)),
350        }
351    }
352
353    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
354    where
355        V: Visitor<'de>,
356    {
357        match self {
358            Value::Null => visitor.visit_unit(),
359            _ => Err(self.invalid_type(&visitor)),
360        }
361    }
362
363    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
364    where
365        V: Visitor<'de>,
366    {
367        self.deserialize_unit(visitor)
368    }
369
370    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
371    where
372        V: Visitor<'de>,
373    {
374        match self {
375            Value::Array(v) => visit_array(v, visitor),
376            _ => Err(self.invalid_type(&visitor)),
377        }
378    }
379
380    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
381    where
382        V: Visitor<'de>,
383    {
384        self.deserialize_seq(visitor)
385    }
386
387    fn deserialize_tuple_struct<V>(
388        self,
389        _name: &'static str,
390        _len: usize,
391        visitor: V,
392    ) -> Result<V::Value, Error>
393    where
394        V: Visitor<'de>,
395    {
396        self.deserialize_seq(visitor)
397    }
398
399    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
400    where
401        V: Visitor<'de>,
402    {
403        match self {
404            Value::Object(v) => visit_object(v, visitor),
405            _ => Err(self.invalid_type(&visitor)),
406        }
407    }
408
409    fn deserialize_struct<V>(
410        self,
411        _name: &'static str,
412        _fields: &'static [&'static str],
413        visitor: V,
414    ) -> Result<V::Value, Error>
415    where
416        V: Visitor<'de>,
417    {
418        match self {
419            Value::Array(v) => visit_array(v, visitor),
420            Value::Object(v) => visit_object(v, visitor),
421            _ => Err(self.invalid_type(&visitor)),
422        }
423    }
424
425    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
426    where
427        V: Visitor<'de>,
428    {
429        self.deserialize_string(visitor)
430    }
431
432    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
433    where
434        V: Visitor<'de>,
435    {
436        drop(self);
437        visitor.visit_unit()
438    }
439}
440
441struct EnumDeserializer {
442    variant: InternedString,
443    value: Option<Value>,
444}
445
446impl<'de> EnumAccess<'de> for EnumDeserializer {
447    type Error = Error;
448    type Variant = VariantDeserializer;
449
450    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
451    where
452        V: DeserializeSeed<'de>,
453    {
454        let variant = self.variant.into_deserializer();
455        let visitor = VariantDeserializer { value: self.value };
456        seed.deserialize(variant).map(|v| (v, visitor))
457    }
458}
459
460impl<'de> IntoDeserializer<'de, Error> for Value {
461    type Deserializer = Self;
462
463    fn into_deserializer(self) -> Self::Deserializer {
464        self
465    }
466}
467
468struct VariantDeserializer {
469    value: Option<Value>,
470}
471
472impl<'de> VariantAccess<'de> for VariantDeserializer {
473    type Error = Error;
474
475    fn unit_variant(self) -> Result<(), Error> {
476        match self.value {
477            Some(value) => Deserialize::deserialize(value),
478            None => Ok(()),
479        }
480    }
481
482    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
483    where
484        T: DeserializeSeed<'de>,
485    {
486        match self.value {
487            Some(value) => seed.deserialize(value),
488            None => Err(serde::de::Error::invalid_type(
489                Unexpected::UnitVariant,
490                &"newtype variant",
491            )),
492        }
493    }
494
495    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
496    where
497        V: Visitor<'de>,
498    {
499        match self.value {
500            Some(Value::Array(v)) => {
501                if v.is_empty() {
502                    visitor.visit_unit()
503                } else {
504                    visit_array(v, visitor)
505                }
506            }
507            Some(other) => Err(serde::de::Error::invalid_type(
508                other.unexpected(),
509                &"tuple variant",
510            )),
511            None => Err(serde::de::Error::invalid_type(
512                Unexpected::UnitVariant,
513                &"tuple variant",
514            )),
515        }
516    }
517
518    fn struct_variant<V>(
519        self,
520        _fields: &'static [&'static str],
521        visitor: V,
522    ) -> Result<V::Value, Error>
523    where
524        V: Visitor<'de>,
525    {
526        match self.value {
527            Some(Value::Object(v)) => visit_object(v, visitor),
528            Some(other) => Err(serde::de::Error::invalid_type(
529                other.unexpected(),
530                &"struct variant",
531            )),
532            None => Err(serde::de::Error::invalid_type(
533                Unexpected::UnitVariant,
534                &"struct variant",
535            )),
536        }
537    }
538}
539
540struct SeqDeserializer {
541    iter: imbl::vector::ConsumingIter<Value>,
542}
543
544impl SeqDeserializer {
545    fn new(vec: Vector<Value>) -> Self {
546        SeqDeserializer {
547            iter: vec.into_iter(),
548        }
549    }
550}
551
552impl<'de> SeqAccess<'de> for SeqDeserializer {
553    type Error = Error;
554
555    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
556    where
557        T: DeserializeSeed<'de>,
558    {
559        match self.iter.next() {
560            Some(value) => seed.deserialize(value).map(Some),
561            None => Ok(None),
562        }
563    }
564
565    fn size_hint(&self) -> Option<usize> {
566        match self.iter.size_hint() {
567            (lower, Some(upper)) if lower == upper => Some(upper),
568            _ => None,
569        }
570    }
571}
572
573struct MapDeserializer {
574    iter: <Map<InternedString, Value> as IntoIterator>::IntoIter,
575    value: Option<Value>,
576}
577
578impl MapDeserializer {
579    fn new(map: Map<InternedString, Value>) -> Self {
580        MapDeserializer {
581            iter: map.into_iter(),
582            value: None,
583        }
584    }
585}
586
587impl<'de> MapAccess<'de> for MapDeserializer {
588    type Error = Error;
589
590    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
591    where
592        T: DeserializeSeed<'de>,
593    {
594        match self.iter.next() {
595            Some((key, value)) => {
596                self.value = Some(value);
597                let key_de = MapKeyDeserializer { key };
598                seed.deserialize(key_de).map(Some)
599            }
600            None => Ok(None),
601        }
602    }
603
604    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
605    where
606        T: DeserializeSeed<'de>,
607    {
608        match self.value.take() {
609            Some(value) => seed.deserialize(value),
610            None => Err(serde::de::Error::custom("value is missing")),
611        }
612    }
613
614    fn size_hint(&self) -> Option<usize> {
615        match self.iter.size_hint() {
616            (lower, Some(upper)) if lower == upper => Some(upper),
617            _ => None,
618        }
619    }
620}
621
622macro_rules! deserialize_value_ref_number {
623    ($method:ident) => {
624        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
625        where
626            V: Visitor<'de>,
627        {
628            match self {
629                Value::Number(n) => n.deserialize_any(visitor),
630                _ => Err(self.invalid_type(&visitor)),
631            }
632        }
633    };
634}
635
636fn visit_array_ref<'de, V>(array: &'de Vector<Value>, visitor: V) -> Result<V::Value, Error>
637where
638    V: Visitor<'de>,
639{
640    let len = array.len();
641    let mut deserializer = SeqRefDeserializer::new(array);
642    let seq = visitor.visit_seq(&mut deserializer)?;
643    let remaining = deserializer.iter.len();
644    if remaining == 0 {
645        Ok(seq)
646    } else {
647        Err(serde::de::Error::invalid_length(
648            len,
649            &"fewer elements in array",
650        ))
651    }
652}
653
654fn visit_object_ref<'de, V>(
655    object: &'de Map<InternedString, Value>,
656    visitor: V,
657) -> Result<V::Value, Error>
658where
659    V: Visitor<'de>,
660{
661    let len = object.len();
662    let mut deserializer = MapRefDeserializer::new(object);
663    let map = visitor.visit_map(&mut deserializer)?;
664    let remaining = deserializer.iter.len();
665    if remaining == 0 {
666        Ok(map)
667    } else {
668        Err(serde::de::Error::invalid_length(
669            len,
670            &"fewer elements in map",
671        ))
672    }
673}
674
675impl<'de> serde::Deserializer<'de> for &'de Value {
676    type Error = Error;
677
678    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
679    where
680        V: Visitor<'de>,
681    {
682        match self {
683            Value::Null => visitor.visit_unit(),
684            Value::Bool(v) => visitor.visit_bool(*v),
685            Value::Number(n) => n.deserialize_any(visitor),
686            Value::String(v) => visitor.visit_borrowed_str(v),
687            Value::Array(v) => visit_array_ref(v, visitor),
688            Value::Object(v) => visit_object_ref(v, visitor),
689        }
690    }
691
692    deserialize_value_ref_number!(deserialize_i8);
693    deserialize_value_ref_number!(deserialize_i16);
694    deserialize_value_ref_number!(deserialize_i32);
695    deserialize_value_ref_number!(deserialize_i64);
696    deserialize_number!(deserialize_i128);
697    deserialize_value_ref_number!(deserialize_u8);
698    deserialize_value_ref_number!(deserialize_u16);
699    deserialize_value_ref_number!(deserialize_u32);
700    deserialize_value_ref_number!(deserialize_u64);
701    deserialize_number!(deserialize_u128);
702    deserialize_value_ref_number!(deserialize_f32);
703    deserialize_value_ref_number!(deserialize_f64);
704
705    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
706    where
707        V: Visitor<'de>,
708    {
709        match *self {
710            Value::Null => visitor.visit_none(),
711            _ => visitor.visit_some(self),
712        }
713    }
714
715    fn deserialize_enum<V>(
716        self,
717        _name: &str,
718        _variants: &'static [&'static str],
719        visitor: V,
720    ) -> Result<V::Value, Error>
721    where
722        V: Visitor<'de>,
723    {
724        let (variant, value) = match self {
725            Value::Object(value) => {
726                let mut iter = value.into_iter();
727                let (variant, value) = match iter.next() {
728                    Some(v) => v,
729                    None => {
730                        return Err(serde::de::Error::invalid_value(
731                            Unexpected::Map,
732                            &"map with a single key",
733                        ));
734                    }
735                };
736                // enums are encoded in json as maps with a single key:value pair
737                if iter.next().is_some() {
738                    return Err(serde::de::Error::invalid_value(
739                        Unexpected::Map,
740                        &"map with a single key",
741                    ));
742                }
743                (&**variant, Some(value))
744            }
745            Value::String(variant) => (&***variant, None),
746            other => {
747                return Err(serde::de::Error::invalid_type(
748                    other.unexpected(),
749                    &"string or map",
750                ));
751            }
752        };
753
754        visitor.visit_enum(EnumRefDeserializer { variant, value })
755    }
756
757    #[inline]
758    fn deserialize_newtype_struct<V>(
759        self,
760        name: &'static str,
761        visitor: V,
762    ) -> Result<V::Value, Error>
763    where
764        V: Visitor<'de>,
765    {
766        let _ = name;
767        visitor.visit_newtype_struct(self)
768    }
769
770    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
771    where
772        V: Visitor<'de>,
773    {
774        match *self {
775            Value::Bool(v) => visitor.visit_bool(v),
776            _ => Err(self.invalid_type(&visitor)),
777        }
778    }
779
780    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
781    where
782        V: Visitor<'de>,
783    {
784        self.deserialize_str(visitor)
785    }
786
787    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
788    where
789        V: Visitor<'de>,
790    {
791        match self {
792            Value::String(v) => visitor.visit_borrowed_str(v),
793            _ => Err(self.invalid_type(&visitor)),
794        }
795    }
796
797    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
798    where
799        V: Visitor<'de>,
800    {
801        self.deserialize_str(visitor)
802    }
803
804    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
805    where
806        V: Visitor<'de>,
807    {
808        match self {
809            Value::String(v) => visitor.visit_borrowed_str(v),
810            Value::Array(v) => visit_array_ref(v, visitor),
811            _ => Err(self.invalid_type(&visitor)),
812        }
813    }
814
815    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
816    where
817        V: Visitor<'de>,
818    {
819        self.deserialize_bytes(visitor)
820    }
821
822    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
823    where
824        V: Visitor<'de>,
825    {
826        match *self {
827            Value::Null => visitor.visit_unit(),
828            _ => Err(self.invalid_type(&visitor)),
829        }
830    }
831
832    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
833    where
834        V: Visitor<'de>,
835    {
836        self.deserialize_unit(visitor)
837    }
838
839    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
840    where
841        V: Visitor<'de>,
842    {
843        match self {
844            Value::Array(v) => visit_array_ref(v, visitor),
845            _ => Err(self.invalid_type(&visitor)),
846        }
847    }
848
849    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
850    where
851        V: Visitor<'de>,
852    {
853        self.deserialize_seq(visitor)
854    }
855
856    fn deserialize_tuple_struct<V>(
857        self,
858        _name: &'static str,
859        _len: usize,
860        visitor: V,
861    ) -> Result<V::Value, Error>
862    where
863        V: Visitor<'de>,
864    {
865        self.deserialize_seq(visitor)
866    }
867
868    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
869    where
870        V: Visitor<'de>,
871    {
872        match self {
873            Value::Object(v) => visit_object_ref(v, visitor),
874            _ => Err(self.invalid_type(&visitor)),
875        }
876    }
877
878    fn deserialize_struct<V>(
879        self,
880        _name: &'static str,
881        _fields: &'static [&'static str],
882        visitor: V,
883    ) -> Result<V::Value, Error>
884    where
885        V: Visitor<'de>,
886    {
887        match self {
888            Value::Array(v) => visit_array_ref(v, visitor),
889            Value::Object(v) => visit_object_ref(v, visitor),
890            _ => Err(self.invalid_type(&visitor)),
891        }
892    }
893
894    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
895    where
896        V: Visitor<'de>,
897    {
898        self.deserialize_str(visitor)
899    }
900
901    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
902    where
903        V: Visitor<'de>,
904    {
905        visitor.visit_unit()
906    }
907}
908
909struct EnumRefDeserializer<'de> {
910    variant: &'de str,
911    value: Option<&'de Value>,
912}
913
914impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
915    type Error = Error;
916    type Variant = VariantRefDeserializer<'de>;
917
918    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
919    where
920        V: DeserializeSeed<'de>,
921    {
922        let variant = self.variant.into_deserializer();
923        let visitor = VariantRefDeserializer { value: self.value };
924        seed.deserialize(variant).map(|v| (v, visitor))
925    }
926}
927
928struct VariantRefDeserializer<'de> {
929    value: Option<&'de Value>,
930}
931
932impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
933    type Error = Error;
934
935    fn unit_variant(self) -> Result<(), Error> {
936        match self.value {
937            Some(value) => Deserialize::deserialize(value),
938            None => Ok(()),
939        }
940    }
941
942    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
943    where
944        T: DeserializeSeed<'de>,
945    {
946        match self.value {
947            Some(value) => seed.deserialize(value),
948            None => Err(serde::de::Error::invalid_type(
949                Unexpected::UnitVariant,
950                &"newtype variant",
951            )),
952        }
953    }
954
955    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
956    where
957        V: Visitor<'de>,
958    {
959        match self.value {
960            Some(Value::Array(v)) => {
961                if v.is_empty() {
962                    visitor.visit_unit()
963                } else {
964                    visit_array_ref(v, visitor)
965                }
966            }
967            Some(other) => Err(serde::de::Error::invalid_type(
968                other.unexpected(),
969                &"tuple variant",
970            )),
971            None => Err(serde::de::Error::invalid_type(
972                Unexpected::UnitVariant,
973                &"tuple variant",
974            )),
975        }
976    }
977
978    fn struct_variant<V>(
979        self,
980        _fields: &'static [&'static str],
981        visitor: V,
982    ) -> Result<V::Value, Error>
983    where
984        V: Visitor<'de>,
985    {
986        match self.value {
987            Some(Value::Object(v)) => visit_object_ref(v, visitor),
988            Some(other) => Err(serde::de::Error::invalid_type(
989                other.unexpected(),
990                &"struct variant",
991            )),
992            None => Err(serde::de::Error::invalid_type(
993                Unexpected::UnitVariant,
994                &"struct variant",
995            )),
996        }
997    }
998}
999
1000struct SeqRefDeserializer<'de> {
1001    iter: imbl::vector::Iter<'de, Value>,
1002}
1003
1004impl<'de> SeqRefDeserializer<'de> {
1005    fn new(slice: &'de Vector<Value>) -> Self {
1006        SeqRefDeserializer { iter: slice.iter() }
1007    }
1008}
1009
1010impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
1011    type Error = Error;
1012
1013    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1014    where
1015        T: DeserializeSeed<'de>,
1016    {
1017        match self.iter.next() {
1018            Some(value) => seed.deserialize(value).map(Some),
1019            None => Ok(None),
1020        }
1021    }
1022
1023    fn size_hint(&self) -> Option<usize> {
1024        match self.iter.size_hint() {
1025            (lower, Some(upper)) if lower == upper => Some(upper),
1026            _ => None,
1027        }
1028    }
1029}
1030
1031struct MapRefDeserializer<'de> {
1032    iter: <&'de Map<InternedString, Value> as IntoIterator>::IntoIter,
1033    value: Option<&'de Value>,
1034}
1035
1036impl<'de> MapRefDeserializer<'de> {
1037    fn new(map: &'de Map<InternedString, Value>) -> Self {
1038        MapRefDeserializer {
1039            iter: map.into_iter(),
1040            value: None,
1041        }
1042    }
1043}
1044
1045impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
1046    type Error = Error;
1047
1048    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1049    where
1050        T: DeserializeSeed<'de>,
1051    {
1052        match self.iter.next() {
1053            Some((key, value)) => {
1054                self.value = Some(value);
1055                let key_de = MapKeyDeserializer { key: key.clone() };
1056                seed.deserialize(key_de).map(Some)
1057            }
1058            None => Ok(None),
1059        }
1060    }
1061
1062    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1063    where
1064        T: DeserializeSeed<'de>,
1065    {
1066        match self.value.take() {
1067            Some(value) => seed.deserialize(value),
1068            None => Err(serde::de::Error::custom("value is missing")),
1069        }
1070    }
1071
1072    fn size_hint(&self) -> Option<usize> {
1073        match self.iter.size_hint() {
1074            (lower, Some(upper)) if lower == upper => Some(upper),
1075            _ => None,
1076        }
1077    }
1078}
1079
1080struct MapKeyDeserializer {
1081    key: InternedString,
1082}
1083
1084macro_rules! deserialize_integer_key {
1085    ($method:ident => $visit:ident) => {
1086        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
1087        where
1088            V: Visitor<'de>,
1089        {
1090            match self.key.parse() {
1091                Ok(integer) => visitor.$visit(integer),
1092                Err(_) => visitor.visit_str(&*self.key),
1093            }
1094        }
1095    };
1096}
1097
1098impl<'de> serde::Deserializer<'de> for MapKeyDeserializer {
1099    type Error = Error;
1100
1101    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1102    where
1103        V: Visitor<'de>,
1104    {
1105        InternedStringDeserializer::new(self.key).deserialize_any(visitor)
1106    }
1107
1108    deserialize_integer_key!(deserialize_i8 => visit_i8);
1109    deserialize_integer_key!(deserialize_i16 => visit_i16);
1110    deserialize_integer_key!(deserialize_i32 => visit_i32);
1111    deserialize_integer_key!(deserialize_i64 => visit_i64);
1112    deserialize_integer_key!(deserialize_i128 => visit_i128);
1113    deserialize_integer_key!(deserialize_u8 => visit_u8);
1114    deserialize_integer_key!(deserialize_u16 => visit_u16);
1115    deserialize_integer_key!(deserialize_u32 => visit_u32);
1116    deserialize_integer_key!(deserialize_u64 => visit_u64);
1117    deserialize_integer_key!(deserialize_u128 => visit_u128);
1118
1119    #[inline]
1120    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
1121    where
1122        V: Visitor<'de>,
1123    {
1124        // Map keys cannot be null.
1125        visitor.visit_some(self)
1126    }
1127
1128    #[inline]
1129    fn deserialize_newtype_struct<V>(
1130        self,
1131        _name: &'static str,
1132        visitor: V,
1133    ) -> Result<V::Value, Error>
1134    where
1135        V: Visitor<'de>,
1136    {
1137        visitor.visit_newtype_struct(self)
1138    }
1139
1140    fn deserialize_enum<V>(
1141        self,
1142        name: &'static str,
1143        variants: &'static [&'static str],
1144        visitor: V,
1145    ) -> Result<V::Value, Error>
1146    where
1147        V: Visitor<'de>,
1148    {
1149        InternedStringDeserializer::new(self.key).deserialize_enum(name, variants, visitor)
1150    }
1151
1152    forward_to_deserialize_any! {
1153        bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
1154        tuple_struct map struct identifier ignored_any
1155    }
1156}
1157
1158struct KeyClassifier;
1159
1160enum KeyClass {
1161    Map(InternedString),
1162}
1163
1164impl<'de> DeserializeSeed<'de> for KeyClassifier {
1165    type Value = KeyClass;
1166
1167    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1168    where
1169        D: serde::Deserializer<'de>,
1170    {
1171        deserializer.deserialize_str(self)
1172    }
1173}
1174
1175impl<'de> Visitor<'de> for KeyClassifier {
1176    type Value = KeyClass;
1177
1178    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1179        formatter.write_str("a string key")
1180    }
1181
1182    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1183    where
1184        E: de::Error,
1185    {
1186        match s {
1187            _ => Ok(KeyClass::Map(InternedString::intern(s))),
1188        }
1189    }
1190
1191    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
1192    where
1193        E: de::Error,
1194    {
1195        match s.as_str() {
1196            _ => Ok(KeyClass::Map(InternedString::intern(s))),
1197        }
1198    }
1199}
1200
1201impl Value {
1202    #[cold]
1203    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
1204    where
1205        E: serde::de::Error,
1206    {
1207        serde::de::Error::invalid_type(self.unexpected(), exp)
1208    }
1209
1210    #[cold]
1211    fn unexpected(&self) -> Unexpected {
1212        match self {
1213            Value::Null => Unexpected::Unit,
1214            Value::Bool(b) => Unexpected::Bool(*b),
1215            Value::Number(n) => {
1216                if let Some(n) = n.as_u64() {
1217                    Unexpected::Unsigned(n)
1218                } else if let Some(n) = n.as_i64() {
1219                    Unexpected::Signed(n)
1220                } else if let Some(n) = n.as_f64() {
1221                    Unexpected::Float(n)
1222                } else {
1223                    unreachable!()
1224                }
1225            }
1226            Value::String(s) => Unexpected::Str(s),
1227            Value::Array(_) => Unexpected::Seq,
1228            Value::Object(_) => Unexpected::Map,
1229        }
1230    }
1231}
1232
1233impl From<InternedString> for InternedStringDeserializer {
1234    fn from(value: InternedString) -> Self {
1235        Self { value }
1236    }
1237}
1238pub struct InternedStringDeserializer {
1239    value: InternedString,
1240}
1241
1242impl InternedStringDeserializer {
1243    fn new(value: InternedString) -> Self {
1244        InternedStringDeserializer { value }
1245    }
1246}
1247
1248impl<'de> de::Deserializer<'de> for InternedStringDeserializer {
1249    type Error = Error;
1250
1251    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1252    where
1253        V: de::Visitor<'de>,
1254    {
1255        visitor.visit_str(&*self.value)
1256    }
1257
1258    fn deserialize_enum<V>(
1259        self,
1260        _name: &str,
1261        _variants: &'static [&'static str],
1262        visitor: V,
1263    ) -> Result<V::Value, Error>
1264    where
1265        V: de::Visitor<'de>,
1266    {
1267        visitor.visit_enum(self)
1268    }
1269
1270    forward_to_deserialize_any! {
1271        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1272        bytes byte_buf option unit unit_struct newtype_struct seq tuple
1273        tuple_struct map struct identifier ignored_any
1274    }
1275}
1276
1277impl<'de> de::EnumAccess<'de> for InternedStringDeserializer {
1278    type Error = Error;
1279    type Variant = UnitOnly;
1280
1281    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error>
1282    where
1283        T: de::DeserializeSeed<'de>,
1284    {
1285        let value = seed.deserialize(self)?;
1286        Ok((value, UnitOnly))
1287    }
1288}
1289
1290pub struct UnitOnly;
1291
1292impl<'de> de::VariantAccess<'de> for UnitOnly {
1293    type Error = Error;
1294
1295    fn unit_variant(self) -> Result<(), Error> {
1296        Ok(())
1297    }
1298
1299    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
1300    where
1301        T: de::DeserializeSeed<'de>,
1302    {
1303        Err(de::Error::invalid_type(
1304            Unexpected::UnitVariant,
1305            &"newtype variant",
1306        ))
1307    }
1308
1309    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
1310    where
1311        V: de::Visitor<'de>,
1312    {
1313        Err(de::Error::invalid_type(
1314            Unexpected::UnitVariant,
1315            &"tuple variant",
1316        ))
1317    }
1318
1319    fn struct_variant<V>(
1320        self,
1321        _fields: &'static [&'static str],
1322        _visitor: V,
1323    ) -> Result<V::Value, Error>
1324    where
1325        V: de::Visitor<'de>,
1326    {
1327        Err(de::Error::invalid_type(
1328            Unexpected::UnitVariant,
1329            &"struct variant",
1330        ))
1331    }
1332}
imbl_value/de.rs

imbl_value/
de.rs
