config/
de.rs

1use std::collections::VecDeque;
2use std::convert::TryInto;
3use std::iter::Enumerate;
4
5use serde::de;
6
7use crate::config::Config;
8use crate::error::{ConfigError, Result, Unexpected};
9use crate::map::Map;
10use crate::value::{Table, Value, ValueKind};
11
12macro_rules! try_convert_number {
13    (signed, $self:expr, $size:literal) => {{
14        let num = $self.into_int()?;
15        num.try_into().map_err(|_| {
16            ConfigError::invalid_type(
17                None,
18                Unexpected::I64(num),
19                concat!("an signed ", $size, " bit integer"),
20            )
21        })?
22    }};
23
24    (unsigned, $self:expr, $size:literal) => {{
25        let num = $self.into_uint()?;
26        num.try_into().map_err(|_| {
27            ConfigError::invalid_type(
28                None,
29                Unexpected::U64(num),
30                concat!("an unsigned ", $size, " bit integer"),
31            )
32        })?
33    }};
34}
35
36impl<'de> de::Deserializer<'de> for Value {
37    type Error = ConfigError;
38
39    #[inline]
40    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
41    where
42        V: de::Visitor<'de>,
43    {
44        // Deserialize based on the underlying type
45        match self.kind {
46            ValueKind::Nil => visitor.visit_unit(),
47            ValueKind::I64(i) => visitor.visit_i64(i),
48            ValueKind::I128(i) => visitor.visit_i128(i),
49            ValueKind::U64(i) => visitor.visit_u64(i),
50            ValueKind::U128(i) => visitor.visit_u128(i),
51            ValueKind::Boolean(b) => visitor.visit_bool(b),
52            ValueKind::Float(f) => visitor.visit_f64(f),
53            ValueKind::String(s) => visitor.visit_string(s),
54            ValueKind::Array(values) => visitor.visit_seq(SeqAccess::new(values)),
55            ValueKind::Table(map) => visitor.visit_map(MapAccess::new(map)),
56        }
57    }
58
59    #[inline]
60    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
61        visitor.visit_bool(self.into_bool()?)
62    }
63
64    #[inline]
65    fn deserialize_i8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
66        let num = try_convert_number!(signed, self, "8");
67        visitor.visit_i8(num)
68    }
69
70    #[inline]
71    fn deserialize_i16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
72        let num = try_convert_number!(signed, self, "16");
73        visitor.visit_i16(num)
74    }
75
76    #[inline]
77    fn deserialize_i32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
78        let num = try_convert_number!(signed, self, "32");
79        visitor.visit_i32(num)
80    }
81
82    #[inline]
83    fn deserialize_i64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
84        let num = try_convert_number!(signed, self, "64");
85        visitor.visit_i64(num)
86    }
87
88    #[inline]
89    fn deserialize_u8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
90        let num = try_convert_number!(unsigned, self, "8");
91        visitor.visit_u8(num)
92    }
93
94    #[inline]
95    fn deserialize_u16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
96        let num = try_convert_number!(unsigned, self, "16");
97        visitor.visit_u16(num)
98    }
99
100    #[inline]
101    fn deserialize_u32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
102        let num = try_convert_number!(unsigned, self, "32");
103        visitor.visit_u32(num)
104    }
105
106    #[inline]
107    fn deserialize_u64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
108        let num = try_convert_number!(unsigned, self, "u64");
109        visitor.visit_u64(num)
110    }
111
112    #[inline]
113    fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
114        visitor.visit_f32(self.into_float()? as f32)
115    }
116
117    #[inline]
118    fn deserialize_f64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
119        visitor.visit_f64(self.into_float()?)
120    }
121
122    #[inline]
123    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
124        visitor.visit_string(self.into_string()?)
125    }
126
127    #[inline]
128    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
129        visitor.visit_string(self.into_string()?)
130    }
131
132    #[inline]
133    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
134    where
135        V: de::Visitor<'de>,
136    {
137        // Match an explicit nil as None and everything else as Some
138        match self.kind {
139            ValueKind::Nil => visitor.visit_none(),
140            _ => visitor.visit_some(self),
141        }
142    }
143
144    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
145    where
146        V: de::Visitor<'de>,
147    {
148        visitor.visit_newtype_struct(self)
149    }
150
151    fn deserialize_enum<V>(
152        self,
153        name: &'static str,
154        variants: &'static [&'static str],
155        visitor: V,
156    ) -> Result<V::Value>
157    where
158        V: de::Visitor<'de>,
159    {
160        visitor.visit_enum(EnumAccess {
161            value: self,
162            name,
163            variants,
164        })
165    }
166
167    serde::forward_to_deserialize_any! {
168        char seq
169        bytes byte_buf map struct unit
170        identifier ignored_any unit_struct tuple_struct tuple
171    }
172}
173
174struct StrDeserializer<'a>(&'a str);
175
176impl<'de> de::Deserializer<'de> for StrDeserializer<'_> {
177    type Error = ConfigError;
178
179    #[inline]
180    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
181        visitor.visit_str(self.0)
182    }
183
184    serde::forward_to_deserialize_any! {
185        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
186        bytes byte_buf map struct unit enum newtype_struct
187        identifier ignored_any unit_struct tuple_struct tuple option
188    }
189}
190
191struct SeqAccess {
192    elements: Enumerate<::std::vec::IntoIter<Value>>,
193}
194
195impl SeqAccess {
196    fn new(elements: Vec<Value>) -> Self {
197        Self {
198            elements: elements.into_iter().enumerate(),
199        }
200    }
201}
202
203impl<'de> de::SeqAccess<'de> for SeqAccess {
204    type Error = ConfigError;
205
206    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
207    where
208        T: de::DeserializeSeed<'de>,
209    {
210        match self.elements.next() {
211            Some((idx, value)) => seed
212                .deserialize(value)
213                .map(Some)
214                .map_err(|e| e.prepend_index(idx)),
215            None => Ok(None),
216        }
217    }
218
219    fn size_hint(&self) -> Option<usize> {
220        match self.elements.size_hint() {
221            (lower, Some(upper)) if lower == upper => Some(upper),
222            _ => None,
223        }
224    }
225}
226
227struct MapAccess {
228    elements: VecDeque<(String, Value)>,
229}
230
231impl MapAccess {
232    fn new(table: Map<String, Value>) -> Self {
233        Self {
234            elements: table.into_iter().collect(),
235        }
236    }
237}
238
239impl<'de> de::MapAccess<'de> for MapAccess {
240    type Error = ConfigError;
241
242    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
243    where
244        K: de::DeserializeSeed<'de>,
245    {
246        if let Some((ref key_s, _)) = self.elements.front() {
247            let key_de = Value::new(None, key_s as &str);
248            let key = de::DeserializeSeed::deserialize(seed, key_de)?;
249
250            Ok(Some(key))
251        } else {
252            Ok(None)
253        }
254    }
255
256    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
257    where
258        V: de::DeserializeSeed<'de>,
259    {
260        let (key, value) = self.elements.pop_front().unwrap();
261        de::DeserializeSeed::deserialize(seed, value).map_err(|e| e.prepend_key(&key))
262    }
263}
264
265struct EnumAccess {
266    value: Value,
267    name: &'static str,
268    variants: &'static [&'static str],
269}
270
271impl EnumAccess {
272    fn variant_deserializer(&self, name: &str) -> Result<StrDeserializer<'_>> {
273        self.variants
274            .iter()
275            .find(|&&s| s == name)
276            .map(|&s| StrDeserializer(s))
277            .ok_or_else(|| self.no_constructor_error(name))
278    }
279
280    fn table_deserializer(&self, table: &Table) -> Result<StrDeserializer<'_>> {
281        if table.len() == 1 {
282            self.variant_deserializer(table.iter().next().unwrap().0)
283        } else {
284            Err(self.structural_error())
285        }
286    }
287
288    fn no_constructor_error(&self, supposed_variant: &str) -> ConfigError {
289        ConfigError::Message(format!(
290            "enum {} does not have variant constructor {}",
291            self.name, supposed_variant
292        ))
293    }
294
295    fn structural_error(&self) -> ConfigError {
296        ConfigError::Message(format!(
297            "value of enum {} should be represented by either string or table with exactly one key",
298            self.name
299        ))
300    }
301}
302
303impl<'de> de::EnumAccess<'de> for EnumAccess {
304    type Error = ConfigError;
305    type Variant = Self;
306
307    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
308    where
309        V: de::DeserializeSeed<'de>,
310    {
311        let value = {
312            let deserializer = match self.value.kind {
313                ValueKind::String(ref s) => self.variant_deserializer(s),
314                ValueKind::Table(ref t) => self.table_deserializer(t),
315                _ => Err(self.structural_error()),
316            }?;
317            seed.deserialize(deserializer)?
318        };
319
320        Ok((value, self))
321    }
322}
323
324impl<'de> de::VariantAccess<'de> for EnumAccess {
325    type Error = ConfigError;
326
327    fn unit_variant(self) -> Result<()> {
328        Ok(())
329    }
330
331    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
332    where
333        T: de::DeserializeSeed<'de>,
334    {
335        match self.value.kind {
336            ValueKind::Table(t) => seed.deserialize(t.into_iter().next().unwrap().1),
337            _ => unreachable!(),
338        }
339    }
340
341    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
342    where
343        V: de::Visitor<'de>,
344    {
345        match self.value.kind {
346            ValueKind::Table(t) => {
347                de::Deserializer::deserialize_seq(t.into_iter().next().unwrap().1, visitor)
348            }
349            _ => unreachable!(),
350        }
351    }
352
353    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
354    where
355        V: de::Visitor<'de>,
356    {
357        match self.value.kind {
358            ValueKind::Table(t) => {
359                de::Deserializer::deserialize_map(t.into_iter().next().unwrap().1, visitor)
360            }
361            _ => unreachable!(),
362        }
363    }
364}
365
366/// Define `$method`s, `deserialize_foo`, by forwarding to `Value`
367///
368/// `($arg: $argtype, ...)`, if supplied, are the formal arguments
369macro_rules! config_deserialize_via_value { { $(
370    $method:ident $( ( $( $arg:ident: $argtype:ty ),* ) )? ;
371)* } => { $(
372    #[inline]
373        fn $method<V: de::Visitor<'de>>(
374            self,
375      $( $( $arg: $argtype, )* )?
376            visitor: V,
377        ) -> Result<V::Value> {
378        self.cache.$method( $( $( $arg, )* )? visitor)
379    }
380)* } }
381
382impl<'de> de::Deserializer<'de> for Config {
383    type Error = ConfigError;
384
385    config_deserialize_via_value! {
386        deserialize_any;
387        deserialize_bool;
388        deserialize_i8;
389        deserialize_i16;
390        deserialize_i32;
391        deserialize_i64;
392        deserialize_u8;
393        deserialize_u16;
394        deserialize_u32;
395        deserialize_u64;
396        deserialize_f32;
397        deserialize_f64;
398        deserialize_str;
399        deserialize_string;
400        deserialize_option;
401
402        deserialize_char;
403        deserialize_seq;
404        deserialize_bytes;
405        deserialize_byte_buf;
406        deserialize_map;
407        deserialize_unit;
408        deserialize_identifier;
409        deserialize_ignored_any;
410
411        deserialize_enum(name: &'static str, variants: &'static [&'static str]);
412        deserialize_unit_struct(name: &'static str);
413        deserialize_newtype_struct(name: &'static str);
414        deserialize_tuple(n: usize);
415        deserialize_tuple_struct(name: &'static str, n: usize);
416        deserialize_struct(name: &'static str, fields: &'static [&'static str]);
417    }
418}
config/de.rs

config/
de.rs
