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_enum<V>(
309        self,
310        _: &'static str,
311        _: &'static [&'static str],
312        visitor: V,
313    ) -> Result<V::Value, Self::Error>
314    where
315        V: Visitor<'de>,
316    {
317        let (variant, value) = match self.0 {
318            Inner::Map(value) => {
319                let mut iter = value.into_iter();
320                let (variant, value) = match iter.next() {
321                    Some(v) => v,
322                    None => {
323                        return Err(Error::invalid_value(
324                            Unexpected::Map,
325                            &"map with a single key",
326                        ))
327                    }
328                };
329                if iter.next().is_some() {
330                    return Err(Error::invalid_value(
331                        Unexpected::Map,
332                        &"map with a single key",
333                    ));
334                }
335                (variant, Some(value))
336            }
337            Inner::String(variant) => (Any(Inner::String(variant)), None),
338            _ => return self.deserialize_any(visitor),
339        };
340
341        visitor.visit_enum(EnumDeserializer { variant, value })
342    }
343
344    forward_to_deserialize_any! {
345        bool i8 i16 i32 i64 u8 u16 u32 u64 char str string unit unit_struct newtype_struct seq tuple tuple_struct map
346        struct identifier ignored_any
347    }
348}
349
350struct SeqDeserializer(vec::IntoIter<Any>);
351
352impl<'de> SeqAccess<'de> for SeqDeserializer {
353    type Error = Error;
354
355    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
356    where
357        T: DeserializeSeed<'de>,
358    {
359        match self.0.next() {
360            Some(value) => seed.deserialize(value).map(Some),
361            None => Ok(None),
362        }
363    }
364
365    fn size_hint(&self) -> Option<usize> {
366        Some(self.0.len())
367    }
368}
369
370struct MapDeserializer {
371    it: btree_map::IntoIter<Any, Any>,
372    value: Option<Any>,
373}
374
375impl<'de> MapAccess<'de> for MapDeserializer {
376    type Error = Error;
377
378    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
379    where
380        K: DeserializeSeed<'de>,
381    {
382        let (key, value) = match self.it.next() {
383            Some((key, value)) => (key, value),
384            None => return Ok(None),
385        };
386
387        self.value = Some(value);
388        seed.deserialize(KeyDeserializer(key)).map(Some)
389    }
390
391    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
392    where
393        V: DeserializeSeed<'de>,
394    {
395        match self.value.take() {
396            Some(value) => seed.deserialize(value),
397            None => Err(Error::custom("value is missing")),
398        }
399    }
400
401    fn size_hint(&self) -> Option<usize> {
402        Some(self.it.len())
403    }
404}
405
406macro_rules! deserialize_parse {
407    ($method:ident => $visit:ident) => {
408        fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
409        where
410            V: Visitor<'de>,
411        {
412            if let Inner::String(s) = &(self.0).0 {
413                if let Ok(v) = s.parse() {
414                    return visitor.$visit(v);
415                }
416            }
417
418            self.0.$method(visitor)
419        }
420    };
421}
422
423macro_rules! deserialize_delegate {
424    ($method:ident) => {
425        fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
426        where
427            V: Visitor<'de>,
428        {
429            self.0.$method(visitor)
430        }
431    };
432}
433
434struct KeyDeserializer(Any);
435
436impl<'de> Deserializer<'de> for KeyDeserializer {
437    type Error = Error;
438
439    deserialize_delegate!(deserialize_any);
440
441    deserialize_parse!(deserialize_bool => visit_bool);
442    deserialize_parse!(deserialize_i8 => visit_i8);
443    deserialize_parse!(deserialize_i16 => visit_i16);
444    deserialize_parse!(deserialize_i32 => visit_i32);
445    deserialize_parse!(deserialize_i64 => visit_i64);
446    deserialize_parse!(deserialize_i128 => visit_i128);
447    deserialize_parse!(deserialize_u8 => visit_u8);
448    deserialize_parse!(deserialize_u16 => visit_u16);
449    deserialize_parse!(deserialize_u32 => visit_u32);
450    deserialize_parse!(deserialize_u64 => visit_u64);
451    deserialize_parse!(deserialize_u128 => visit_u128);
452    deserialize_parse!(deserialize_f32 => visit_f32);
453    deserialize_parse!(deserialize_f64 => visit_f64);
454
455    deserialize_delegate!(deserialize_char);
456    deserialize_delegate!(deserialize_str);
457    deserialize_delegate!(deserialize_string);
458    deserialize_delegate!(deserialize_bytes);
459    deserialize_delegate!(deserialize_byte_buf);
460
461    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
462    where
463        V: Visitor<'de>,
464    {
465        match &(self.0).0 {
466            Inner::Null => visitor.visit_none(),
467            _ => visitor.visit_some(self),
468        }
469    }
470
471    deserialize_delegate!(deserialize_unit);
472
473    fn deserialize_unit_struct<V>(
474        self,
475        name: &'static str,
476        visitor: V,
477    ) -> Result<V::Value, Self::Error>
478    where
479        V: Visitor<'de>,
480    {
481        self.0.deserialize_unit_struct(name, visitor)
482    }
483
484    fn deserialize_newtype_struct<V>(
485        self,
486        _: &'static str,
487        visitor: V,
488    ) -> Result<V::Value, Self::Error>
489    where
490        V: Visitor<'de>,
491    {
492        visitor.visit_newtype_struct(self)
493    }
494
495    deserialize_delegate!(deserialize_seq);
496
497    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
498    where
499        V: Visitor<'de>,
500    {
501        self.0.deserialize_tuple(len, visitor)
502    }
503
504    fn deserialize_tuple_struct<V>(
505        self,
506        name: &'static str,
507        len: usize,
508        visitor: V,
509    ) -> Result<V::Value, Self::Error>
510    where
511        V: Visitor<'de>,
512    {
513        self.0.deserialize_tuple_struct(name, len, visitor)
514    }
515
516    deserialize_delegate!(deserialize_map);
517
518    fn deserialize_struct<V>(
519        self,
520        name: &'static str,
521        fields: &'static [&'static str],
522        visitor: V,
523    ) -> Result<V::Value, Self::Error>
524    where
525        V: Visitor<'de>,
526    {
527        self.0.deserialize_struct(name, fields, visitor)
528    }
529
530    fn deserialize_enum<V>(
531        self,
532        _: &'static str,
533        _: &'static [&'static str],
534        visitor: V,
535    ) -> Result<V::Value, Self::Error>
536    where
537        V: Visitor<'de>,
538    {
539        visitor.visit_enum(self)
540    }
541
542    deserialize_delegate!(deserialize_identifier);
543    deserialize_delegate!(deserialize_ignored_any);
544}
545
546impl<'de> EnumAccess<'de> for KeyDeserializer {
547    type Error = Error;
548    type Variant = UnitVariantDeserializer;
549
550    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
551    where
552        V: DeserializeSeed<'de>,
553    {
554        let value = seed.deserialize(self)?;
555        Ok((value, UnitVariantDeserializer))
556    }
557}
558
559struct UnitVariantDeserializer;
560
561impl<'de> VariantAccess<'de> for UnitVariantDeserializer {
562    type Error = Error;
563
564    fn unit_variant(self) -> Result<(), Self::Error> {
565        Ok(())
566    }
567
568    fn newtype_variant_seed<T>(
569        self,
570        _: T,
571    ) -> Result<<T as DeserializeSeed<'de>>::Value, Self::Error>
572    where
573        T: DeserializeSeed<'de>,
574    {
575        Err(Error::invalid_value(
576            Unexpected::UnitVariant,
577            &"newtype variant",
578        ))
579    }
580
581    fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
582    where
583        V: Visitor<'de>,
584    {
585        Err(Error::invalid_value(
586            Unexpected::UnitVariant,
587            &"tuple variant",
588        ))
589    }
590
591    fn struct_variant<V>(self, _: &'static [&'static str], _: V) -> Result<V::Value, Self::Error>
592    where
593        V: Visitor<'de>,
594    {
595        Err(Error::invalid_value(
596            Unexpected::UnitVariant,
597            &"struct variant",
598        ))
599    }
600}
601
602struct EnumDeserializer {
603    variant: Any,
604    value: Option<Any>,
605}
606
607impl<'de> EnumAccess<'de> for EnumDeserializer {
608    type Error = Error;
609    type Variant = VariantDeserializer;
610
611    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
612    where
613        V: DeserializeSeed<'de>,
614    {
615        let variant = seed.deserialize(self.variant)?;
616        Ok((variant, VariantDeserializer(self.value)))
617    }
618}
619
620struct VariantDeserializer(Option<Any>);
621
622impl<'de> VariantAccess<'de> for VariantDeserializer {
623    type Error = Error;
624
625    fn unit_variant(self) -> Result<(), Self::Error> {
626        match self.0 {
627            Some(value) => Deserialize::deserialize(value),
628            None => Ok(()),
629        }
630    }
631
632    fn newtype_variant_seed<T>(
633        self,
634        seed: T,
635    ) -> Result<<T as DeserializeSeed<'de>>::Value, Self::Error>
636    where
637        T: DeserializeSeed<'de>,
638    {
639        match self.0 {
640            Some(value) => seed.deserialize(value),
641            None => Err(Error::invalid_value(
642                Unexpected::UnitVariant,
643                &"newtype variant",
644            )),
645        }
646    }
647
648    fn tuple_variant<V>(
649        self,
650        _: usize,
651        visitor: V,
652    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
653    where
654        V: Visitor<'de>,
655    {
656        match self.0 {
657            Some(Any(Inner::Seq(value))) => visitor.visit_seq(SeqDeserializer(value.into_iter())),
658            Some(v) => Err(Error::invalid_value(v.unexpected(), &"tuple variant")),
659            None => Err(Error::invalid_value(
660                Unexpected::UnitVariant,
661                &"tuple variant",
662            )),
663        }
664    }
665
666    fn struct_variant<V>(
667        self,
668        _: &'static [&'static str],
669        visitor: V,
670    ) -> Result<<V as Visitor<'de>>::Value, Self::Error>
671    where
672        V: Visitor<'de>,
673    {
674        match self.0 {
675            Some(Any(Inner::Map(value))) => visitor.visit_map(MapDeserializer {
676                it: value.into_iter(),
677                value: None,
678            }),
679            Some(v) => Err(Error::invalid_value(v.unexpected(), &"struct variant")),
680            None => Err(Error::invalid_value(
681                Unexpected::UnitVariant,
682                &"struct variant",
683            )),
684        }
685    }
686}
conjure_object/any/de.rs

conjure_object/any/
de.rs
