serde_plain/
de.rs

Help
1use serde::de::{self, Deserialize, IntoDeserializer, Visitor};
2
3use crate::error::Error;
4
5/// A simple deserializer that works with plain strings.
6pub struct Deserializer<'de> {
7    input: &'de str,
8}
9
10impl<'de> Deserializer<'de> {
11    pub fn new(input: &'de str) -> Self {
12        Deserializer { input }
13    }
14}
15
16/// Deserialize an instance of type `T` from a string of plain text.
17///
18/// This deserializes the string into an object with the `Deserializer`
19/// and returns it.  This requires that the type is a simple one
20/// (integer, string etc.).
21pub fn from_str<'a, T>(s: &'a str) -> Result<T, Error>
22where
23    T: Deserialize<'a>,
24{
25    T::deserialize(Deserializer::new(s))
26}
27
28macro_rules! forward_to_deserialize_from_str {
29    ($func:ident, $visit_func:ident, $tymsg:expr) => {
30        fn $func<V>(self, visitor: V) -> Result<V::Value, Error>
31        where
32            V: Visitor<'de>,
33        {
34            visitor.$visit_func(
35                self.input
36                    .parse()
37                    .map_err(|e| Error::Parse($tymsg, format!("{}", e)))?,
38            )
39        }
40    };
41}
42
43impl<'de> de::Deserializer<'de> for Deserializer<'de> {
44    type Error = Error;
45
46    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
47    where
48        V: Visitor<'de>,
49    {
50        self.deserialize_str(visitor)
51    }
52
53    forward_to_deserialize_from_str!(deserialize_bool, visit_bool, "boolean");
54    forward_to_deserialize_from_str!(deserialize_i8, visit_i8, "i8");
55    forward_to_deserialize_from_str!(deserialize_i16, visit_i16, "i16");
56    forward_to_deserialize_from_str!(deserialize_i32, visit_i32, "i32");
57    forward_to_deserialize_from_str!(deserialize_i64, visit_i64, "i64");
58    forward_to_deserialize_from_str!(deserialize_u8, visit_u8, "u8");
59    forward_to_deserialize_from_str!(deserialize_u16, visit_u16, "u16");
60    forward_to_deserialize_from_str!(deserialize_u32, visit_u32, "u32");
61    forward_to_deserialize_from_str!(deserialize_u64, visit_u64, "u64");
62    forward_to_deserialize_from_str!(deserialize_f32, visit_f32, "f32");
63    forward_to_deserialize_from_str!(deserialize_f64, visit_f64, "f64");
64    forward_to_deserialize_from_str!(deserialize_char, visit_char, "char");
65
66    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
67    where
68        V: Visitor<'de>,
69    {
70        visitor.visit_borrowed_str(self.input)
71    }
72
73    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
74    where
75        V: Visitor<'de>,
76    {
77        self.deserialize_str(visitor)
78    }
79
80    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Error>
81    where
82        V: Visitor<'de>,
83    {
84        Err(Error::ImpossibleDeserialization("bytes"))
85    }
86
87    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Error>
88    where
89        V: Visitor<'de>,
90    {
91        Err(Error::ImpossibleDeserialization("bytes"))
92    }
93
94    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
95    where
96        V: Visitor<'de>,
97    {
98        if self.input.is_empty() {
99            visitor.visit_none()
100        } else {
101            visitor.visit_some(self)
102        }
103    }
104
105    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
106    where
107        V: Visitor<'de>,
108    {
109        if self.input.is_empty() {
110            visitor.visit_unit()
111        } else {
112            Err(Error::Message("expected empty string for unit".into()))
113        }
114    }
115
116    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
117    where
118        V: Visitor<'de>,
119    {
120        self.deserialize_unit(visitor)
121    }
122
123    fn deserialize_newtype_struct<V>(
124        self,
125        _name: &'static str,
126        visitor: V,
127    ) -> Result<V::Value, Error>
128    where
129        V: Visitor<'de>,
130    {
131        visitor.visit_newtype_struct(self)
132    }
133
134    fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value, Error>
135    where
136        V: Visitor<'de>,
137    {
138        Err(Error::ImpossibleDeserialization("seq"))
139    }
140
141    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
142    where
143        V: Visitor<'de>,
144    {
145        Err(Error::ImpossibleDeserialization("tuple"))
146    }
147
148    fn deserialize_tuple_struct<V>(
149        self,
150        _name: &'static str,
151        _len: usize,
152        _visitor: V,
153    ) -> Result<V::Value, Error>
154    where
155        V: Visitor<'de>,
156    {
157        Err(Error::ImpossibleDeserialization("tuple struct"))
158    }
159
160    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Error>
161    where
162        V: Visitor<'de>,
163    {
164        Err(Error::ImpossibleDeserialization("map"))
165    }
166
167    fn deserialize_struct<V>(
168        self,
169        _name: &'static str,
170        _fields: &'static [&'static str],
171        _visitor: V,
172    ) -> Result<V::Value, Error>
173    where
174        V: Visitor<'de>,
175    {
176        Err(Error::ImpossibleDeserialization("struct"))
177    }
178
179    fn deserialize_enum<V>(
180        self,
181        _name: &'static str,
182        _variants: &'static [&'static str],
183        visitor: V,
184    ) -> Result<V::Value, Error>
185    where
186        V: Visitor<'de>,
187    {
188        visitor.visit_enum(self.input.into_deserializer())
189    }
190
191    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
192    where
193        V: Visitor<'de>,
194    {
195        self.deserialize_str(visitor)
196    }
197
198    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
199    where
200        V: Visitor<'de>,
201    {
202        self.deserialize_any(visitor)
203    }
204}
serde_plain/de.rs

serde_plain/
de.rs
