relay_pii/
transform.rs

1//! A transforming `serde` Deserializer`.
2
3use std::borrow::Cow;
4use std::fmt;
5
6use serde::de;
7
8/// A transform for deserialized values.
9///
10/// This transformer defines callbacks that will be called by a [`Deserializer`] during
11/// deserialization to map values inline. The default for every transform callback is the identity
12/// function, which will not change the value.
13///
14/// There is a default implementation for all functions with a matching signature, for example
15/// `FnMut(&str) -> Cow<str>`.
16///
17/// # Strings and Bytes
18///
19/// When implementing a transform for strings or bytes, **always implement both** the owned and
20/// borrowed version:
21///
22///  - `transform_str` and `transform_string` for strings
23///  - `transform_bytes` and `transform_byte_buf` for bytes.
24///
25/// # Numbers
26///
27/// If the deserializer is used on a format that supports all numeric types, the default of each
28/// transform function is the identity. To override this, all of `transform_i*` and `transform_u*`
29/// have to be implemented.
30///
31/// # Example
32///
33/// ```ignore
34/// struct StringDefault(&'static str);
35///
36/// impl Transform for StringDefault {
37///     fn transform_str<'a>(&mut self, v: &'a str) -> Cow<'a, str> {
38///         match v {
39///             "" => Cow::Borrowed(self.0),
40///             other => Cow::Borrowed(other),
41///         }
42///     }
43///
44///     fn transform_string(&mut self, v: String) -> Cow<'a, str> {
45///         match v.as_str() {
46///             "" => Cow::Borrowed(self.0),
47///             _ => Cow::Owned(v),
48///         }
49///     }
50/// }
51/// ```
52#[allow(missing_docs)]
53pub trait Transform<'de> {
54    fn push_path(&mut self, _key: &'de str) {}
55
56    fn pop_path(&mut self) {}
57
58    fn transform_bool(&mut self, v: bool) -> bool {
59        v
60    }
61
62    fn transform_i8(&mut self, v: i8) -> i8 {
63        v
64    }
65
66    fn transform_i16(&mut self, v: i16) -> i16 {
67        v
68    }
69
70    fn transform_i32(&mut self, v: i32) -> i32 {
71        v
72    }
73
74    fn transform_i64(&mut self, v: i64) -> i64 {
75        v
76    }
77
78    fn transform_u8(&mut self, v: u8) -> u8 {
79        v
80    }
81
82    fn transform_u16(&mut self, v: u16) -> u16 {
83        v
84    }
85
86    fn transform_u32(&mut self, v: u32) -> u32 {
87        v
88    }
89
90    fn transform_u64(&mut self, v: u64) -> u64 {
91        v
92    }
93
94    fn transform_i128(&mut self, v: i128) -> i128 {
95        v
96    }
97
98    fn transform_u128(&mut self, v: u128) -> u128 {
99        v
100    }
101
102    fn transform_f32(&mut self, v: f32) -> f32 {
103        v
104    }
105
106    fn transform_f64(&mut self, v: f64) -> f64 {
107        v
108    }
109
110    fn transform_char(&mut self, v: char) -> char {
111        v
112    }
113
114    fn transform_str<'a>(&mut self, v: &'a str) -> Cow<'a, str> {
115        Cow::Borrowed(v)
116    }
117
118    fn transform_string(&mut self, v: String) -> Cow<'static, str> {
119        Cow::Owned(v)
120    }
121
122    fn transform_bytes<'a>(&mut self, v: &'a [u8]) -> Cow<'a, [u8]> {
123        Cow::Borrowed(v)
124    }
125
126    fn transform_byte_buf(&mut self, v: Vec<u8>) -> Cow<'static, [u8]> {
127        Cow::Owned(v)
128    }
129}
130
131enum Mut<'a, T> {
132    Owned(T),
133    Borrowed(&'a mut T),
134}
135
136impl<T> Mut<'_, T> {
137    fn as_mut(&mut self) -> &mut T {
138        match self {
139            Self::Owned(ref mut t) => t,
140            Self::Borrowed(t) => t,
141        }
142    }
143}
144
145/// A [`Deserializer`](de::Deserializer) that maps all values through a [`Transform`].
146///
147/// This deserializer wraps another deserializer. Values are transformed inline during
148/// deserialization and passed directly to the `Deserialize` implementation. All errors are passed
149/// through without modification.
150///
151///  # Lifetime
152///
153/// The lifetime parameter is an implementation detail. [`new`](Self::new) returns a transforming
154/// deserializer with static lifetime.
155///
156/// # Example
157///
158/// ```ignore
159/// struct Identity;
160///
161/// let json = "42";
162/// let json_deserializer = &mut serde_json::Deserializer::from_str(&json);
163/// let deserializer = Deserializer::new(json_deserializer, Identity);
164///
165/// let number = deserializer.deserialize_u32(deserializer).unwrap();
166/// assert_eq!(number, 42);
167/// ```
168pub struct Deserializer<'a, D, T> {
169    inner: D,
170    transformer: Mut<'a, T>,
171    is_key: bool,
172}
173
174impl<'de, 'a, D, T> Deserializer<'a, D, T>
175where
176    D: de::Deserializer<'de>,
177    T: Transform<'de>,
178{
179    /// Creates a new `Deserializer`.
180    pub fn new(deserializer: D, transformer: T) -> Self {
181        Self {
182            inner: deserializer,
183            transformer: Mut::Owned(transformer),
184            is_key: false,
185        }
186    }
187
188    fn borrowed(deserializer: D, transformer: &'a mut T) -> Self {
189        Self {
190            inner: deserializer,
191            transformer: Mut::Borrowed(transformer),
192            is_key: false,
193        }
194    }
195
196    fn key(deserializer: D, transformer: &'a mut T) -> Self {
197        Self {
198            inner: deserializer,
199            transformer: Mut::Borrowed(transformer),
200            is_key: true,
201        }
202    }
203}
204
205impl<'de, D, T> de::Deserializer<'de> for Deserializer<'_, D, T>
206where
207    D: de::Deserializer<'de>,
208    T: Transform<'de>,
209{
210    type Error = D::Error;
211
212    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
213    where
214        V: de::Visitor<'de>,
215    {
216        self.inner.deserialize_any(Visitor::new(
217            visitor,
218            self.transformer.as_mut(),
219            self.is_key,
220        ))
221    }
222
223    fn deserialize_bool<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
224    where
225        V: de::Visitor<'de>,
226    {
227        self.inner.deserialize_bool(Visitor::new(
228            visitor,
229            self.transformer.as_mut(),
230            self.is_key,
231        ))
232    }
233
234    fn deserialize_i8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
235    where
236        V: de::Visitor<'de>,
237    {
238        self.inner.deserialize_i8(Visitor::new(
239            visitor,
240            self.transformer.as_mut(),
241            self.is_key,
242        ))
243    }
244
245    fn deserialize_i16<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
246    where
247        V: de::Visitor<'de>,
248    {
249        self.inner.deserialize_i16(Visitor::new(
250            visitor,
251            self.transformer.as_mut(),
252            self.is_key,
253        ))
254    }
255
256    fn deserialize_i32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
257    where
258        V: de::Visitor<'de>,
259    {
260        self.inner.deserialize_i32(Visitor::new(
261            visitor,
262            self.transformer.as_mut(),
263            self.is_key,
264        ))
265    }
266
267    fn deserialize_i64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
268    where
269        V: de::Visitor<'de>,
270    {
271        self.inner.deserialize_i64(Visitor::new(
272            visitor,
273            self.transformer.as_mut(),
274            self.is_key,
275        ))
276    }
277
278    fn deserialize_u8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
279    where
280        V: de::Visitor<'de>,
281    {
282        self.inner.deserialize_u8(Visitor::new(
283            visitor,
284            self.transformer.as_mut(),
285            self.is_key,
286        ))
287    }
288
289    fn deserialize_u16<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
290    where
291        V: de::Visitor<'de>,
292    {
293        self.inner.deserialize_u16(Visitor::new(
294            visitor,
295            self.transformer.as_mut(),
296            self.is_key,
297        ))
298    }
299
300    fn deserialize_u32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
301    where
302        V: de::Visitor<'de>,
303    {
304        self.inner.deserialize_u32(Visitor::new(
305            visitor,
306            self.transformer.as_mut(),
307            self.is_key,
308        ))
309    }
310
311    fn deserialize_u64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
312    where
313        V: de::Visitor<'de>,
314    {
315        self.inner.deserialize_u64(Visitor::new(
316            visitor,
317            self.transformer.as_mut(),
318            self.is_key,
319        ))
320    }
321
322    fn deserialize_i128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
323    where
324        V: de::Visitor<'de>,
325    {
326        self.inner.deserialize_i128(Visitor {
327            inner: visitor,
328            transformer: self.transformer.as_mut(),
329            is_key: self.is_key,
330        })
331    }
332
333    fn deserialize_u128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
334    where
335        V: de::Visitor<'de>,
336    {
337        self.inner.deserialize_u128(Visitor {
338            inner: visitor,
339            transformer: self.transformer.as_mut(),
340            is_key: self.is_key,
341        })
342    }
343
344    fn deserialize_f32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
345    where
346        V: de::Visitor<'de>,
347    {
348        self.inner.deserialize_f32(Visitor::new(
349            visitor,
350            self.transformer.as_mut(),
351            self.is_key,
352        ))
353    }
354
355    fn deserialize_f64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
356    where
357        V: de::Visitor<'de>,
358    {
359        self.inner.deserialize_f64(Visitor::new(
360            visitor,
361            self.transformer.as_mut(),
362            self.is_key,
363        ))
364    }
365
366    fn deserialize_char<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
367    where
368        V: de::Visitor<'de>,
369    {
370        self.inner.deserialize_char(Visitor::new(
371            visitor,
372            self.transformer.as_mut(),
373            self.is_key,
374        ))
375    }
376
377    fn deserialize_str<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
378    where
379        V: de::Visitor<'de>,
380    {
381        self.inner.deserialize_str(Visitor::new(
382            visitor,
383            self.transformer.as_mut(),
384            self.is_key,
385        ))
386    }
387
388    fn deserialize_string<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
389    where
390        V: de::Visitor<'de>,
391    {
392        self.inner.deserialize_string(Visitor::new(
393            visitor,
394            self.transformer.as_mut(),
395            self.is_key,
396        ))
397    }
398
399    fn deserialize_bytes<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
400    where
401        V: de::Visitor<'de>,
402    {
403        self.inner.deserialize_bytes(Visitor::new(
404            visitor,
405            self.transformer.as_mut(),
406            self.is_key,
407        ))
408    }
409
410    fn deserialize_byte_buf<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
411    where
412        V: de::Visitor<'de>,
413    {
414        self.inner.deserialize_byte_buf(Visitor::new(
415            visitor,
416            self.transformer.as_mut(),
417            self.is_key,
418        ))
419    }
420
421    fn deserialize_option<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
422    where
423        V: de::Visitor<'de>,
424    {
425        self.inner.deserialize_option(Visitor::new(
426            visitor,
427            self.transformer.as_mut(),
428            self.is_key,
429        ))
430    }
431
432    fn deserialize_unit<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
433    where
434        V: de::Visitor<'de>,
435    {
436        self.inner.deserialize_unit(Visitor::new(
437            visitor,
438            self.transformer.as_mut(),
439            self.is_key,
440        ))
441    }
442
443    fn deserialize_unit_struct<V>(
444        mut self,
445        name: &'static str,
446        visitor: V,
447    ) -> Result<V::Value, Self::Error>
448    where
449        V: de::Visitor<'de>,
450    {
451        self.inner.deserialize_unit_struct(
452            name,
453            Visitor {
454                inner: visitor,
455                transformer: self.transformer.as_mut(),
456                is_key: self.is_key,
457            },
458        )
459    }
460
461    fn deserialize_newtype_struct<V>(
462        mut self,
463        name: &'static str,
464        visitor: V,
465    ) -> Result<V::Value, Self::Error>
466    where
467        V: de::Visitor<'de>,
468    {
469        self.inner.deserialize_newtype_struct(
470            name,
471            Visitor {
472                inner: visitor,
473                transformer: self.transformer.as_mut(),
474                is_key: self.is_key,
475            },
476        )
477    }
478
479    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
480    where
481        V: de::Visitor<'de>,
482    {
483        self.inner.deserialize_seq(Visitor::new(
484            visitor,
485            self.transformer.as_mut(),
486            self.is_key,
487        ))
488    }
489
490    fn deserialize_tuple<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
491    where
492        V: de::Visitor<'de>,
493    {
494        self.inner.deserialize_tuple(
495            len,
496            Visitor {
497                inner: visitor,
498                transformer: self.transformer.as_mut(),
499                is_key: self.is_key,
500            },
501        )
502    }
503
504    fn deserialize_tuple_struct<V>(
505        mut self,
506        name: &'static str,
507        len: usize,
508        visitor: V,
509    ) -> Result<V::Value, Self::Error>
510    where
511        V: de::Visitor<'de>,
512    {
513        self.inner.deserialize_tuple_struct(
514            name,
515            len,
516            Visitor {
517                inner: visitor,
518                transformer: self.transformer.as_mut(),
519                is_key: self.is_key,
520            },
521        )
522    }
523
524    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
525    where
526        V: de::Visitor<'de>,
527    {
528        self.inner.deserialize_map(Visitor::new(
529            visitor,
530            self.transformer.as_mut(),
531            self.is_key,
532        ))
533    }
534
535    fn deserialize_struct<V>(
536        mut self,
537        name: &'static str,
538        fields: &'static [&'static str],
539        visitor: V,
540    ) -> Result<V::Value, Self::Error>
541    where
542        V: de::Visitor<'de>,
543    {
544        self.inner.deserialize_struct(
545            name,
546            fields,
547            Visitor {
548                inner: visitor,
549                transformer: self.transformer.as_mut(),
550                is_key: self.is_key,
551            },
552        )
553    }
554
555    fn deserialize_enum<V>(
556        mut self,
557        name: &'static str,
558        variants: &'static [&'static str],
559        visitor: V,
560    ) -> Result<V::Value, Self::Error>
561    where
562        V: de::Visitor<'de>,
563    {
564        self.inner.deserialize_enum(
565            name,
566            variants,
567            Visitor {
568                inner: visitor,
569                transformer: self.transformer.as_mut(),
570                is_key: self.is_key,
571            },
572        )
573    }
574
575    fn deserialize_identifier<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
576    where
577        V: de::Visitor<'de>,
578    {
579        self.inner.deserialize_identifier(Visitor {
580            inner: visitor,
581            transformer: self.transformer.as_mut(),
582            is_key: true,
583        })
584    }
585
586    fn deserialize_ignored_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
587    where
588        V: de::Visitor<'de>,
589    {
590        self.inner.deserialize_ignored_any(Visitor::new(
591            visitor,
592            self.transformer.as_mut(),
593            self.is_key,
594        ))
595    }
596}
597
598struct Visitor<'a, V, T> {
599    inner: V,
600    transformer: &'a mut T,
601    is_key: bool,
602}
603
604impl<'a, V, T> Visitor<'a, V, T> {
605    fn new(visitor: V, transformer: &'a mut T, is_key: bool) -> Self {
606        Self {
607            inner: visitor,
608            transformer,
609            is_key,
610        }
611    }
612}
613
614impl<'de, V, T> de::Visitor<'de> for Visitor<'_, V, T>
615where
616    V: de::Visitor<'de>,
617    T: Transform<'de>,
618{
619    type Value = V::Value;
620
621    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
622        write!(fmt, "any value")
623    }
624
625    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
626    where
627        E: de::Error,
628    {
629        self.inner.visit_bool(self.transformer.transform_bool(v))
630    }
631
632    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
633    where
634        E: de::Error,
635    {
636        self.inner.visit_i8(self.transformer.transform_i8(v))
637    }
638
639    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
640    where
641        E: de::Error,
642    {
643        self.inner.visit_i16(self.transformer.transform_i16(v))
644    }
645
646    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
647    where
648        E: de::Error,
649    {
650        self.inner.visit_i32(self.transformer.transform_i32(v))
651    }
652
653    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
654    where
655        E: de::Error,
656    {
657        self.inner.visit_i64(self.transformer.transform_i64(v))
658    }
659
660    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
661    where
662        E: de::Error,
663    {
664        self.inner.visit_u8(self.transformer.transform_u8(v))
665    }
666
667    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
668    where
669        E: de::Error,
670    {
671        self.inner.visit_u16(self.transformer.transform_u16(v))
672    }
673
674    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
675    where
676        E: de::Error,
677    {
678        self.inner.visit_u32(self.transformer.transform_u32(v))
679    }
680
681    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
682    where
683        E: de::Error,
684    {
685        self.inner.visit_u64(self.transformer.transform_u64(v))
686    }
687
688    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
689    where
690        E: de::Error,
691    {
692        self.inner.visit_i128(self.transformer.transform_i128(v))
693    }
694
695    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
696    where
697        E: de::Error,
698    {
699        self.inner.visit_u128(self.transformer.transform_u128(v))
700    }
701
702    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
703    where
704        E: de::Error,
705    {
706        self.inner.visit_f32(self.transformer.transform_f32(v))
707    }
708
709    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
710    where
711        E: de::Error,
712    {
713        self.inner.visit_f64(self.transformer.transform_f64(v))
714    }
715
716    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
717    where
718        E: de::Error,
719    {
720        self.inner.visit_char(self.transformer.transform_char(v))
721    }
722
723    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
724    where
725        E: de::Error,
726    {
727        if self.is_key {
728            self.transformer.push_path(v);
729            return self.inner.visit_borrowed_str(v);
730        };
731
732        let res = match self.transformer.transform_str(v) {
733            Cow::Borrowed(v) => self.inner.visit_borrowed_str(v),
734            Cow::Owned(v) => self.inner.visit_string(v),
735        };
736        res
737    }
738
739    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
740    where
741        E: de::Error,
742    {
743        if self.is_key {
744            return self.inner.visit_str(v);
745        };
746        match self.transformer.transform_str(v) {
747            Cow::Borrowed(v) => self.inner.visit_str(v),
748            Cow::Owned(v) => self.inner.visit_string(v),
749        }
750    }
751
752    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
753    where
754        E: de::Error,
755    {
756        if self.is_key {
757            return self.inner.visit_string(v);
758        };
759        match self.transformer.transform_string(v) {
760            Cow::Borrowed(v) => self.inner.visit_borrowed_str(v),
761            Cow::Owned(v) => self.inner.visit_string(v),
762        }
763    }
764
765    fn visit_unit<E>(self) -> Result<Self::Value, E>
766    where
767        E: de::Error,
768    {
769        self.inner.visit_unit()
770    }
771
772    fn visit_none<E>(self) -> Result<Self::Value, E>
773    where
774        E: de::Error,
775    {
776        self.inner.visit_none()
777    }
778
779    fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
780    where
781        D: de::Deserializer<'de>,
782    {
783        self.inner
784            .visit_some(Deserializer::borrowed(d, self.transformer))
785    }
786
787    fn visit_newtype_struct<D>(self, d: D) -> Result<Self::Value, D::Error>
788    where
789        D: de::Deserializer<'de>,
790    {
791        self.inner
792            .visit_newtype_struct(Deserializer::borrowed(d, self.transformer))
793    }
794
795    fn visit_seq<A>(self, v: A) -> Result<Self::Value, A::Error>
796    where
797        A: de::SeqAccess<'de>,
798    {
799        self.inner.visit_seq(SeqAccess(v, self.transformer))
800    }
801
802    fn visit_map<A>(self, v: A) -> Result<Self::Value, A::Error>
803    where
804        A: de::MapAccess<'de>,
805    {
806        self.inner.visit_map(MapAccess(v, self.transformer))
807    }
808
809    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
810    where
811        E: de::Error,
812    {
813        match self.transformer.transform_bytes(v) {
814            Cow::Borrowed(v) => self.inner.visit_bytes(v),
815            Cow::Owned(v) => self.inner.visit_byte_buf(v),
816        }
817    }
818
819    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
820    where
821        E: de::Error,
822    {
823        match self.transformer.transform_byte_buf(v) {
824            Cow::Borrowed(v) => self.inner.visit_bytes(v),
825            Cow::Owned(v) => self.inner.visit_byte_buf(v),
826        }
827    }
828}
829
830struct SeqAccess<'a, A, T>(A, &'a mut T);
831
832impl<'de, A, T> de::SeqAccess<'de> for SeqAccess<'_, A, T>
833where
834    A: de::SeqAccess<'de>,
835    T: Transform<'de>,
836{
837    type Error = A::Error;
838
839    fn size_hint(&self) -> Option<usize> {
840        self.0.size_hint()
841    }
842
843    fn next_element_seed<S>(&mut self, seed: S) -> Result<Option<S::Value>, Self::Error>
844    where
845        S: de::DeserializeSeed<'de>,
846    {
847        // We want to use a special ValueSeed for sequences that does not call pop_path
848        // because we don't push paths when entering sequences right now.
849        self.0
850            .next_element_seed(DeserializeSeqValueSeed(seed, self.1))
851    }
852}
853
854struct MapAccess<'a, A, T>(A, &'a mut T);
855
856impl<'de, A, T> de::MapAccess<'de> for MapAccess<'_, A, T>
857where
858    A: de::MapAccess<'de>,
859    T: Transform<'de>,
860{
861    type Error = A::Error;
862
863    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
864    where
865        K: de::DeserializeSeed<'de>,
866    {
867        // NOTE: No transform on keys.
868        self.0.next_key_seed(DeserializeKeySeed(seed, self.1))
869    }
870
871    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
872    where
873        V: de::DeserializeSeed<'de>,
874    {
875        self.0.next_value_seed(DeserializeValueSeed(seed, self.1))
876    }
877}
878
879struct DeserializeValueSeed<'a, D, T>(D, &'a mut T);
880
881impl<'de, D, T> de::DeserializeSeed<'de> for DeserializeValueSeed<'_, D, T>
882where
883    D: de::DeserializeSeed<'de>,
884    T: Transform<'de>,
885{
886    type Value = D::Value;
887
888    fn deserialize<X>(self, deserializer: X) -> Result<Self::Value, X::Error>
889    where
890        X: serde::Deserializer<'de>,
891    {
892        let res = self
893            .0
894            .deserialize(Deserializer::borrowed(deserializer, self.1));
895        self.1.pop_path();
896        res
897    }
898}
899
900struct DeserializeSeqValueSeed<'a, D, T>(D, &'a mut T);
901
902impl<'de, D, T> de::DeserializeSeed<'de> for DeserializeSeqValueSeed<'_, D, T>
903where
904    D: de::DeserializeSeed<'de>,
905    T: Transform<'de>,
906{
907    type Value = D::Value;
908
909    fn deserialize<X>(self, deserializer: X) -> Result<Self::Value, X::Error>
910    where
911        X: serde::Deserializer<'de>,
912    {
913        self.0
914            .deserialize(Deserializer::borrowed(deserializer, self.1))
915    }
916}
917
918struct DeserializeKeySeed<'a, D, T>(D, &'a mut T);
919
920impl<'de, D, T> de::DeserializeSeed<'de> for DeserializeKeySeed<'_, D, T>
921where
922    D: de::DeserializeSeed<'de>,
923    T: Transform<'de>,
924{
925    type Value = D::Value;
926
927    fn deserialize<X>(self, deserializer: X) -> Result<Self::Value, X::Error>
928    where
929        X: serde::Deserializer<'de>,
930    {
931        self.0.deserialize(Deserializer::key(deserializer, self.1))
932    }
933}
relay_pii/transform.rs

relay_pii/
transform.rs
