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.12")]
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_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
236    where
237        V: Visitor<'de>,
238    {
239        self.de
240            .deserialize_u128(Wrap::new(visitor, self.callback, &self.path))
241    }
242
243    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, D::Error>
244    where
245        V: Visitor<'de>,
246    {
247        self.de
248            .deserialize_i8(Wrap::new(visitor, self.callback, &self.path))
249    }
250
251    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, D::Error>
252    where
253        V: Visitor<'de>,
254    {
255        self.de
256            .deserialize_i16(Wrap::new(visitor, self.callback, &self.path))
257    }
258
259    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, D::Error>
260    where
261        V: Visitor<'de>,
262    {
263        self.de
264            .deserialize_i32(Wrap::new(visitor, self.callback, &self.path))
265    }
266
267    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, D::Error>
268    where
269        V: Visitor<'de>,
270    {
271        self.de
272            .deserialize_i64(Wrap::new(visitor, self.callback, &self.path))
273    }
274
275    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
276    where
277        V: Visitor<'de>,
278    {
279        self.de
280            .deserialize_i128(Wrap::new(visitor, self.callback, &self.path))
281    }
282
283    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, D::Error>
284    where
285        V: Visitor<'de>,
286    {
287        self.de
288            .deserialize_f32(Wrap::new(visitor, self.callback, &self.path))
289    }
290
291    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, D::Error>
292    where
293        V: Visitor<'de>,
294    {
295        self.de
296            .deserialize_f64(Wrap::new(visitor, self.callback, &self.path))
297    }
298
299    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, D::Error>
300    where
301        V: Visitor<'de>,
302    {
303        self.de
304            .deserialize_char(Wrap::new(visitor, self.callback, &self.path))
305    }
306
307    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, D::Error>
308    where
309        V: Visitor<'de>,
310    {
311        self.de
312            .deserialize_str(Wrap::new(visitor, self.callback, &self.path))
313    }
314
315    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D::Error>
316    where
317        V: Visitor<'de>,
318    {
319        self.de
320            .deserialize_string(Wrap::new(visitor, self.callback, &self.path))
321    }
322
323    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D::Error>
324    where
325        V: Visitor<'de>,
326    {
327        self.de
328            .deserialize_bytes(Wrap::new(visitor, self.callback, &self.path))
329    }
330
331    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, D::Error>
332    where
333        V: Visitor<'de>,
334    {
335        self.de
336            .deserialize_byte_buf(Wrap::new(visitor, self.callback, &self.path))
337    }
338
339    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, D::Error>
340    where
341        V: Visitor<'de>,
342    {
343        self.de
344            .deserialize_option(Wrap::new(visitor, self.callback, &self.path))
345    }
346
347    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D::Error>
348    where
349        V: Visitor<'de>,
350    {
351        self.de
352            .deserialize_unit(Wrap::new(visitor, self.callback, &self.path))
353    }
354
355    fn deserialize_unit_struct<V>(
356        self,
357        name: &'static str,
358        visitor: V,
359    ) -> Result<V::Value, D::Error>
360    where
361        V: Visitor<'de>,
362    {
363        self.de
364            .deserialize_unit_struct(name, Wrap::new(visitor, self.callback, &self.path))
365    }
366
367    fn deserialize_newtype_struct<V>(
368        self,
369        name: &'static str,
370        visitor: V,
371    ) -> Result<V::Value, D::Error>
372    where
373        V: Visitor<'de>,
374    {
375        self.de
376            .deserialize_newtype_struct(name, Wrap::new(visitor, self.callback, &self.path))
377    }
378
379    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D::Error>
380    where
381        V: Visitor<'de>,
382    {
383        self.de
384            .deserialize_seq(Wrap::new(visitor, self.callback, &self.path))
385    }
386
387    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
388    where
389        V: Visitor<'de>,
390    {
391        self.de
392            .deserialize_tuple(len, Wrap::new(visitor, self.callback, &self.path))
393    }
394
395    fn deserialize_tuple_struct<V>(
396        self,
397        name: &'static str,
398        len: usize,
399        visitor: V,
400    ) -> Result<V::Value, D::Error>
401    where
402        V: Visitor<'de>,
403    {
404        self.de
405            .deserialize_tuple_struct(name, len, Wrap::new(visitor, self.callback, &self.path))
406    }
407
408    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D::Error>
409    where
410        V: Visitor<'de>,
411    {
412        self.de
413            .deserialize_map(Wrap::new(visitor, self.callback, &self.path))
414    }
415
416    fn deserialize_struct<V>(
417        self,
418        name: &'static str,
419        fields: &'static [&'static str],
420        visitor: V,
421    ) -> Result<V::Value, D::Error>
422    where
423        V: Visitor<'de>,
424    {
425        self.de
426            .deserialize_struct(name, fields, Wrap::new(visitor, self.callback, &self.path))
427    }
428
429    fn deserialize_enum<V>(
430        self,
431        name: &'static str,
432        variants: &'static [&'static str],
433        visitor: V,
434    ) -> Result<V::Value, D::Error>
435    where
436        V: Visitor<'de>,
437    {
438        self.de.deserialize_enum(
439            name,
440            variants,
441            Wrap::new(visitor, self.callback, &self.path),
442        )
443    }
444
445    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
446    where
447        V: Visitor<'de>,
448    {
449        (self.callback)(self.path);
450        self.de.deserialize_ignored_any(visitor)
451    }
452
453    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D::Error>
454    where
455        V: Visitor<'de>,
456    {
457        self.de
458            .deserialize_identifier(Wrap::new(visitor, self.callback, &self.path))
459    }
460
461    fn is_human_readable(&self) -> bool {
462        self.de.is_human_readable()
463    }
464}
465
466/// Wrapper that attaches context to a `Visitor`, `SeqAccess`, `EnumAccess` or
467/// `VariantAccess`.
468struct Wrap<'a, 'b, X, F: 'b> {
469    delegate: X,
470    callback: &'b mut F,
471    path: &'a Path<'a>,
472}
473
474impl<'a, 'b, X, F> Wrap<'a, 'b, X, F> {
475    fn new(delegate: X, callback: &'b mut F, path: &'a Path<'a>) -> Self {
476        Wrap {
477            delegate,
478            callback,
479            path,
480        }
481    }
482}
483
484/// Forwarding impl to preserve context.
485impl<'a, 'b, 'de, X, F> Visitor<'de> for Wrap<'a, 'b, X, F>
486where
487    X: Visitor<'de>,
488    F: FnMut(Path),
489{
490    type Value = X::Value;
491
492    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
493        self.delegate.expecting(formatter)
494    }
495
496    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
497    where
498        E: de::Error,
499    {
500        self.delegate.visit_bool(v)
501    }
502
503    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
504    where
505        E: de::Error,
506    {
507        self.delegate.visit_i8(v)
508    }
509
510    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
511    where
512        E: de::Error,
513    {
514        self.delegate.visit_i16(v)
515    }
516
517    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
518    where
519        E: de::Error,
520    {
521        self.delegate.visit_i32(v)
522    }
523
524    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
525    where
526        E: de::Error,
527    {
528        self.delegate.visit_i64(v)
529    }
530
531    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
532    where
533        E: de::Error,
534    {
535        self.delegate.visit_i128(v)
536    }
537
538    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
539    where
540        E: de::Error,
541    {
542        self.delegate.visit_u8(v)
543    }
544
545    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
546    where
547        E: de::Error,
548    {
549        self.delegate.visit_u16(v)
550    }
551
552    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
553    where
554        E: de::Error,
555    {
556        self.delegate.visit_u32(v)
557    }
558
559    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
560    where
561        E: de::Error,
562    {
563        self.delegate.visit_u64(v)
564    }
565
566    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
567    where
568        E: de::Error,
569    {
570        self.delegate.visit_u128(v)
571    }
572
573    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
574    where
575        E: de::Error,
576    {
577        self.delegate.visit_f32(v)
578    }
579
580    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
581    where
582        E: de::Error,
583    {
584        self.delegate.visit_f64(v)
585    }
586
587    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
588    where
589        E: de::Error,
590    {
591        self.delegate.visit_char(v)
592    }
593
594    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
595    where
596        E: de::Error,
597    {
598        self.delegate.visit_str(v)
599    }
600
601    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
602    where
603        E: de::Error,
604    {
605        self.delegate.visit_borrowed_str(v)
606    }
607
608    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
609    where
610        E: de::Error,
611    {
612        self.delegate.visit_string(v)
613    }
614
615    fn visit_unit<E>(self) -> Result<Self::Value, E>
616    where
617        E: de::Error,
618    {
619        self.delegate.visit_unit()
620    }
621
622    fn visit_none<E>(self) -> Result<Self::Value, E>
623    where
624        E: de::Error,
625    {
626        self.delegate.visit_none()
627    }
628
629    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
630    where
631        D: de::Deserializer<'de>,
632    {
633        self.delegate.visit_some(Deserializer {
634            de: deserializer,
635            callback: self.callback,
636            path: Path::Some { parent: self.path },
637        })
638    }
639
640    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
641    where
642        D: de::Deserializer<'de>,
643    {
644        self.delegate.visit_newtype_struct(Deserializer {
645            de: deserializer,
646            callback: self.callback,
647            path: Path::NewtypeStruct { parent: self.path },
648        })
649    }
650
651    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
652    where
653        V: de::SeqAccess<'de>,
654    {
655        self.delegate
656            .visit_seq(SeqAccess::new(visitor, self.callback, self.path))
657    }
658
659    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
660    where
661        V: de::MapAccess<'de>,
662    {
663        self.delegate
664            .visit_map(MapAccess::new(visitor, self.callback, self.path))
665    }
666
667    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
668    where
669        V: de::EnumAccess<'de>,
670    {
671        self.delegate
672            .visit_enum(Wrap::new(visitor, self.callback, self.path))
673    }
674
675    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
676    where
677        E: de::Error,
678    {
679        self.delegate.visit_bytes(v)
680    }
681
682    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
683    where
684        E: de::Error,
685    {
686        self.delegate.visit_borrowed_bytes(v)
687    }
688
689    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
690    where
691        E: de::Error,
692    {
693        self.delegate.visit_byte_buf(v)
694    }
695}
696
697/// Forwarding impl to preserve context.
698impl<'a, 'b, 'de, X, F> de::EnumAccess<'de> for Wrap<'a, 'b, X, F>
699where
700    X: de::EnumAccess<'de> + 'a,
701    F: FnMut(Path) + 'b,
702{
703    type Error = X::Error;
704    type Variant = Wrap<'a, 'b, X::Variant, F>;
705
706    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
707    where
708        V: DeserializeSeed<'de>,
709    {
710        let callback = self.callback;
711        let path = self.path;
712        self.delegate
713            .variant_seed(seed)
714            .map(move |(v, vis)| (v, Wrap::new(vis, callback, path)))
715    }
716}
717
718/// Forwarding impl to preserve context.
719impl<'a, 'b, 'de, X, F> de::VariantAccess<'de> for Wrap<'a, 'b, X, F>
720where
721    X: de::VariantAccess<'de>,
722    F: FnMut(Path),
723{
724    type Error = X::Error;
725
726    fn unit_variant(self) -> Result<(), X::Error> {
727        self.delegate.unit_variant()
728    }
729
730    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, X::Error>
731    where
732        T: DeserializeSeed<'de>,
733    {
734        let path = Path::NewtypeVariant { parent: self.path };
735        self.delegate
736            .newtype_variant_seed(TrackedSeed::new(seed, self.callback, path))
737    }
738
739    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
740    where
741        V: Visitor<'de>,
742    {
743        self.delegate
744            .tuple_variant(len, Wrap::new(visitor, self.callback, self.path))
745    }
746
747    fn struct_variant<V>(
748        self,
749        fields: &'static [&'static str],
750        visitor: V,
751    ) -> Result<V::Value, X::Error>
752    where
753        V: Visitor<'de>,
754    {
755        self.delegate
756            .struct_variant(fields, Wrap::new(visitor, self.callback, self.path))
757    }
758}
759
760/// Seed that saves the string into the given optional during `visit_str` and
761/// `visit_string`.
762struct CaptureKey<'a, X> {
763    delegate: X,
764    key: &'a mut Option<String>,
765}
766
767impl<'a, X> CaptureKey<'a, X> {
768    fn new(delegate: X, key: &'a mut Option<String>) -> Self {
769        CaptureKey { delegate, key }
770    }
771}
772
773/// Forwarding impl.
774impl<'a, 'de, X> DeserializeSeed<'de> for CaptureKey<'a, X>
775where
776    X: DeserializeSeed<'de>,
777{
778    type Value = X::Value;
779
780    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
781    where
782        D: de::Deserializer<'de>,
783    {
784        self.delegate
785            .deserialize(CaptureKey::new(deserializer, self.key))
786    }
787}
788
789/// Forwarding impl.
790impl<'a, 'de, X> de::Deserializer<'de> for CaptureKey<'a, X>
791where
792    X: de::Deserializer<'de>,
793{
794    type Error = X::Error;
795
796    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
797    where
798        V: Visitor<'de>,
799    {
800        self.delegate
801            .deserialize_any(CaptureKey::new(visitor, self.key))
802    }
803
804    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, X::Error>
805    where
806        V: Visitor<'de>,
807    {
808        self.delegate
809            .deserialize_bool(CaptureKey::new(visitor, self.key))
810    }
811
812    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, X::Error>
813    where
814        V: Visitor<'de>,
815    {
816        self.delegate
817            .deserialize_u8(CaptureKey::new(visitor, self.key))
818    }
819
820    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, X::Error>
821    where
822        V: Visitor<'de>,
823    {
824        self.delegate
825            .deserialize_u16(CaptureKey::new(visitor, self.key))
826    }
827
828    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, X::Error>
829    where
830        V: Visitor<'de>,
831    {
832        self.delegate
833            .deserialize_u32(CaptureKey::new(visitor, self.key))
834    }
835
836    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, X::Error>
837    where
838        V: Visitor<'de>,
839    {
840        self.delegate
841            .deserialize_u64(CaptureKey::new(visitor, self.key))
842    }
843
844    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, X::Error>
845    where
846        V: Visitor<'de>,
847    {
848        self.delegate
849            .deserialize_u128(CaptureKey::new(visitor, self.key))
850    }
851
852    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, X::Error>
853    where
854        V: Visitor<'de>,
855    {
856        self.delegate
857            .deserialize_i8(CaptureKey::new(visitor, self.key))
858    }
859
860    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, X::Error>
861    where
862        V: Visitor<'de>,
863    {
864        self.delegate
865            .deserialize_i16(CaptureKey::new(visitor, self.key))
866    }
867
868    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, X::Error>
869    where
870        V: Visitor<'de>,
871    {
872        self.delegate
873            .deserialize_i32(CaptureKey::new(visitor, self.key))
874    }
875
876    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, X::Error>
877    where
878        V: Visitor<'de>,
879    {
880        self.delegate
881            .deserialize_i64(CaptureKey::new(visitor, self.key))
882    }
883
884    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, X::Error>
885    where
886        V: Visitor<'de>,
887    {
888        self.delegate
889            .deserialize_i128(CaptureKey::new(visitor, self.key))
890    }
891
892    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, X::Error>
893    where
894        V: Visitor<'de>,
895    {
896        self.delegate
897            .deserialize_f32(CaptureKey::new(visitor, self.key))
898    }
899
900    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, X::Error>
901    where
902        V: Visitor<'de>,
903    {
904        self.delegate
905            .deserialize_f64(CaptureKey::new(visitor, self.key))
906    }
907
908    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, X::Error>
909    where
910        V: Visitor<'de>,
911    {
912        self.delegate
913            .deserialize_char(CaptureKey::new(visitor, self.key))
914    }
915
916    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, X::Error>
917    where
918        V: Visitor<'de>,
919    {
920        self.delegate
921            .deserialize_str(CaptureKey::new(visitor, self.key))
922    }
923
924    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, X::Error>
925    where
926        V: Visitor<'de>,
927    {
928        self.delegate
929            .deserialize_string(CaptureKey::new(visitor, self.key))
930    }
931
932    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, X::Error>
933    where
934        V: Visitor<'de>,
935    {
936        self.delegate
937            .deserialize_bytes(CaptureKey::new(visitor, self.key))
938    }
939
940    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, X::Error>
941    where
942        V: Visitor<'de>,
943    {
944        self.delegate
945            .deserialize_byte_buf(CaptureKey::new(visitor, self.key))
946    }
947
948    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, X::Error>
949    where
950        V: Visitor<'de>,
951    {
952        self.delegate
953            .deserialize_option(CaptureKey::new(visitor, self.key))
954    }
955
956    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, X::Error>
957    where
958        V: Visitor<'de>,
959    {
960        self.delegate
961            .deserialize_unit(CaptureKey::new(visitor, self.key))
962    }
963
964    fn deserialize_unit_struct<V>(
965        self,
966        name: &'static str,
967        visitor: V,
968    ) -> Result<V::Value, X::Error>
969    where
970        V: Visitor<'de>,
971    {
972        self.delegate
973            .deserialize_unit_struct(name, CaptureKey::new(visitor, self.key))
974    }
975
976    fn deserialize_newtype_struct<V>(
977        self,
978        name: &'static str,
979        visitor: V,
980    ) -> Result<V::Value, X::Error>
981    where
982        V: Visitor<'de>,
983    {
984        self.delegate
985            .deserialize_newtype_struct(name, CaptureKey::new(visitor, self.key))
986    }
987
988    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, X::Error>
989    where
990        V: Visitor<'de>,
991    {
992        self.delegate
993            .deserialize_seq(CaptureKey::new(visitor, self.key))
994    }
995
996    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
997    where
998        V: Visitor<'de>,
999    {
1000        self.delegate
1001            .deserialize_tuple(len, CaptureKey::new(visitor, self.key))
1002    }
1003
1004    fn deserialize_tuple_struct<V>(
1005        self,
1006        name: &'static str,
1007        len: usize,
1008        visitor: V,
1009    ) -> Result<V::Value, X::Error>
1010    where
1011        V: Visitor<'de>,
1012    {
1013        self.delegate
1014            .deserialize_tuple_struct(name, len, CaptureKey::new(visitor, self.key))
1015    }
1016
1017    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, X::Error>
1018    where
1019        V: Visitor<'de>,
1020    {
1021        self.delegate
1022            .deserialize_map(CaptureKey::new(visitor, self.key))
1023    }
1024
1025    fn deserialize_struct<V>(
1026        self,
1027        name: &'static str,
1028        fields: &'static [&'static str],
1029        visitor: V,
1030    ) -> Result<V::Value, X::Error>
1031    where
1032        V: Visitor<'de>,
1033    {
1034        self.delegate
1035            .deserialize_struct(name, fields, CaptureKey::new(visitor, self.key))
1036    }
1037
1038    fn deserialize_enum<V>(
1039        self,
1040        name: &'static str,
1041        variants: &'static [&'static str],
1042        visitor: V,
1043    ) -> Result<V::Value, X::Error>
1044    where
1045        V: Visitor<'de>,
1046    {
1047        self.delegate
1048            .deserialize_enum(name, variants, CaptureKey::new(visitor, self.key))
1049    }
1050
1051    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
1052    where
1053        V: Visitor<'de>,
1054    {
1055        self.delegate
1056            .deserialize_ignored_any(CaptureKey::new(visitor, self.key))
1057    }
1058
1059    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, X::Error>
1060    where
1061        V: Visitor<'de>,
1062    {
1063        self.delegate
1064            .deserialize_identifier(CaptureKey::new(visitor, self.key))
1065    }
1066
1067    fn is_human_readable(&self) -> bool {
1068        self.delegate.is_human_readable()
1069    }
1070}
1071
1072/// Forwarding impl that also saves the value of integers and strings.
1073impl<'a, 'de, X> Visitor<'de> for CaptureKey<'a, X>
1074where
1075    X: Visitor<'de>,
1076{
1077    type Value = X::Value;
1078
1079    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1080        self.delegate.expecting(formatter)
1081    }
1082
1083    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
1084    where
1085        E: de::Error,
1086    {
1087        *self.key = Some(v.to_string());
1088        self.delegate.visit_bool(v)
1089    }
1090
1091    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
1092    where
1093        E: de::Error,
1094    {
1095        *self.key = Some(v.to_string());
1096        self.delegate.visit_i8(v)
1097    }
1098
1099    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
1100    where
1101        E: de::Error,
1102    {
1103        *self.key = Some(v.to_string());
1104        self.delegate.visit_i16(v)
1105    }
1106
1107    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
1108    where
1109        E: de::Error,
1110    {
1111        *self.key = Some(v.to_string());
1112        self.delegate.visit_i32(v)
1113    }
1114
1115    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
1116    where
1117        E: de::Error,
1118    {
1119        *self.key = Some(v.to_string());
1120        self.delegate.visit_i64(v)
1121    }
1122
1123    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
1124    where
1125        E: de::Error,
1126    {
1127        *self.key = Some(v.to_string());
1128        self.delegate.visit_i128(v)
1129    }
1130
1131    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
1132    where
1133        E: de::Error,
1134    {
1135        *self.key = Some(v.to_string());
1136        self.delegate.visit_u8(v)
1137    }
1138
1139    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
1140    where
1141        E: de::Error,
1142    {
1143        *self.key = Some(v.to_string());
1144        self.delegate.visit_u16(v)
1145    }
1146
1147    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
1148    where
1149        E: de::Error,
1150    {
1151        *self.key = Some(v.to_string());
1152        self.delegate.visit_u32(v)
1153    }
1154
1155    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
1156    where
1157        E: de::Error,
1158    {
1159        *self.key = Some(v.to_string());
1160        self.delegate.visit_u64(v)
1161    }
1162
1163    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
1164    where
1165        E: de::Error,
1166    {
1167        *self.key = Some(v.to_string());
1168        self.delegate.visit_u128(v)
1169    }
1170
1171    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
1172    where
1173        E: de::Error,
1174    {
1175        self.delegate.visit_f32(v)
1176    }
1177
1178    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
1179    where
1180        E: de::Error,
1181    {
1182        self.delegate.visit_f64(v)
1183    }
1184
1185    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
1186    where
1187        E: de::Error,
1188    {
1189        self.delegate.visit_char(v)
1190    }
1191
1192    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1193    where
1194        E: de::Error,
1195    {
1196        *self.key = Some(v.to_owned());
1197        self.delegate.visit_str(v)
1198    }
1199
1200    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
1201    where
1202        E: de::Error,
1203    {
1204        *self.key = Some(v.to_owned());
1205        self.delegate.visit_borrowed_str(v)
1206    }
1207
1208    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1209    where
1210        E: de::Error,
1211    {
1212        *self.key = Some(v.clone());
1213        self.delegate.visit_string(v)
1214    }
1215
1216    fn visit_unit<E>(self) -> Result<Self::Value, E>
1217    where
1218        E: de::Error,
1219    {
1220        self.delegate.visit_unit()
1221    }
1222
1223    fn visit_none<E>(self) -> Result<Self::Value, E>
1224    where
1225        E: de::Error,
1226    {
1227        self.delegate.visit_none()
1228    }
1229
1230    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1231    where
1232        D: de::Deserializer<'de>,
1233    {
1234        self.delegate.visit_some(deserializer)
1235    }
1236
1237    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1238    where
1239        D: de::Deserializer<'de>,
1240    {
1241        self.delegate
1242            .visit_newtype_struct(CaptureKey::new(deserializer, self.key))
1243    }
1244
1245    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1246    where
1247        V: de::SeqAccess<'de>,
1248    {
1249        self.delegate.visit_seq(visitor)
1250    }
1251
1252    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1253    where
1254        V: de::MapAccess<'de>,
1255    {
1256        self.delegate.visit_map(visitor)
1257    }
1258
1259    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1260    where
1261        V: de::EnumAccess<'de>,
1262    {
1263        self.delegate.visit_enum(CaptureKey::new(visitor, self.key))
1264    }
1265
1266    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
1267    where
1268        E: de::Error,
1269    {
1270        self.delegate.visit_bytes(v)
1271    }
1272
1273    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
1274    where
1275        E: de::Error,
1276    {
1277        self.delegate.visit_borrowed_bytes(v)
1278    }
1279
1280    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
1281    where
1282        E: de::Error,
1283    {
1284        self.delegate.visit_byte_buf(v)
1285    }
1286}
1287
1288impl<'a, 'de, X> de::EnumAccess<'de> for CaptureKey<'a, X>
1289where
1290    X: de::EnumAccess<'de>,
1291{
1292    type Error = X::Error;
1293    type Variant = X::Variant;
1294
1295    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
1296    where
1297        V: DeserializeSeed<'de>,
1298    {
1299        self.delegate.variant_seed(CaptureKey::new(seed, self.key))
1300    }
1301}
1302
1303/// Seed used for map values, sequence elements and newtype variants to track
1304/// their path.
1305struct TrackedSeed<'a, X, F: 'a> {
1306    seed: X,
1307    callback: &'a mut F,
1308    path: Path<'a>,
1309}
1310
1311impl<'a, X, F> TrackedSeed<'a, X, F> {
1312    fn new(seed: X, callback: &'a mut F, path: Path<'a>) -> Self {
1313        TrackedSeed {
1314            seed,
1315            callback,
1316            path,
1317        }
1318    }
1319}
1320
1321impl<'a, 'de, X, F> DeserializeSeed<'de> for TrackedSeed<'a, X, F>
1322where
1323    X: DeserializeSeed<'de>,
1324    F: FnMut(Path),
1325{
1326    type Value = X::Value;
1327
1328    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
1329    where
1330        D: de::Deserializer<'de>,
1331    {
1332        self.seed.deserialize(Deserializer {
1333            de: deserializer,
1334            callback: self.callback,
1335            path: self.path,
1336        })
1337    }
1338}
1339
1340/// Seq visitor that tracks the index of its elements.
1341struct SeqAccess<'a, 'b, X, F: 'b> {
1342    delegate: X,
1343    callback: &'b mut F,
1344    path: &'a Path<'a>,
1345    index: usize,
1346}
1347
1348impl<'a, 'b, X, F> SeqAccess<'a, 'b, X, F> {
1349    fn new(delegate: X, callback: &'b mut F, path: &'a Path<'a>) -> Self {
1350        SeqAccess {
1351            delegate,
1352            callback,
1353            path,
1354            index: 0,
1355        }
1356    }
1357}
1358
1359/// Forwarding impl to preserve context.
1360impl<'a, 'b, 'de, X, F> de::SeqAccess<'de> for SeqAccess<'a, 'b, X, F>
1361where
1362    X: de::SeqAccess<'de>,
1363    F: FnMut(Path),
1364{
1365    type Error = X::Error;
1366
1367    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, X::Error>
1368    where
1369        T: DeserializeSeed<'de>,
1370    {
1371        let path = Path::Seq {
1372            parent: self.path,
1373            index: self.index,
1374        };
1375        self.index += 1;
1376        self.delegate
1377            .next_element_seed(TrackedSeed::new(seed, self.callback, path))
1378    }
1379
1380    fn size_hint(&self) -> Option<usize> {
1381        self.delegate.size_hint()
1382    }
1383}
1384
1385/// Map visitor that captures the string value of its keys and uses that to
1386/// track the path to its values.
1387struct MapAccess<'a, 'b, X, F: 'b> {
1388    delegate: X,
1389    callback: &'b mut F,
1390    path: &'a Path<'a>,
1391    key: Option<String>,
1392}
1393
1394impl<'a, 'b, X, F> MapAccess<'a, 'b, X, F> {
1395    fn new(delegate: X, callback: &'b mut F, path: &'a Path<'a>) -> Self {
1396        MapAccess {
1397            delegate,
1398            callback,
1399            path,
1400            key: None,
1401        }
1402    }
1403
1404    fn key<E>(&mut self) -> Result<String, E>
1405    where
1406        E: de::Error,
1407    {
1408        self.key.take().ok_or_else(|| E::custom("non-string key"))
1409    }
1410}
1411
1412impl<'a, 'b, 'de, X, F> de::MapAccess<'de> for MapAccess<'a, 'b, X, F>
1413where
1414    X: de::MapAccess<'de>,
1415    F: FnMut(Path),
1416{
1417    type Error = X::Error;
1418
1419    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, X::Error>
1420    where
1421        K: DeserializeSeed<'de>,
1422    {
1423        self.delegate
1424            .next_key_seed(CaptureKey::new(seed, &mut self.key))
1425    }
1426
1427    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, X::Error>
1428    where
1429        V: DeserializeSeed<'de>,
1430    {
1431        let path = Path::Map {
1432            parent: self.path,
1433            key: self.key()?,
1434        };
1435        self.delegate
1436            .next_value_seed(TrackedSeed::new(seed, self.callback, path))
1437    }
1438
1439    fn size_hint(&self) -> Option<usize> {
1440        self.delegate.size_hint()
1441    }
1442}
serde_ignored/lib.rs

serde_ignored/
lib.rs
