conjure_object/any/
de.rs

1// Copyright 2020 Palantir Technologies, Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14use crate::any::{Any, Error, Inner};
15use base64::engine::general_purpose::STANDARD;
16use base64::Engine;
17use ordered_float::OrderedFloat;
18use serde::de::{
19    DeserializeSeed, EnumAccess, Error as _, MapAccess, SeqAccess, Unexpected, VariantAccess,
20    Visitor,
21};
22use serde::{de, forward_to_deserialize_any, Deserialize, Deserializer};
23use std::collections::{btree_map, BTreeMap};
24use std::f32;
25use std::f64;
26use std::fmt;
27use std::vec;
28
29impl<'de> Deserialize<'de> for Any {
30    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
31    where
32        D: Deserializer<'de>,
33    {
34        deserializer.deserialize_any(AnyVisitor)
35    }
36}
37
38struct AnyVisitor;
39
40impl<'de> Visitor<'de> for AnyVisitor {
41    type Value = Any;
42
43    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
44        formatter.write_str("any JSON value")
45    }
46
47    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
48    where
49        E: de::Error,
50    {
51        Ok(Any(Inner::Bool(v)))
52    }
53
54    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
55    where
56        E: de::Error,
57    {
58        Ok(Any(Inner::I8(v)))
59    }
60
61    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
62    where
63        E: de::Error,
64    {
65        Ok(Any(Inner::I16(v)))
66    }
67
68    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
69    where
70        E: de::Error,
71    {
72        Ok(Any(Inner::I32(v)))
73    }
74
75    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
76    where
77        E: de::Error,
78    {
79        Ok(Any(Inner::I64(v)))
80    }
81
82    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
83    where
84        E: de::Error,
85    {
86        Ok(Any(Inner::I128(v)))
87    }
88
89    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
90    where
91        E: de::Error,
92    {
93        Ok(Any(Inner::U8(v)))
94    }
95
96    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
97    where
98        E: de::Error,
99    {
100        Ok(Any(Inner::U16(v)))
101    }
102
103    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
104    where
105        E: de::Error,
106    {
107        Ok(Any(Inner::U32(v)))
108    }
109
110    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
111    where
112        E: de::Error,
113    {
114        Ok(Any(Inner::U64(v)))
115    }
116
117    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
118    where
119        E: de::Error,
120    {
121        Ok(Any(Inner::U128(v)))
122    }
123
124    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
125    where
126        E: de::Error,
127    {
128        Ok(Any(Inner::F32(OrderedFloat(v))))
129    }
130
131    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
132    where
133        E: de::Error,
134    {
135        Ok(Any(Inner::F64(OrderedFloat(v))))
136    }
137
138    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
139    where
140        E: de::Error,
141    {
142        Ok(Any(Inner::Char(v)))
143    }
144
145    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
146    where
147        E: de::Error,
148    {
149        Ok(Any(Inner::String(v.to_string())))
150    }
151
152    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
153    where
154        E: de::Error,
155    {
156        Ok(Any(Inner::String(v)))
157    }
158
159    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
160    where
161        E: de::Error,
162    {
163        Ok(Any(Inner::Bytes(v.to_vec())))
164    }
165
166    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
167    where
168        E: de::Error,
169    {
170        Ok(Any(Inner::Bytes(v)))
171    }
172
173    fn visit_none<E>(self) -> Result<Self::Value, E>
174    where
175        E: de::Error,
176    {
177        Ok(Any(Inner::Null))
178    }
179
180    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
181    where
182        D: Deserializer<'de>,
183    {
184        Any::deserialize(deserializer)
185    }
186
187    fn visit_unit<E>(self) -> Result<Self::Value, E>
188    where
189        E: de::Error,
190    {
191        Ok(Any(Inner::Null))
192    }
193
194    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
195    where
196        A: SeqAccess<'de>,
197    {
198        let mut out = vec![];
199
200        while let Some(value) = seq.next_element()? {
201            out.push(value);
202        }
203
204        Ok(Any(Inner::Seq(out)))
205    }
206
207    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
208    where
209        A: MapAccess<'de>,
210    {
211        let mut out = BTreeMap::new();
212
213        while let Some((key, value)) = map.next_entry()? {
214            out.insert(key, value);
215        }
216
217        Ok(Any(Inner::Map(out)))
218    }
219}
220
221impl<'de> Deserializer<'de> for Any {
222    type Error = Error;
223
224    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
225    where
226        V: Visitor<'de>,
227    {
228        match self.0 {
229            Inner::Null => visitor.visit_unit(),
230            Inner::Bool(v) => visitor.visit_bool(v),
231            Inner::I8(v) => visitor.visit_i8(v),
232            Inner::I16(v) => visitor.visit_i16(v),
233            Inner::I32(v) => visitor.visit_i32(v),
234            Inner::I64(v) => visitor.visit_i64(v),
235            Inner::I128(v) => visitor.visit_i128(v),
236            Inner::U8(v) => visitor.visit_u8(v),
237            Inner::U16(v) => visitor.visit_u16(v),
238            Inner::U32(v) => visitor.visit_u32(v),
239            Inner::U64(v) => visitor.visit_u64(v),
240            Inner::U128(v) => visitor.visit_u128(v),
241            Inner::F32(v) => visitor.visit_f32(v.0),
242            Inner::F64(v) => visitor.visit_f64(v.0),
243            Inner::Char(v) => visitor.visit_char(v),
244            Inner::String(v) => visitor.visit_string(v),
245            Inner::Bytes(v) => visitor.visit_byte_buf(v),
246            Inner::Seq(v) => visitor.visit_seq(SeqDeserializer(v.into_iter())),
247            Inner::Map(v) => visitor.visit_map(MapDeserializer {
248                it: v.into_iter(),
249                value: None,
250            }),
251        }
252    }
253
254    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
255    where
256        V: Visitor<'de>,
257    {
258        match &self.0 {
259            Inner::String(v) if v == "NaN" => visitor.visit_f32(f32::NAN),
260            Inner::String(v) if v == "Infinity" => visitor.visit_f32(f32::INFINITY),
261            Inner::String(v) if v == "-Infinity" => visitor.visit_f32(f32::NEG_INFINITY),
262            _ => self.deserialize_any(visitor),
263        }
264    }
265
266    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
267    where
268        V: Visitor<'de>,
269    {
270        match &self.0 {
271            Inner::String(v) if v == "NaN" => visitor.visit_f64(f64::NAN),
272            Inner::String(v) if v == "Infinity" => visitor.visit_f64(f64::INFINITY),
273            Inner::String(v) if v == "-Infinity" => visitor.visit_f64(f64::NEG_INFINITY),
274            _ => self.deserialize_any(visitor),
275        }
276    }
277
278    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
279    where
280        V: Visitor<'de>,
281    {
282        match &self.0 {
283            Inner::String(v) => match STANDARD.decode(v) {
284                Ok(buf) => visitor.visit_byte_buf(buf),
285                Err(_) => self.deserialize_any(visitor),
286            },
287            _ => self.deserialize_any(visitor),
288        }
289    }
290
291    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
292    where
293        V: Visitor<'de>,
294    {
295        self.deserialize_bytes(visitor)
296    }
297
298    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
299    where
300        V: Visitor<'de>,
301    {
302        match self.0 {
303            Inner::Null => visitor.visit_none(),
304            _ => visitor.visit_some(self),
305        }
306    }
307
308    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
309    where
310        V: Visitor<'de>,
311    {
312        match self.0 {
313            Inner::Null => visitor.visit_seq(SeqDeserializer(Vec::new().into_iter())),
314            _ => self.deserialize_any(visitor),
315        }
316    }
317
318    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
319    where
320        V: Visitor<'de>,
321    {
322        match self.0 {
323            Inner::Null => visitor.visit_map(MapDeserializer {
324                it: BTreeMap::new().into_iter(),
325                value: None,
326            }),
327            _ => self.deserialize_any(visitor),
328        }
329    }
330
331    fn deserialize_enum<V>(
332        self,
333        _: &'static str,
334        _: &'static [&'static str],
335        visitor: V,
336    ) -> Result<V::Value, Self::Error>
337    where
338        V: Visitor<'de>,
339    {
340        let (variant, value) = match self.0 {
341            Inner::Map(value) => {
342                let mut iter = value.into_iter();
343                let (variant, value) = match iter.next() {
344                    Some(v) => v,
345                    None => {
346                        return Err(Error::invalid_value(
347                            Unexpected::Map,
348                            &"map with a single key",
349                        ))
350                    }
351                };
352                if iter.next().is_some() {
353                    return Err(Error::invalid_value(
354                        Unexpected::Map,
355                        &"map with a single key",
356                    ));
357                }
358                (variant, Some(value))
359            }
360            Inner::String(variant) => (Any(Inner::String(variant)), None),
361            _ => return self.deserialize_any(visitor),
362        };
363
364        visitor.visit_enum(EnumDeserializer { variant, value })
365    }
366
367    forward_to_deserialize_any! {
368        bool i8 i16 i32 i64 u8 u16 u32 u64 char str string unit unit_struct newtype_struct tuple tuple_struct
369        struct identifier ignored_any
370    }
371}
372
373struct SeqDeserializer(vec::IntoIter<Any>);
374
375impl<'de> SeqAccess<'de> for SeqDeserializer {
376    type Error = Error;
377
378    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
379    where
380        T: DeserializeSeed<'de>,
381    {
382        match self.0.next() {
383            Some(value) => seed.deserialize(value).map(Some),
384            None => Ok(None),
385        }
386    }
387
388    fn size_hint(&self) -> Option<usize> {
389        Some(self.0.len())
390    }
391}
392
393struct MapDeserializer {
394    it: btree_map::IntoIter<Any, Any>,
395    value: Option<Any>,
396}
397
398impl<'de> MapAccess<'de> for MapDeserializer {
399    type Error = Error;
400
401    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
402    where
403        K: DeserializeSeed<'de>,
404    {
405        let (key, value) = match self.it.next() {
406            Some((key, value)) => (key, value),
407            None => return Ok(None),
408        };
409
410        self.value = Some(value);
411        seed.deserialize(KeyDeserializer(key)).map(Some)
412    }
413
414    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
415    where
416        V: DeserializeSeed<'de>,
417    {
418        match self.value.take() {
419            Some(value) => seed.deserialize(value),
420            None => Err(Error::custom("value is missing")),
421        }
422    }
423
424    fn size_hint(&self) -> Option<usize> {
425        Some(self.it.len())
426    }
427}
428
429macro_rules! deserialize_parse {
430    ($method:ident => $visit:ident) => {
431        fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
432        where
433            V: Visitor<'de>,
434        {
435            if let Inner::String(s) = &(self.0).0 {
436                if let Ok(v) = s.parse() {
437                    return visitor.$visit(v);
438                }
439            }
440
441            self.0.$method(visitor)
442        }
443    };
444}
445
446macro_rules! deserialize_delegate {
447    ($method:ident) => {
448        fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
449        where
450            V: Visitor<'de>,
451        {
452            self.0.$method(visitor)
453        }
454    };
455}
456
457struct KeyDeserializer(Any);
458
459impl<'de> Deserializer<'de> for KeyDeserializer {
460    type Error = Error;
461
462    deserialize_delegate!(deserialize_any);
463
464    deserialize_parse!(deserialize_bool => visit_bool);
465    deserialize_parse!(deserialize_i8 => visit_i8);
466    deserialize_parse!(deserialize_i16 => visit_i16);
467    deserialize_parse!(deserialize_i32 => visit_i32);
468    deserialize_parse!(deserialize_i64 => visit_i64);
469    deserialize_parse!(deserialize_i128 => visit_i128);
470    deserialize_parse!(deserialize_u8 => visit_u8);
471    deserialize_parse!(deserialize_u16 => visit_u16);
472    deserialize_parse!(deserialize_u32 => visit_u32);
473    deserialize_parse!(deserialize_u64 => visit_u64);
474    deserialize_parse!(deserialize_u128 => visit_u128);
475    deserialize_parse!(deserialize_f32 => visit_f32);
476    deserialize_parse!(deserialize_f64 => visit_f64);
477
478    deserialize_delegate!(deserialize_char);
479    deserialize_delegate!(deserialize_str);
480    deserialize_delegate!(deserialize_string);
481    deserialize_delegate!(deserialize_bytes);
482    deserialize_delegate!(deserialize_byte_buf);
483
484    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
485    where
486        V: Visitor<'de>,
487    {
488        match &(self.0).0 {
489            Inner::Null => visitor.visit_none(),
490            _ => visitor.visit_some(self),
491        }
492    }
493
494    deserialize_delegate!(deserialize_unit);
495
496    fn deserialize_unit_struct<V>(
497        self,
498        name: &'static str,
499        visitor: V,
500    ) -> Result<V::Value, Self::Error>
501    where
502        V: Visitor<'de>,
503    {
504        self.0.deserialize_unit_struct(name, visitor)
505    }
506
507    fn deserialize_newtype_struct<V>(
508        self,
509        _: &'static str,
510        visitor: V,
511    ) -> Result<V::Value, Self::Error>
512    where
513        V: Visitor<'de>,
514    {
515        visitor.visit_newtype_struct(self)
516    }
517
518    deserialize_delegate!(deserialize_seq);
519
520    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
521    where
522        V: Visitor<'de>,
523    {
524        self.0.deserialize_tuple(len, visitor)
525    }
526
527    fn deserialize_tuple_struct<V>(
528        self,
529        name: &'static str,
530        len: usize,
531        visitor: V,
532    ) -> Result<V::Value, Self::Error>
533    where
534        V: Visitor<'de>,
535    {
536        self.0.deserialize_tuple_struct(name, len, visitor)
537    }
538
539    deserialize_delegate!(deserialize_map);
540
541    fn deserialize_struct<V>(
542        self,
543        name: &'static str,
544        fields: &'static [&'static str],
545        visitor: V,
546    ) -> Result<V::Value, Self::Error>
547    where
548        V: Visitor<'de>,
549    {
550        self.0.deserialize_struct(name, fields, visitor)
551    }
552
553    fn deserialize_enum<V>(
554        self,
555        _: &'static str,
556        _: &'static [&'static str],
557        visitor: V,
558    ) -> Result<V::Value, Self::Error>
559    where
560        V: Visitor<'de>,
561    {
562        visitor.visit_enum(self)
563    }
564
565    deserialize_delegate!(deserialize_identifier);
566    deserialize_delegate!(deserialize_ignored_any);
567}
568
569impl<'de> EnumAccess<'de> for KeyDeserializer {
570    type Error = Error;
571    type Variant = UnitVariantDeserializer;
572
573    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
574    where
575        V: DeserializeSeed<'de>,
576    {
577        let value = seed.deserialize(self)?;
578        Ok((value, UnitVariantDeserializer))
579    }
580}
581
582struct UnitVariantDeserializer;
583
584impl<'de> VariantAccess<'de> for UnitVariantDeserializer {
585    type Error = Error;
586
587    fn unit_variant(self) -> Result<(), Self::Error> {
588        Ok(())
589    }
590
591    fn newtype_variant_seed<T>(
592        self,
593        _: T,
594    ) -> Result<<T as DeserializeSeed<'de>>::Value, Self::Error>
595    where
596        T: DeserializeSeed<'de>,
597    {
598        Err(Error::invalid_value(
599            Unexpected::UnitVariant,
600            &"newtype variant",
601        ))
602    }
603
604    fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
605    where
606        V: Visitor<'de>,
607    {
608        Err(Error::invalid_value(
609            Unexpected::UnitVariant,
610            &"tuple variant",
611        ))
612    }
613
614    fn struct_variant<V>(self, _: &'static [&'static str], _: V) -> Result<V::Value, Self::Error>
615    where
616        V: Visitor<'de>,
617    {
618        Err(Error::invalid_value(
619            Unexpected::UnitVariant,
620            &"struct variant",
621        ))
622    }
623}
624
625struct EnumDeserializer {
626    variant: Any,
627    value: Option<Any>,
628}
629
630impl<'de> EnumAccess<'de> for EnumDeserializer {
631    type Error = Error;
632    type Variant = VariantDeserializer;
633
634    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
635    where
636        V: DeserializeSeed<'de>,
637    {
638        let variant = seed.deserialize(self.variant)?;
639        Ok((variant, VariantDeserializer(self.value)))
640    }
641}
642
643struct VariantDeserializer(Option<Any>);
644
645impl<'de> VariantAccess<'de> for VariantDeserializer {
646    type Error = Error;
647
648    fn unit_variant(self) -> Result<(), Self::Error> {
649        match self.0 {
650            Some(value) => Deserialize::deserialize(value),
651            None => Ok(()),
652        }
653    }
654
655    fn newtype_variant_seed<T>(
656        self,
657        seed: T,
658    ) -> Result<<T as DeserializeSeed<'de>>::Value, Self::Error>
659    where
660        T: DeserializeSeed<'de>,
661    {
662        match self.0 {
663            Some(value) => seed.deserialize(value),
664            None => Err(Error::invalid_value(
665                Unexpected::UnitVariant,
666                &"newtype variant",
667            )),
668        }
669    }
670
671    fn tuple_variant<V>(
672        self,
673        _: usize,
674        visitor: V,
675    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
676    where
677        V: Visitor<'de>,
678    {
679        match self.0 {
680            Some(Any(Inner::Seq(value))) => visitor.visit_seq(SeqDeserializer(value.into_iter())),
681            Some(v) => Err(Error::invalid_value(v.unexpected(), &"tuple variant")),
682            None => Err(Error::invalid_value(
683                Unexpected::UnitVariant,
684                &"tuple variant",
685            )),
686        }
687    }
688
689    fn struct_variant<V>(
690        self,
691        _: &'static [&'static str],
692        visitor: V,
693    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
694    where
695        V: Visitor<'de>,
696    {
697        match self.0 {
698            Some(Any(Inner::Map(value))) => visitor.visit_map(MapDeserializer {
699                it: value.into_iter(),
700                value: None,
701            }),
702            Some(v) => Err(Error::invalid_value(v.unexpected(), &"struct variant")),
703            None => Err(Error::invalid_value(
704                Unexpected::UnitVariant,
705                &"struct variant",
706            )),
707        }
708    }
709}
conjure_object/any/de.rs

conjure_object/any/
de.rs
