serde_vars/
de.rs

1use std::{borrow::Cow, marker::PhantomData};
2
3use serde::de::{self, Deserialize, Visitor};
4
5use crate::content::Content;
6use crate::source::Source;
7
8/// A deserializer which substitutes strings with values provided from a [`Source`].
9///
10/// It allows strings in place of arbitrary primitive types to be resolved through the
11/// provided [`Source`].
12///
13///
14/// # Examples:
15///
16/// ```
17/// # #[derive(PartialEq)]
18/// #[derive(Debug, serde::Deserialize)]
19/// struct Config {
20///     redis: Redis,
21/// }
22///
23/// # #[derive(PartialEq)]
24/// #[derive(Debug, serde::Deserialize)]
25/// struct Redis {
26///     host: std::net::Ipv4Addr,
27///     port: u16,
28///     timeout: u32,
29/// }
30///
31/// fn read_config() -> String {
32///     return r#"{
33///         "redis": {
34///             "host": "${REDIS_HOST}",
35///             "port": "${REDIS_PORT}",
36///             "timeout": 5
37///         }
38///     }"#.to_owned();
39/// }
40///
41/// let mut source = serde_vars::EnvSource::default();
42/// # unsafe { std::env::set_var("REDIS_HOST", "127.0.0.1"); }
43/// # unsafe { std::env::set_var("REDIS_PORT", "9977"); }
44///
45/// let config: Config = {
46///     let config = read_config();
47///
48///     let mut de = serde_json::Deserializer::from_str(&config);
49///     serde_vars::deserialize(&mut de, &mut source).unwrap()
50/// };
51///
52/// assert_eq!(config, Config {
53///     redis: Redis {
54///         host: [127, 0, 0, 1].into(),
55///         port: 9977,
56///         timeout: 5
57///     }
58/// });
59/// ```
60pub struct Deserializer<'a, D, S> {
61    de: D,
62    source: &'a mut S,
63}
64
65impl<'a, D, S> Deserializer<'a, D, S> {
66    pub fn new(de: D, source: &'a mut S) -> Self {
67        Self { de, source }
68    }
69}
70
71impl<'de, D, S> de::Deserializer<'de> for Deserializer<'_, D, S>
72where
73    D: de::Deserializer<'de>,
74    S: Source,
75{
76    type Error = D::Error;
77
78    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
79    where
80        V: de::Visitor<'de>,
81    {
82        self.de.deserialize_any(Wrap::new(visitor, self.source))
83    }
84
85    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
86    where
87        V: de::Visitor<'de>,
88    {
89        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_bool(visitor)
90    }
91
92    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
93    where
94        V: de::Visitor<'de>,
95    {
96        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_i8(visitor)
97    }
98
99    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
100    where
101        V: de::Visitor<'de>,
102    {
103        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_i16(visitor)
104    }
105
106    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
107    where
108        V: de::Visitor<'de>,
109    {
110        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_i32(visitor)
111    }
112
113    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
114    where
115        V: de::Visitor<'de>,
116    {
117        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_i64(visitor)
118    }
119
120    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
121    where
122        V: de::Visitor<'de>,
123    {
124        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_u8(visitor)
125    }
126
127    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
128    where
129        V: de::Visitor<'de>,
130    {
131        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_u16(visitor)
132    }
133
134    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
135    where
136        V: de::Visitor<'de>,
137    {
138        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_u32(visitor)
139    }
140
141    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
142    where
143        V: de::Visitor<'de>,
144    {
145        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_u64(visitor)
146    }
147
148    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
149    where
150        V: de::Visitor<'de>,
151    {
152        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_f32(visitor)
153    }
154
155    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
156    where
157        V: de::Visitor<'de>,
158    {
159        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_f64(visitor)
160    }
161
162    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
163    where
164        V: de::Visitor<'de>,
165    {
166        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_char(visitor)
167    }
168
169    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
170    where
171        V: de::Visitor<'de>,
172    {
173        // TODO: support zero copy/borrowed strings here.
174        // To support this we need a custom visitor which can differentiate between
175        // a borrowed `&'de str` and just a referenced `&str` as well as accept `String`.
176        self.deserialize_string(visitor)
177    }
178
179    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
180    where
181        V: de::Visitor<'de>,
182    {
183        // Directly deserialize into a `String` here, because we do not need support arbitrary
184        // types here (through any). Here we can always expect a string, no matter if the value
185        // contains a variable reference or not.
186        // This allows formats, like YAML, which can deserialize a value into multiple types,
187        // to yield a string when they otherwise would yield another type (e.g. u64).
188        let content = Content::String(Deserialize::deserialize(self.de)?);
189        ContentVarDeserializer::new(content, self.source).deserialize_string(visitor)
190    }
191
192    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
193    where
194        V: de::Visitor<'de>,
195    {
196        // TODO: support zero copy/borrowed bytes here.
197        // To support this we need a custom visitor which can differentiate between
198        // a borrowed `&'de str` and just a referenced `&str` as well as accept `String`.
199        self.deserialize_byte_buf(visitor)
200    }
201
202    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
203    where
204        V: de::Visitor<'de>,
205    {
206        // See `deserialize_string` why we deserialize into a byte buf directly here.
207        let content = Content::ByteBuf(crate::value::deserialize_byte_buf(self.de)?);
208        ContentVarDeserializer::new(content, self.source).deserialize_byte_buf(visitor)
209    }
210
211    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
212    where
213        V: de::Visitor<'de>,
214    {
215        self.de.deserialize_option(Wrap::new(visitor, self.source))
216    }
217
218    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
219    where
220        V: de::Visitor<'de>,
221    {
222        ContentVarDeserializer::from_de(self.de, self.source)?.deserialize_unit(visitor)
223    }
224
225    fn deserialize_unit_struct<V>(
226        self,
227        name: &'static str,
228        visitor: V,
229    ) -> Result<V::Value, Self::Error>
230    where
231        V: de::Visitor<'de>,
232    {
233        self.de
234            .deserialize_unit_struct(name, Wrap::new(visitor, self.source))
235    }
236
237    fn deserialize_newtype_struct<V>(
238        self,
239        name: &'static str,
240        visitor: V,
241    ) -> Result<V::Value, Self::Error>
242    where
243        V: de::Visitor<'de>,
244    {
245        self.de
246            .deserialize_newtype_struct(name, Wrap::new(visitor, self.source))
247    }
248
249    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
250    where
251        V: de::Visitor<'de>,
252    {
253        self.de.deserialize_seq(Wrap::new(visitor, self.source))
254    }
255
256    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
257    where
258        V: de::Visitor<'de>,
259    {
260        self.de
261            .deserialize_tuple(len, Wrap::new(visitor, self.source))
262    }
263
264    fn deserialize_tuple_struct<V>(
265        self,
266        name: &'static str,
267        len: usize,
268        visitor: V,
269    ) -> Result<V::Value, Self::Error>
270    where
271        V: de::Visitor<'de>,
272    {
273        self.de
274            .deserialize_tuple_struct(name, len, Wrap::new(visitor, self.source))
275    }
276
277    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
278    where
279        V: de::Visitor<'de>,
280    {
281        self.de.deserialize_map(Wrap::new(visitor, self.source))
282    }
283
284    fn deserialize_struct<V>(
285        self,
286        name: &'static str,
287        fields: &'static [&'static str],
288        visitor: V,
289    ) -> Result<V::Value, Self::Error>
290    where
291        V: de::Visitor<'de>,
292    {
293        self.de
294            .deserialize_struct(name, fields, Wrap::new(visitor, self.source))
295    }
296
297    fn deserialize_enum<V>(
298        self,
299        name: &'static str,
300        variants: &'static [&'static str],
301        visitor: V,
302    ) -> Result<V::Value, Self::Error>
303    where
304        V: de::Visitor<'de>,
305    {
306        self.de
307            .deserialize_enum(name, variants, Wrap::new(visitor, self.source))
308    }
309
310    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
311    where
312        V: de::Visitor<'de>,
313    {
314        self.de
315            .deserialize_identifier(Wrap::new(visitor, self.source))
316    }
317
318    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
319    where
320        V: de::Visitor<'de>,
321    {
322        self.de
323            .deserialize_ignored_any(Wrap::new(visitor, self.source))
324    }
325}
326
327struct Wrap<'a, T, S> {
328    delegate: T,
329    source: &'a mut S,
330}
331
332impl<'a, T, S> Wrap<'a, T, S> {
333    fn new(delegate: T, source: &'a mut S) -> Self {
334        Self { delegate, source }
335    }
336}
337
338/// This implementation is only called for non-primitive types, like
339/// struct, enum, option etc. in which case it forwards nested
340/// [`de::Deserializer`] calls to the original [`Deserializer`].
341///
342/// And it is also called as a dispatch for [`de::Deserializer::deserialize_any`],
343/// any primitive callback like, `visit_bool` can be expected to be called
344/// from a code path which invoked `deserialize_any`.
345/// When a string variant is invoked through such a code path, the visitor
346/// delegates it to [`Source::expand_any`].
347impl<'de, T, S> Visitor<'de> for Wrap<'_, T, S>
348where
349    T: Visitor<'de>,
350    S: Source,
351{
352    type Value = T::Value;
353
354    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
355        self.delegate.expecting(formatter)
356    }
357
358    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
359    where
360        E: de::Error,
361    {
362        self.delegate.visit_bool(v)
363    }
364
365    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
366    where
367        E: de::Error,
368    {
369        self.delegate.visit_i8(v)
370    }
371
372    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
373    where
374        E: de::Error,
375    {
376        self.delegate.visit_i16(v)
377    }
378
379    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
380    where
381        E: de::Error,
382    {
383        self.delegate.visit_i32(v)
384    }
385
386    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
387    where
388        E: de::Error,
389    {
390        self.delegate.visit_i64(v)
391    }
392
393    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
394    where
395        E: de::Error,
396    {
397        self.delegate.visit_i128(v)
398    }
399
400    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
401    where
402        E: de::Error,
403    {
404        self.delegate.visit_u8(v)
405    }
406
407    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
408    where
409        E: de::Error,
410    {
411        self.delegate.visit_u16(v)
412    }
413
414    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
415    where
416        E: de::Error,
417    {
418        self.delegate.visit_u32(v)
419    }
420
421    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
422    where
423        E: de::Error,
424    {
425        self.delegate.visit_u64(v)
426    }
427
428    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
429    where
430        E: de::Error,
431    {
432        self.delegate.visit_u128(v)
433    }
434
435    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
436    where
437        E: de::Error,
438    {
439        self.delegate.visit_f32(v)
440    }
441
442    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
443    where
444        E: de::Error,
445    {
446        self.delegate.visit_f64(v)
447    }
448
449    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
450    where
451        E: de::Error,
452    {
453        self.delegate.visit_char(v)
454    }
455
456    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
457    where
458        E: de::Error,
459    {
460        self.source
461            .expand_any(Cow::Borrowed(v))?
462            .visit(self.delegate)
463    }
464
465    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
466    where
467        E: de::Error,
468    {
469        self.source
470            .expand_any(Cow::Borrowed(v))?
471            .visit_borrowed(self.delegate)
472    }
473
474    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
475    where
476        E: de::Error,
477    {
478        self.source.expand_any(Cow::Owned(v))?.visit(self.delegate)
479    }
480
481    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
482    where
483        E: de::Error,
484    {
485        self.delegate.visit_bytes(v)
486    }
487
488    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
489    where
490        E: de::Error,
491    {
492        self.delegate.visit_borrowed_bytes(v)
493    }
494
495    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
496    where
497        E: de::Error,
498    {
499        self.delegate.visit_byte_buf(v)
500    }
501
502    fn visit_none<E>(self) -> Result<Self::Value, E>
503    where
504        E: de::Error,
505    {
506        self.delegate.visit_none()
507    }
508
509    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
510    where
511        D: de::Deserializer<'de>,
512    {
513        self.delegate
514            .visit_some(Deserializer::new(deserializer, self.source))
515    }
516
517    fn visit_unit<E>(self) -> Result<Self::Value, E>
518    where
519        E: de::Error,
520    {
521        self.delegate.visit_unit()
522    }
523
524    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
525    where
526        D: de::Deserializer<'de>,
527    {
528        self.delegate
529            .visit_newtype_struct(Deserializer::new(deserializer, self.source))
530    }
531
532    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
533    where
534        A: de::SeqAccess<'de>,
535    {
536        self.delegate.visit_seq(Wrap::new(seq, self.source))
537    }
538
539    fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
540    where
541        A: de::MapAccess<'de>,
542    {
543        self.delegate.visit_map(Wrap::new(map, self.source))
544    }
545
546    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
547    where
548        A: de::EnumAccess<'de>,
549    {
550        self.delegate.visit_enum(Wrap::new(data, self.source))
551    }
552}
553
554impl<'de, T, S> de::MapAccess<'de> for Wrap<'_, T, S>
555where
556    S: Source,
557    T: de::MapAccess<'de>,
558{
559    type Error = T::Error;
560
561    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
562    where
563        K: de::DeserializeSeed<'de>,
564    {
565        // Do not wrap the key, we do not want to resolve keys.
566        self.delegate.next_key_seed(seed)
567    }
568
569    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
570    where
571        V: de::DeserializeSeed<'de>,
572    {
573        self.delegate.next_value_seed(Wrap::new(seed, self.source))
574    }
575}
576
577impl<'de, T, S> de::SeqAccess<'de> for Wrap<'_, T, S>
578where
579    S: Source,
580    T: de::SeqAccess<'de>,
581{
582    type Error = T::Error;
583
584    fn next_element_seed<Seed>(&mut self, seed: Seed) -> Result<Option<Seed::Value>, Self::Error>
585    where
586        Seed: de::DeserializeSeed<'de>,
587    {
588        self.delegate
589            .next_element_seed(Wrap::new(seed, self.source))
590    }
591}
592
593impl<'de, T, S> de::EnumAccess<'de> for Wrap<'_, T, S>
594where
595    T: de::EnumAccess<'de>,
596    S: Source,
597{
598    type Error = T::Error;
599    type Variant = T::Variant;
600
601    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
602    where
603        V: de::DeserializeSeed<'de>,
604    {
605        self.delegate.variant_seed(Wrap::new(seed, self.source))
606    }
607}
608
609impl<'de, T, S> de::DeserializeSeed<'de> for Wrap<'_, T, S>
610where
611    T: de::DeserializeSeed<'de>,
612    S: Source,
613{
614    type Value = T::Value;
615
616    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
617    where
618        D: de::Deserializer<'de>,
619    {
620        let deserializer = Deserializer::new(deserializer, self.source);
621        T::deserialize(self.delegate, deserializer)
622    }
623}
624
625/// A [`de::Deserializer`] holding a [`Content`] that expands strings using a [`Source`].
626struct ContentVarDeserializer<'a, 'de, E, S> {
627    content: Content<'de>,
628    err: PhantomData<E>,
629    source: &'a mut S,
630}
631
632impl<'a, 'de, E, S> ContentVarDeserializer<'a, 'de, E, S> {
633    fn new(content: Content<'de>, source: &'a mut S) -> Self {
634        Self {
635            content,
636            err: PhantomData,
637            source,
638        }
639    }
640
641    fn from_de<D>(deserializer: D, source: &'a mut S) -> Result<Self, E>
642    where
643        D: de::Deserializer<'de, Error = E>,
644    {
645        Content::deserialize(deserializer).map(|content| Self::new(content, source))
646    }
647}
648
649impl<'de, E, S> ContentVarDeserializer<'_, 'de, E, S>
650where
651    E: de::Error,
652    S: Source,
653{
654    #[cold]
655    fn invalid_type(self, exp: &dyn de::Expected) -> E {
656        de::Error::invalid_type(self.content.unexpected(), exp)
657    }
658
659    fn deserialize_integer<V, F>(
660        self,
661        visitor: V,
662        visit: impl FnOnce(V, F) -> Result<V::Value, E>,
663        mut conv: impl FnMut(&mut S, &str) -> Result<Option<F>, E>,
664    ) -> Result<V::Value, E>
665    where
666        V: Visitor<'de>,
667    {
668        match match self.content {
669            Content::Str(s) => conv(self.source, s)?,
670            Content::String(ref s) => conv(self.source, s)?,
671            other => return other.visit(visitor),
672        } {
673            Some(v) => visit(visitor, v),
674            None => self.content.visit(visitor),
675        }
676    }
677
678    fn deserialize_float<V, F>(
679        self,
680        visitor: V,
681        visit: impl FnOnce(V, F) -> Result<V::Value, E>,
682        mut conv: impl FnMut(&mut S, &str) -> Result<Option<F>, E>,
683    ) -> Result<V::Value, E>
684    where
685        V: Visitor<'de>,
686    {
687        match match self.content {
688            Content::Str(s) => conv(self.source, s)?,
689            Content::String(ref s) => conv(self.source, s)?,
690            other => return other.visit(visitor),
691        } {
692            Some(v) => visit(visitor, v),
693            None => self.content.visit(visitor),
694        }
695    }
696}
697
698impl<'de, E, S> de::Deserializer<'de> for ContentVarDeserializer<'_, 'de, E, S>
699where
700    E: de::Error,
701    S: Source,
702{
703    type Error = E;
704
705    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
706    where
707        V: Visitor<'de>,
708    {
709        Err(self.invalid_type(&visitor))
710    }
711
712    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
713    where
714        V: Visitor<'de>,
715    {
716        match match self.content {
717            Content::Str(s) => self.source.expand_bool(s)?,
718            Content::String(ref s) => self.source.expand_bool(s)?,
719            other => return other.visit(visitor),
720        } {
721            Some(value) => visitor.visit_bool(value),
722            None => self.content.visit(visitor),
723        }
724    }
725
726    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
727    where
728        V: Visitor<'de>,
729    {
730        self.deserialize_integer(visitor, Visitor::visit_i8, Source::expand_i8)
731    }
732
733    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
734    where
735        V: Visitor<'de>,
736    {
737        self.deserialize_integer(visitor, Visitor::visit_i16, Source::expand_i16)
738    }
739
740    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
741    where
742        V: Visitor<'de>,
743    {
744        self.deserialize_integer(visitor, Visitor::visit_i32, Source::expand_i32)
745    }
746
747    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
748    where
749        V: Visitor<'de>,
750    {
751        self.deserialize_integer(visitor, Visitor::visit_i64, Source::expand_i64)
752    }
753
754    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
755    where
756        V: Visitor<'de>,
757    {
758        self.deserialize_integer(visitor, Visitor::visit_u8, Source::expand_u8)
759    }
760
761    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
762    where
763        V: Visitor<'de>,
764    {
765        self.deserialize_integer(visitor, Visitor::visit_u16, Source::expand_u16)
766    }
767
768    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
769    where
770        V: Visitor<'de>,
771    {
772        self.deserialize_integer(visitor, Visitor::visit_u32, Source::expand_u32)
773    }
774
775    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
776    where
777        V: Visitor<'de>,
778    {
779        self.deserialize_integer(visitor, Visitor::visit_u64, Source::expand_u64)
780    }
781
782    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
783    where
784        V: Visitor<'de>,
785    {
786        self.deserialize_float(visitor, Visitor::visit_f32, Source::expand_f32)
787    }
788
789    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
790    where
791        V: Visitor<'de>,
792    {
793        self.deserialize_float(visitor, Visitor::visit_f64, Source::expand_f64)
794    }
795
796    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
797    where
798        V: Visitor<'de>,
799    {
800        match self.content {
801            Content::String(_) | Content::Str(_) => self.deserialize_str(visitor),
802            other => other.visit(visitor),
803        }
804    }
805
806    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
807    where
808        V: Visitor<'de>,
809    {
810        self.deserialize_string(visitor)
811    }
812
813    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
814    where
815        V: Visitor<'de>,
816    {
817        match match self.content {
818            Content::String(v) => self.source.expand_str(Cow::Owned(v))?,
819            Content::Str(v) => self.source.expand_str(Cow::Borrowed(v))?,
820            other => return other.visit(visitor),
821        }
822        .collapse()
823        {
824            Cow::Owned(s) => visitor.visit_string(s),
825            Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
826        }
827    }
828
829    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
830    where
831        V: Visitor<'de>,
832    {
833        self.deserialize_byte_buf(visitor)
834    }
835
836    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
837    where
838        V: Visitor<'de>,
839    {
840        match match self.content {
841            Content::String(_) | Content::Str(_) => return self.deserialize_str(visitor),
842            Content::ByteBuf(v) => self.source.expand_bytes(Cow::Owned(v))?,
843            Content::Bytes(v) => self.source.expand_bytes(Cow::Borrowed(v))?,
844            other => return other.visit(visitor),
845        }
846        .collapse()
847        {
848            Cow::Owned(v) => visitor.visit_byte_buf(v),
849            Cow::Borrowed(v) => visitor.visit_bytes(v),
850        }
851    }
852
853    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
854    where
855        V: Visitor<'de>,
856    {
857        Err(self.invalid_type(&visitor))
858    }
859
860    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
861    where
862        V: Visitor<'de>,
863    {
864        Err(self.invalid_type(&visitor))
865    }
866
867    fn deserialize_unit_struct<V>(
868        self,
869        _name: &'static str,
870        visitor: V,
871    ) -> Result<V::Value, Self::Error>
872    where
873        V: Visitor<'de>,
874    {
875        Err(self.invalid_type(&visitor))
876    }
877
878    fn deserialize_newtype_struct<V>(
879        self,
880        _name: &'static str,
881        visitor: V,
882    ) -> Result<V::Value, Self::Error>
883    where
884        V: Visitor<'de>,
885    {
886        Err(self.invalid_type(&visitor))
887    }
888
889    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
890    where
891        V: Visitor<'de>,
892    {
893        Err(self.invalid_type(&visitor))
894    }
895
896    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
897    where
898        V: Visitor<'de>,
899    {
900        Err(self.invalid_type(&visitor))
901    }
902
903    fn deserialize_tuple_struct<V>(
904        self,
905        _name: &'static str,
906        _len: usize,
907        visitor: V,
908    ) -> Result<V::Value, Self::Error>
909    where
910        V: Visitor<'de>,
911    {
912        Err(self.invalid_type(&visitor))
913    }
914
915    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
916    where
917        V: Visitor<'de>,
918    {
919        Err(self.invalid_type(&visitor))
920    }
921
922    fn deserialize_struct<V>(
923        self,
924        _name: &'static str,
925        _fields: &'static [&'static str],
926        visitor: V,
927    ) -> Result<V::Value, Self::Error>
928    where
929        V: Visitor<'de>,
930    {
931        Err(self.invalid_type(&visitor))
932    }
933
934    fn deserialize_enum<V>(
935        self,
936        _name: &'static str,
937        _variants: &'static [&'static str],
938        visitor: V,
939    ) -> Result<V::Value, Self::Error>
940    where
941        V: Visitor<'de>,
942    {
943        Err(self.invalid_type(&visitor))
944    }
945
946    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
947    where
948        V: Visitor<'de>,
949    {
950        Err(self.invalid_type(&visitor))
951    }
952
953    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
954    where
955        V: Visitor<'de>,
956    {
957        drop(self);
958        visitor.visit_unit()
959    }
960}
serde_vars/de.rs

serde_vars/
de.rs
