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

serde_ignored/
lib.rs
