1 use serde::de::value::{Error, MapDeserializer, SeqDeserializer};
2 use serde::de::{
3 DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
4 };
5 use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
6
7 #[derive(PartialEq, Debug, Deserialize)]
8 enum Target {
9 Unit,
10 Newtype(i32),
11 Tuple(i32, i32),
12 Struct { a: i32 },
13 }
14
15 struct Enum(&'static str);
16
17 impl<'de> Deserializer<'de> for Enum {
18 type Error = Error;
19
deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,20 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
21 where
22 V: Visitor<'de>,
23 {
24 visitor.visit_enum(self)
25 }
26
27 forward_to_deserialize_any! {
28 bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
29 bytes byte_buf option unit unit_struct newtype_struct seq tuple
30 tuple_struct map struct enum identifier ignored_any
31 }
32 }
33
34 impl<'de> EnumAccess<'de> for Enum {
35 type Error = Error;
36 type Variant = Self;
37
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> where V: DeserializeSeed<'de>,38 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
39 where
40 V: DeserializeSeed<'de>,
41 {
42 let v = seed.deserialize(self.0.into_deserializer())?;
43 Ok((v, self))
44 }
45 }
46
47 impl<'de> VariantAccess<'de> for Enum {
48 type Error = Error;
49
unit_variant(self) -> Result<(), Self::Error>50 fn unit_variant(self) -> Result<(), Self::Error> {
51 Ok(())
52 }
53
newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error> where T: DeserializeSeed<'de>,54 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
55 where
56 T: DeserializeSeed<'de>,
57 {
58 seed.deserialize(10i32.into_deserializer())
59 }
60
tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor<'de>,61 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
62 where
63 V: Visitor<'de>,
64 {
65 let seq = SeqDeserializer::new(vec![1i32, 2].into_iter());
66 visitor.visit_seq(seq)
67 }
68
struct_variant<V>( self, _fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>,69 fn struct_variant<V>(
70 self,
71 _fields: &'static [&'static str],
72 visitor: V,
73 ) -> Result<V::Value, Self::Error>
74 where
75 V: Visitor<'de>,
76 {
77 let map = MapDeserializer::new(vec![("a", 10i32)].into_iter());
78 visitor.visit_map(map)
79 }
80 }
81
82 #[test]
test_deserialize_enum()83 fn test_deserialize_enum() {
84 // First just make sure the Deserializer impl works
85 assert_eq!(Target::Unit, Target::deserialize(Enum("Unit")).unwrap());
86 assert_eq!(
87 Target::Newtype(10),
88 Target::deserialize(Enum("Newtype")).unwrap()
89 );
90 assert_eq!(
91 Target::Tuple(1, 2),
92 Target::deserialize(Enum("Tuple")).unwrap()
93 );
94 assert_eq!(
95 Target::Struct { a: 10 },
96 Target::deserialize(Enum("Struct")).unwrap()
97 );
98
99 // Now try IgnoredAny
100 IgnoredAny::deserialize(Enum("Unit")).unwrap();
101 IgnoredAny::deserialize(Enum("Newtype")).unwrap();
102 IgnoredAny::deserialize(Enum("Tuple")).unwrap();
103 IgnoredAny::deserialize(Enum("Struct")).unwrap();
104 }
105