serde_ignored/
lib.rs

1//! [![github]](https://github.com/dtolnay/serde-ignored)&ensp;[![crates-io]](https://crates.io/crates/serde_ignored)&ensp;[![docs-rs]](https://docs.rs/serde_ignored)
2//!
3//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
4//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
5//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
6//!
7//! <br>
8//!
9//! Find out about keys that are ignored when deserializing data. This crate
10//! provides a wrapper that works with any existing Serde `Deserializer` and
11//! invokes a callback on every ignored field.
12//!
13//! You can use this to warn users about extraneous keys in a config file, for
14//! example.
15//!
16//! Note that if you want unrecognized fields to be an error, consider using the
17//! `#[serde(deny_unknown_fields)]` [attribute] instead.
18//!
19//! [attribute]: https://serde.rs/attributes.html
20//!
21//! # Example
22//!
23//! ```
24//! # use serde_derive::Deserialize;
25//! #
26//! use serde::Deserialize;
27//! use std::collections::{BTreeSet as Set, BTreeMap as Map};
28//!
29//! #[derive(Debug, PartialEq, Deserialize)]
30//! struct Package {
31//!     name: String,
32//!     dependencies: Map<String, Dependency>,
33//! }
34//!
35//! #[derive(Debug, PartialEq, Deserialize)]
36//! struct Dependency {
37//!     version: String,
38//! }
39//!
40//! # fn try_main() -> Result<(), Box<::std::error::Error>> {
41//! let j = r#"{
42//!     "name": "demo",
43//!     "dependencies": {
44//!         "serde": {
45//!             "version": "1.0",
46//!             "typo1": ""
47//!         }
48//!     },
49//!     "typo2": {
50//!         "inner": ""
51//!     },
52//!     "typo3": {}
53//! }"#;
54//!
55//! // Some Deserializer.
56//! let jd = &mut serde_json::Deserializer::from_str(j);
57//!
58//! // We will build a set of paths to the unused elements.
59//! let mut unused = Set::new();
60//!
61//! let p: Package = serde_ignored::deserialize(jd, |path| {
62//!     unused.insert(path.to_string());
63//! })?;
64//!
65//! assert_eq!(p, Package {
66//!     name: "demo".to_owned(),
67//!     dependencies: {
68//!         let mut map = Map::new();
69//!         map.insert("serde".to_owned(), Dependency {
70//!             version: "1.0".to_owned(),
71//!         });
72//!         map
73//!     },
74//! });
75//!
76//! assert_eq!(unused, {
77//!     let mut expected = Set::new();
78//!     expected.insert("dependencies.serde.typo1".to_owned());
79//!     expected.insert("typo2".to_owned());
80//!     expected.insert("typo3".to_owned());
81//!     expected
82//! });
83//!
84//! # Ok(()) }
85//! # fn main() { try_main().unwrap() }
86//! ```
87
88#![no_std]
89#![doc(html_root_url = "https://docs.rs/serde_ignored/0.1.11")]
90#![allow(
91    clippy::elidable_lifetime_names,
92    clippy::missing_errors_doc,
93    clippy::needless_lifetimes
94)]
95
96extern crate alloc;
97
98use alloc::borrow::ToOwned;
99use alloc::string::{String, ToString};
100use alloc::vec::Vec;
101use core::fmt::{self, Display};
102use serde::de::{self, Deserialize, DeserializeSeed, Visitor};
103
104/// Entry point. See crate documentation for an example.
105pub fn deserialize<'de, D, F, T>(deserializer: D, mut callback: F) -> Result<T, D::Error>
106where
107    D: de::Deserializer<'de>,
108    F: FnMut(Path),
109    T: Deserialize<'de>,
110{
111    T::deserialize(Deserializer::new(deserializer, &mut callback))
112}
113
114/// Deserializer adapter that invokes a callback with the path to every unused
115/// field of the input.
116pub struct Deserializer<'a, 'b, D, F: 'b> {
117    de: D,
118    callback: &'b mut F,
119    path: Path<'a>,
120}
121
122impl<'a, 'b, D, F> Deserializer<'a, 'b, D, F>
123where
124    F: FnMut(Path),
125{
126    // The structs in this crate all hold their closure by &mut F. If they were
127    // to contain F by value, any method taking &mut self (for example
128    // SeqAccess::next_element_seed) would be forced to recurse with &mut
129    // self.callback, even if F is instantiated with a &mut already. This way
130    // they contain &mut F and the &mut self methods can recurse with
131    // self.callback unchanged. This avoids blowing the recursion limit in
132    // Cargo's use of this crate.
133    //
134    // https://github.com/dtolnay/serde-ignored/pull/1
135    pub fn new(de: D, callback: &'b mut F) -> Self {
136        Deserializer {
137            de,
138            callback,
139            path: Path::Root,
140        }
141    }
142}
143
144/// Path to the current value in the input, like `dependencies.serde.typo1`.
145pub enum Path<'a> {
146    Root,
147    Seq { parent: &'a Path<'a>, index: usize },
148    Map { parent: &'a Path<'a>, key: String },
149    Some { parent: &'a Path<'a> },
150    NewtypeStruct { parent: &'a Path<'a> },
151    NewtypeVariant { parent: &'a Path<'a> },
152}
153
154impl<'a> Display for Path<'a> {
155    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
156        struct Parent<'a>(&'a Path<'a>);
157
158        impl<'a> Display for Parent<'a> {
159            fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
160                match *self.0 {
161                    Path::Root => Ok(()),
162                    ref path => write!(formatter, "{}.", path),
163                }
164            }
165        }
166
167        match *self {
168            Path::Root => formatter.write_str("."),
169            Path::Seq { parent, index } => write!(formatter, "{}{}", Parent(parent), index),
170            Path::Map { parent, ref key } => write!(formatter, "{}{}", Parent(parent), key),
171            Path::Some { parent }
172            | Path::NewtypeStruct { parent }
173            | Path::NewtypeVariant { parent } => write!(formatter, "{}?", Parent(parent)),
174        }
175    }
176}
177
178/// Plain old forwarding impl except for `deserialize_ignored_any` which invokes
179/// the callback.
180impl<'a, 'b, 'de, D, F> de::Deserializer<'de> for Deserializer<'a, 'b, D, F>
181where
182    D: de::Deserializer<'de>,
183    F: FnMut(Path),
184{
185    type Error = D::Error;
186
187    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
188    where
189        V: Visitor<'de>,
190    {
191        self.de
192            .deserialize_any(Wrap::new(visitor, self.callback, &self.path))
193    }
194
195    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, D::Error>
196    where
197        V: Visitor<'de>,
198    {
199        self.de
200            .deserialize_bool(Wrap::new(visitor, self.callback, &self.path))
201    }
202
203    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, D::Error>
204    where
205        V: Visitor<'de>,
206    {
207        self.de
208            .deserialize_u8(Wrap::new(visitor, self.callback, &self.path))
209    }
210
211    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, D::Error>
212    where
213        V: Visitor<'de>,
214    {
215        self.de
216            .deserialize_u16(Wrap::new(visitor, self.callback, &self.path))
217    }
218
219    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, D::Error>
220    where
221        V: Visitor<'de>,
222    {
223        self.de
224            .deserialize_u32(Wrap::new(visitor, self.callback, &self.path))
225    }
226
227    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, D::Error>
228    where
229        V: Visitor<'de>,
230    {
231        self.de
232            .deserialize_u64(Wrap::new(visitor, self.callback, &self.path))
233    }
234
235    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, D::Error>
236    where
237        V: Visitor<'de>,
238    {
239        self.de
240            .deserialize_i8(Wrap::new(visitor, self.callback, &self.path))
241    }
242
243    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, D::Error>
244    where
245        V: Visitor<'de>,
246    {
247        self.de
248            .deserialize_i16(Wrap::new(visitor, self.callback, &self.path))
249    }
250
251    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, D::Error>
252    where
253        V: Visitor<'de>,
254    {
255        self.de
256            .deserialize_i32(Wrap::new(visitor, self.callback, &self.path))
257    }
258
259    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, D::Error>
260    where
261        V: Visitor<'de>,
262    {
263        self.de
264            .deserialize_i64(Wrap::new(visitor, self.callback, &self.path))
265    }
266
267    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, D::Error>
268    where
269        V: Visitor<'de>,
270    {
271        self.de
272            .deserialize_f32(Wrap::new(visitor, self.callback, &self.path))
273    }
274
275    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, D::Error>
276    where
277        V: Visitor<'de>,
278    {
279        self.de
280            .deserialize_f64(Wrap::new(visitor, self.callback, &self.path))
281    }
282
283    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, D::Error>
284    where
285        V: Visitor<'de>,
286    {
287        self.de
288            .deserialize_char(Wrap::new(visitor, self.callback, &self.path))
289    }
290
291    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, D::Error>
292    where
293        V: Visitor<'de>,
294    {
295        self.de
296            .deserialize_str(Wrap::new(visitor, self.callback, &self.path))
297    }
298
299    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D::Error>
300    where
301        V: Visitor<'de>,
302    {
303        self.de
304            .deserialize_string(Wrap::new(visitor, self.callback, &self.path))
305    }
306
307    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D::Error>
308    where
309        V: Visitor<'de>,
310    {
311        self.de
312            .deserialize_bytes(Wrap::new(visitor, self.callback, &self.path))
313    }
314
315    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, D::Error>
316    where
317        V: Visitor<'de>,
318    {
319        self.de
320            .deserialize_byte_buf(Wrap::new(visitor, self.callback, &self.path))
321    }
322
323    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, D::Error>
324    where
325        V: Visitor<'de>,
326    {
327        self.de
328            .deserialize_option(Wrap::new(visitor, self.callback, &self.path))
329    }
330
331    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D::Error>
332    where
333        V: Visitor<'de>,
334    {
335        self.de
336            .deserialize_unit(Wrap::new(visitor, self.callback, &self.path))
337    }
338
339    fn deserialize_unit_struct<V>(
340        self,
341        name: &'static str,
342        visitor: V,
343    ) -> Result<V::Value, D::Error>
344    where
345        V: Visitor<'de>,
346    {
347        self.de
348            .deserialize_unit_struct(name, Wrap::new(visitor, self.callback, &self.path))
349    }
350
351    fn deserialize_newtype_struct<V>(
352        self,
353        name: &'static str,
354        visitor: V,
355    ) -> Result<V::Value, D::Error>
356    where
357        V: Visitor<'de>,
358    {
359        self.de
360            .deserialize_newtype_struct(name, Wrap::new(visitor, self.callback, &self.path))
361    }
362
363    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D::Error>
364    where
365        V: Visitor<'de>,
366    {
367        self.de
368            .deserialize_seq(Wrap::new(visitor, self.callback, &self.path))
369    }
370
371    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
372    where
373        V: Visitor<'de>,
374    {
375        self.de
376            .deserialize_tuple(len, Wrap::new(visitor, self.callback, &self.path))
377    }
378
379    fn deserialize_tuple_struct<V>(
380        self,
381        name: &'static str,
382        len: usize,
383        visitor: V,
384    ) -> Result<V::Value, D::Error>
385    where
386        V: Visitor<'de>,
387    {
388        self.de
389            .deserialize_tuple_struct(name, len, Wrap::new(visitor, self.callback, &self.path))
390    }
391
392    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D::Error>
393    where
394        V: Visitor<'de>,
395    {
396        self.de
397            .deserialize_map(Wrap::new(visitor, self.callback, &self.path))
398    }
399
400    fn deserialize_struct<V>(
401        self,
402        name: &'static str,
403        fields: &'static [&'static str],
404        visitor: V,
405    ) -> Result<V::Value, D::Error>
406    where
407        V: Visitor<'de>,
408    {
409        self.de
410            .deserialize_struct(name, fields, Wrap::new(visitor, self.callback, &self.path))
411    }
412
413    fn deserialize_enum<V>(
414        self,
415        name: &'static str,
416        variants: &'static [&'static str],
417        visitor: V,
418    ) -> Result<V::Value, D::Error>
419    where
420        V: Visitor<'de>,
421    {
422        self.de.deserialize_enum(
423            name,
424            variants,
425            Wrap::new(visitor, self.callback, &self.path),
426        )
427    }
428
429    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
430    where
431        V: Visitor<'de>,
432    {
433        (self.callback)(self.path);
434        self.de.deserialize_ignored_any(visitor)
435    }
436
437    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D::Error>
438    where
439        V: Visitor<'de>,
440    {
441        self.de
442            .deserialize_identifier(Wrap::new(visitor, self.callback, &self.path))
443    }
444
445    fn is_human_readable(&self) -> bool {
446        self.de.is_human_readable()
447    }
448}
449
450/// Wrapper that attaches context to a `Visitor`, `SeqAccess`, `EnumAccess` or
451/// `VariantAccess`.
452struct Wrap<'a, 'b, X, F: 'b> {
453    delegate: X,
454    callback: &'b mut F,
455    path: &'a Path<'a>,
456}
457
458impl<'a, 'b, X, F> Wrap<'a, 'b, X, F> {
459    fn new(delegate: X, callback: &'b mut F, path: &'a Path<'a>) -> Self {
460        Wrap {
461            delegate,
462            callback,
463            path,
464        }
465    }
466}
467
468/// Forwarding impl to preserve context.
469impl<'a, 'b, 'de, X, F> Visitor<'de> for Wrap<'a, 'b, X, F>
470where
471    X: Visitor<'de>,
472    F: FnMut(Path),
473{
474    type Value = X::Value;
475
476    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
477        self.delegate.expecting(formatter)
478    }
479
480    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
481    where
482        E: de::Error,
483    {
484        self.delegate.visit_bool(v)
485    }
486
487    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
488    where
489        E: de::Error,
490    {
491        self.delegate.visit_i8(v)
492    }
493
494    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
495    where
496        E: de::Error,
497    {
498        self.delegate.visit_i16(v)
499    }
500
501    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
502    where
503        E: de::Error,
504    {
505        self.delegate.visit_i32(v)
506    }
507
508    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
509    where
510        E: de::Error,
511    {
512        self.delegate.visit_i64(v)
513    }
514
515    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
516    where
517        E: de::Error,
518    {
519        self.delegate.visit_u8(v)
520    }
521
522    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
523    where
524        E: de::Error,
525    {
526        self.delegate.visit_u16(v)
527    }
528
529    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
530    where
531        E: de::Error,
532    {
533        self.delegate.visit_u32(v)
534    }
535
536    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
537    where
538        E: de::Error,
539    {
540        self.delegate.visit_u64(v)
541    }
542
543    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
544    where
545        E: de::Error,
546    {
547        self.delegate.visit_f32(v)
548    }
549
550    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
551    where
552        E: de::Error,
553    {
554        self.delegate.visit_f64(v)
555    }
556
557    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
558    where
559        E: de::Error,
560    {
561        self.delegate.visit_char(v)
562    }
563
564    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
565    where
566        E: de::Error,
567    {
568        self.delegate.visit_str(v)
569    }
570
571    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
572    where
573        E: de::Error,
574    {
575        self.delegate.visit_borrowed_str(v)
576    }
577
578    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
579    where
580        E: de::Error,
581    {
582        self.delegate.visit_string(v)
583    }
584
585    fn visit_unit<E>(self) -> Result<Self::Value, E>
586    where
587        E: de::Error,
588    {
589        self.delegate.visit_unit()
590    }
591
592    fn visit_none<E>(self) -> Result<Self::Value, E>
593    where
594        E: de::Error,
595    {
596        self.delegate.visit_none()
597    }
598
599    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
600    where
601        D: de::Deserializer<'de>,
602    {
603        self.delegate.visit_some(Deserializer {
604            de: deserializer,
605            callback: self.callback,
606            path: Path::Some { parent: self.path },
607        })
608    }
609
610    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
611    where
612        D: de::Deserializer<'de>,
613    {
614        self.delegate.visit_newtype_struct(Deserializer {
615            de: deserializer,
616            callback: self.callback,
617            path: Path::NewtypeStruct { parent: self.path },
618        })
619    }
620
621    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
622    where
623        V: de::SeqAccess<'de>,
624    {
625        self.delegate
626            .visit_seq(SeqAccess::new(visitor, self.callback, self.path))
627    }
628
629    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
630    where
631        V: de::MapAccess<'de>,
632    {
633        self.delegate
634            .visit_map(MapAccess::new(visitor, self.callback, self.path))
635    }
636
637    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
638    where
639        V: de::EnumAccess<'de>,
640    {
641        self.delegate
642            .visit_enum(Wrap::new(visitor, self.callback, self.path))
643    }
644
645    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
646    where
647        E: de::Error,
648    {
649        self.delegate.visit_bytes(v)
650    }
651
652    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
653    where
654        E: de::Error,
655    {
656        self.delegate.visit_borrowed_bytes(v)
657    }
658
659    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
660    where
661        E: de::Error,
662    {
663        self.delegate.visit_byte_buf(v)
664    }
665}
666
667/// Forwarding impl to preserve context.
668impl<'a, 'b, 'de, X, F> de::EnumAccess<'de> for Wrap<'a, 'b, X, F>
669where
670    X: de::EnumAccess<'de> + 'a,
671    F: FnMut(Path) + 'b,
672{
673    type Error = X::Error;
674    type Variant = Wrap<'a, 'b, X::Variant, F>;
675
676    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
677    where
678        V: DeserializeSeed<'de>,
679    {
680        let callback = self.callback;
681        let path = self.path;
682        self.delegate
683            .variant_seed(seed)
684            .map(move |(v, vis)| (v, Wrap::new(vis, callback, path)))
685    }
686}
687
688/// Forwarding impl to preserve context.
689impl<'a, 'b, 'de, X, F> de::VariantAccess<'de> for Wrap<'a, 'b, X, F>
690where
691    X: de::VariantAccess<'de>,
692    F: FnMut(Path),
693{
694    type Error = X::Error;
695
696    fn unit_variant(self) -> Result<(), X::Error> {
697        self.delegate.unit_variant()
698    }
699
700    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, X::Error>
701    where
702        T: DeserializeSeed<'de>,
703    {
704        let path = Path::NewtypeVariant { parent: self.path };
705        self.delegate
706            .newtype_variant_seed(TrackedSeed::new(seed, self.callback, path))
707    }
708
709    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
710    where
711        V: Visitor<'de>,
712    {
713        self.delegate
714            .tuple_variant(len, Wrap::new(visitor, self.callback, self.path))
715    }
716
717    fn struct_variant<V>(
718        self,
719        fields: &'static [&'static str],
720        visitor: V,
721    ) -> Result<V::Value, X::Error>
722    where
723        V: Visitor<'de>,
724    {
725        self.delegate
726            .struct_variant(fields, Wrap::new(visitor, self.callback, self.path))
727    }
728}
729
730/// Seed that saves the string into the given optional during `visit_str` and
731/// `visit_string`.
732struct CaptureKey<'a, X> {
733    delegate: X,
734    key: &'a mut Option<String>,
735}
736
737impl<'a, X> CaptureKey<'a, X> {
738    fn new(delegate: X, key: &'a mut Option<String>) -> Self {
739        CaptureKey { delegate, key }
740    }
741}
742
743/// Forwarding impl.
744impl<'a, 'de, X> DeserializeSeed<'de> for CaptureKey<'a, X>
745where
746    X: DeserializeSeed<'de>,
747{
748    type Value = X::Value;
749
750    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
751    where
752        D: de::Deserializer<'de>,
753    {
754        self.delegate
755            .deserialize(CaptureKey::new(deserializer, self.key))
756    }
757}
758
759/// Forwarding impl.
760impl<'a, 'de, X> de::Deserializer<'de> for CaptureKey<'a, X>
761where
762    X: de::Deserializer<'de>,
763{
764    type Error = X::Error;
765
766    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
767    where
768        V: Visitor<'de>,
769    {
770        self.delegate
771            .deserialize_any(CaptureKey::new(visitor, self.key))
772    }
773
774    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, X::Error>
775    where
776        V: Visitor<'de>,
777    {
778        self.delegate
779            .deserialize_bool(CaptureKey::new(visitor, self.key))
780    }
781
782    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, X::Error>
783    where
784        V: Visitor<'de>,
785    {
786        self.delegate
787            .deserialize_u8(CaptureKey::new(visitor, self.key))
788    }
789
790    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, X::Error>
791    where
792        V: Visitor<'de>,
793    {
794        self.delegate
795            .deserialize_u16(CaptureKey::new(visitor, self.key))
796    }
797
798    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, X::Error>
799    where
800        V: Visitor<'de>,
801    {
802        self.delegate
803            .deserialize_u32(CaptureKey::new(visitor, self.key))
804    }
805
806    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, X::Error>
807    where
808        V: Visitor<'de>,
809    {
810        self.delegate
811            .deserialize_u64(CaptureKey::new(visitor, self.key))
812    }
813
814    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, X::Error>
815    where
816        V: Visitor<'de>,
817    {
818        self.delegate
819            .deserialize_i8(CaptureKey::new(visitor, self.key))
820    }
821
822    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, X::Error>
823    where
824        V: Visitor<'de>,
825    {
826        self.delegate
827            .deserialize_i16(CaptureKey::new(visitor, self.key))
828    }
829
830    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, X::Error>
831    where
832        V: Visitor<'de>,
833    {
834        self.delegate
835            .deserialize_i32(CaptureKey::new(visitor, self.key))
836    }
837
838    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, X::Error>
839    where
840        V: Visitor<'de>,
841    {
842        self.delegate
843            .deserialize_i64(CaptureKey::new(visitor, self.key))
844    }
845
846    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, X::Error>
847    where
848        V: Visitor<'de>,
849    {
850        self.delegate
851            .deserialize_f32(CaptureKey::new(visitor, self.key))
852    }
853
854    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, X::Error>
855    where
856        V: Visitor<'de>,
857    {
858        self.delegate
859            .deserialize_f64(CaptureKey::new(visitor, self.key))
860    }
861
862    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, X::Error>
863    where
864        V: Visitor<'de>,
865    {
866        self.delegate
867            .deserialize_char(CaptureKey::new(visitor, self.key))
868    }
869
870    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, X::Error>
871    where
872        V: Visitor<'de>,
873    {
874        self.delegate
875            .deserialize_str(CaptureKey::new(visitor, self.key))
876    }
877
878    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, X::Error>
879    where
880        V: Visitor<'de>,
881    {
882        self.delegate
883            .deserialize_string(CaptureKey::new(visitor, self.key))
884    }
885
886    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, X::Error>
887    where
888        V: Visitor<'de>,
889    {
890        self.delegate
891            .deserialize_bytes(CaptureKey::new(visitor, self.key))
892    }
893
894    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, X::Error>
895    where
896        V: Visitor<'de>,
897    {
898        self.delegate
899            .deserialize_byte_buf(CaptureKey::new(visitor, self.key))
900    }
901
902    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, X::Error>
903    where
904        V: Visitor<'de>,
905    {
906        self.delegate
907            .deserialize_option(CaptureKey::new(visitor, self.key))
908    }
909
910    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, X::Error>
911    where
912        V: Visitor<'de>,
913    {
914        self.delegate
915            .deserialize_unit(CaptureKey::new(visitor, self.key))
916    }
917
918    fn deserialize_unit_struct<V>(
919        self,
920        name: &'static str,
921        visitor: V,
922    ) -> Result<V::Value, X::Error>
923    where
924        V: Visitor<'de>,
925    {
926        self.delegate
927            .deserialize_unit_struct(name, CaptureKey::new(visitor, self.key))
928    }
929
930    fn deserialize_newtype_struct<V>(
931        self,
932        name: &'static str,
933        visitor: V,
934    ) -> Result<V::Value, X::Error>
935    where
936        V: Visitor<'de>,
937    {
938        self.delegate
939            .deserialize_newtype_struct(name, CaptureKey::new(visitor, self.key))
940    }
941
942    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, X::Error>
943    where
944        V: Visitor<'de>,
945    {
946        self.delegate
947            .deserialize_seq(CaptureKey::new(visitor, self.key))
948    }
949
950    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
951    where
952        V: Visitor<'de>,
953    {
954        self.delegate
955            .deserialize_tuple(len, CaptureKey::new(visitor, self.key))
956    }
957
958    fn deserialize_tuple_struct<V>(
959        self,
960        name: &'static str,
961        len: usize,
962        visitor: V,
963    ) -> Result<V::Value, X::Error>
964    where
965        V: Visitor<'de>,
966    {
967        self.delegate
968            .deserialize_tuple_struct(name, len, CaptureKey::new(visitor, self.key))
969    }
970
971    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, X::Error>
972    where
973        V: Visitor<'de>,
974    {
975        self.delegate
976            .deserialize_map(CaptureKey::new(visitor, self.key))
977    }
978
979    fn deserialize_struct<V>(
980        self,
981        name: &'static str,
982        fields: &'static [&'static str],
983        visitor: V,
984    ) -> Result<V::Value, X::Error>
985    where
986        V: Visitor<'de>,
987    {
988        self.delegate
989            .deserialize_struct(name, fields, CaptureKey::new(visitor, self.key))
990    }
991
992    fn deserialize_enum<V>(
993        self,
994        name: &'static str,
995        variants: &'static [&'static str],
996        visitor: V,
997    ) -> Result<V::Value, X::Error>
998    where
999        V: Visitor<'de>,
1000    {
1001        self.delegate
1002            .deserialize_enum(name, variants, CaptureKey::new(visitor, self.key))
1003    }
1004
1005    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
1006    where
1007        V: Visitor<'de>,
1008    {
1009        self.delegate
1010            .deserialize_ignored_any(CaptureKey::new(visitor, self.key))
1011    }
1012
1013    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, X::Error>
1014    where
1015        V: Visitor<'de>,
1016    {
1017        self.delegate
1018            .deserialize_identifier(CaptureKey::new(visitor, self.key))
1019    }
1020
1021    fn is_human_readable(&self) -> bool {
1022        self.delegate.is_human_readable()
1023    }
1024}
1025
1026/// Forwarding impl that also saves the value of integers and strings.
1027impl<'a, 'de, X> Visitor<'de> for CaptureKey<'a, X>
1028where
1029    X: Visitor<'de>,
1030{
1031    type Value = X::Value;
1032
1033    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1034        self.delegate.expecting(formatter)
1035    }
1036
1037    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
1038    where
1039        E: de::Error,
1040    {
1041        *self.key = Some(v.to_string());
1042        self.delegate.visit_bool(v)
1043    }
1044
1045    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
1046    where
1047        E: de::Error,
1048    {
1049        *self.key = Some(v.to_string());
1050        self.delegate.visit_i8(v)
1051    }
1052
1053    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
1054    where
1055        E: de::Error,
1056    {
1057        *self.key = Some(v.to_string());
1058        self.delegate.visit_i16(v)
1059    }
1060
1061    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
1062    where
1063        E: de::Error,
1064    {
1065        *self.key = Some(v.to_string());
1066        self.delegate.visit_i32(v)
1067    }
1068
1069    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
1070    where
1071        E: de::Error,
1072    {
1073        *self.key = Some(v.to_string());
1074        self.delegate.visit_i64(v)
1075    }
1076
1077    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
1078    where
1079        E: de::Error,
1080    {
1081        *self.key = Some(v.to_string());
1082        self.delegate.visit_u8(v)
1083    }
1084
1085    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
1086    where
1087        E: de::Error,
1088    {
1089        *self.key = Some(v.to_string());
1090        self.delegate.visit_u16(v)
1091    }
1092
1093    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
1094    where
1095        E: de::Error,
1096    {
1097        *self.key = Some(v.to_string());
1098        self.delegate.visit_u32(v)
1099    }
1100
1101    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
1102    where
1103        E: de::Error,
1104    {
1105        *self.key = Some(v.to_string());
1106        self.delegate.visit_u64(v)
1107    }
1108
1109    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
1110    where
1111        E: de::Error,
1112    {
1113        self.delegate.visit_f32(v)
1114    }
1115
1116    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
1117    where
1118        E: de::Error,
1119    {
1120        self.delegate.visit_f64(v)
1121    }
1122
1123    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
1124    where
1125        E: de::Error,
1126    {
1127        self.delegate.visit_char(v)
1128    }
1129
1130    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1131    where
1132        E: de::Error,
1133    {
1134        *self.key = Some(v.to_owned());
1135        self.delegate.visit_str(v)
1136    }
1137
1138    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
1139    where
1140        E: de::Error,
1141    {
1142        *self.key = Some(v.to_owned());
1143        self.delegate.visit_borrowed_str(v)
1144    }
1145
1146    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1147    where
1148        E: de::Error,
1149    {
1150        *self.key = Some(v.clone());
1151        self.delegate.visit_string(v)
1152    }
1153
1154    fn visit_unit<E>(self) -> Result<Self::Value, E>
1155    where
1156        E: de::Error,
1157    {
1158        self.delegate.visit_unit()
1159    }
1160
1161    fn visit_none<E>(self) -> Result<Self::Value, E>
1162    where
1163        E: de::Error,
1164    {
1165        self.delegate.visit_none()
1166    }
1167
1168    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1169    where
1170        D: de::Deserializer<'de>,
1171    {
1172        self.delegate.visit_some(deserializer)
1173    }
1174
1175    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1176    where
1177        D: de::Deserializer<'de>,
1178    {
1179        self.delegate
1180            .visit_newtype_struct(CaptureKey::new(deserializer, self.key))
1181    }
1182
1183    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1184    where
1185        V: de::SeqAccess<'de>,
1186    {
1187        self.delegate.visit_seq(visitor)
1188    }
1189
1190    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1191    where
1192        V: de::MapAccess<'de>,
1193    {
1194        self.delegate.visit_map(visitor)
1195    }
1196
1197    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1198    where
1199        V: de::EnumAccess<'de>,
1200    {
1201        self.delegate.visit_enum(CaptureKey::new(visitor, self.key))
1202    }
1203
1204    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
1205    where
1206        E: de::Error,
1207    {
1208        self.delegate.visit_bytes(v)
1209    }
1210
1211    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
1212    where
1213        E: de::Error,
1214    {
1215        self.delegate.visit_borrowed_bytes(v)
1216    }
1217
1218    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
1219    where
1220        E: de::Error,
1221    {
1222        self.delegate.visit_byte_buf(v)
1223    }
1224}
1225
1226impl<'a, 'de, X> de::EnumAccess<'de> for CaptureKey<'a, X>
1227where
1228    X: de::EnumAccess<'de>,
1229{
1230    type Error = X::Error;
1231    type Variant = X::Variant;
1232
1233    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
1234    where
1235        V: DeserializeSeed<'de>,
1236    {
1237        self.delegate.variant_seed(CaptureKey::new(seed, self.key))
1238    }
1239}
1240
1241/// Seed used for map values, sequence elements and newtype variants to track
1242/// their path.
1243struct TrackedSeed<'a, X, F: 'a> {
1244    seed: X,
1245    callback: &'a mut F,
1246    path: Path<'a>,
1247}
1248
1249impl<'a, X, F> TrackedSeed<'a, X, F> {
1250    fn new(seed: X, callback: &'a mut F, path: Path<'a>) -> Self {
1251        TrackedSeed {
1252            seed,
1253            callback,
1254            path,
1255        }
1256    }
1257}
1258
1259impl<'a, 'de, X, F> DeserializeSeed<'de> for TrackedSeed<'a, X, F>
1260where
1261    X: DeserializeSeed<'de>,
1262    F: FnMut(Path),
1263{
1264    type Value = X::Value;
1265
1266    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
1267    where
1268        D: de::Deserializer<'de>,
1269    {
1270        self.seed.deserialize(Deserializer {
1271            de: deserializer,
1272            callback: self.callback,
1273            path: self.path,
1274        })
1275    }
1276}
1277
1278/// Seq visitor that tracks the index of its elements.
1279struct SeqAccess<'a, 'b, X, F: 'b> {
1280    delegate: X,
1281    callback: &'b mut F,
1282    path: &'a Path<'a>,
1283    index: usize,
1284}
1285
1286impl<'a, 'b, X, F> SeqAccess<'a, 'b, X, F> {
1287    fn new(delegate: X, callback: &'b mut F, path: &'a Path<'a>) -> Self {
1288        SeqAccess {
1289            delegate,
1290            callback,
1291            path,
1292            index: 0,
1293        }
1294    }
1295}
1296
1297/// Forwarding impl to preserve context.
1298impl<'a, 'b, 'de, X, F> de::SeqAccess<'de> for SeqAccess<'a, 'b, X, F>
1299where
1300    X: de::SeqAccess<'de>,
1301    F: FnMut(Path),
1302{
1303    type Error = X::Error;
1304
1305    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, X::Error>
1306    where
1307        T: DeserializeSeed<'de>,
1308    {
1309        let path = Path::Seq {
1310            parent: self.path,
1311            index: self.index,
1312        };
1313        self.index += 1;
1314        self.delegate
1315            .next_element_seed(TrackedSeed::new(seed, self.callback, path))
1316    }
1317
1318    fn size_hint(&self) -> Option<usize> {
1319        self.delegate.size_hint()
1320    }
1321}
1322
1323/// Map visitor that captures the string value of its keys and uses that to
1324/// track the path to its values.
1325struct MapAccess<'a, 'b, X, F: 'b> {
1326    delegate: X,
1327    callback: &'b mut F,
1328    path: &'a Path<'a>,
1329    key: Option<String>,
1330}
1331
1332impl<'a, 'b, X, F> MapAccess<'a, 'b, X, F> {
1333    fn new(delegate: X, callback: &'b mut F, path: &'a Path<'a>) -> Self {
1334        MapAccess {
1335            delegate,
1336            callback,
1337            path,
1338            key: None,
1339        }
1340    }
1341
1342    fn key<E>(&mut self) -> Result<String, E>
1343    where
1344        E: de::Error,
1345    {
1346        self.key.take().ok_or_else(|| E::custom("non-string key"))
1347    }
1348}
1349
1350impl<'a, 'b, 'de, X, F> de::MapAccess<'de> for MapAccess<'a, 'b, X, F>
1351where
1352    X: de::MapAccess<'de>,
1353    F: FnMut(Path),
1354{
1355    type Error = X::Error;
1356
1357    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, X::Error>
1358    where
1359        K: DeserializeSeed<'de>,
1360    {
1361        self.delegate
1362            .next_key_seed(CaptureKey::new(seed, &mut self.key))
1363    }
1364
1365    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, X::Error>
1366    where
1367        V: DeserializeSeed<'de>,
1368    {
1369        let path = Path::Map {
1370            parent: self.path,
1371            key: self.key()?,
1372        };
1373        self.delegate
1374            .next_value_seed(TrackedSeed::new(seed, self.callback, path))
1375    }
1376
1377    fn size_hint(&self) -> Option<usize> {
1378        self.delegate.size_hint()
1379    }
1380}
serde_ignored/lib.rs

serde_ignored/
lib.rs
