1use std::borrow::Cow;
4use std::fmt;
5
6use serde::de;
7
8#[allow(missing_docs)]
53pub trait Transform<'de> {
54 fn push_path(&mut self, _key: &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(t) => t,
140 Self::Borrowed(t) => t,
141 }
142 }
143}
144
145pub 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 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 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 }
737
738 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
739 where
740 E: de::Error,
741 {
742 if self.is_key {
743 self.transformer.push_path(v);
746 return self.inner.visit_str(v);
747 };
748 match self.transformer.transform_str(v) {
749 Cow::Borrowed(v) => self.inner.visit_str(v),
750 Cow::Owned(v) => self.inner.visit_string(v),
751 }
752 }
753
754 fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
755 where
756 E: de::Error,
757 {
758 if self.is_key {
759 self.transformer.push_path(&v);
760 return self.inner.visit_string(v);
761 };
762 match self.transformer.transform_string(v) {
763 Cow::Borrowed(v) => self.inner.visit_borrowed_str(v),
764 Cow::Owned(v) => self.inner.visit_string(v),
765 }
766 }
767
768 fn visit_unit<E>(self) -> Result<Self::Value, E>
769 where
770 E: de::Error,
771 {
772 self.inner.visit_unit()
773 }
774
775 fn visit_none<E>(self) -> Result<Self::Value, E>
776 where
777 E: de::Error,
778 {
779 self.inner.visit_none()
780 }
781
782 fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
783 where
784 D: de::Deserializer<'de>,
785 {
786 self.inner
787 .visit_some(Deserializer::borrowed(d, self.transformer))
788 }
789
790 fn visit_newtype_struct<D>(self, d: D) -> Result<Self::Value, D::Error>
791 where
792 D: de::Deserializer<'de>,
793 {
794 self.inner
795 .visit_newtype_struct(Deserializer::borrowed(d, self.transformer))
796 }
797
798 fn visit_seq<A>(self, v: A) -> Result<Self::Value, A::Error>
799 where
800 A: de::SeqAccess<'de>,
801 {
802 self.inner.visit_seq(SeqAccess(v, self.transformer))
803 }
804
805 fn visit_map<A>(self, v: A) -> Result<Self::Value, A::Error>
806 where
807 A: de::MapAccess<'de>,
808 {
809 self.inner.visit_map(MapAccess(v, self.transformer))
810 }
811
812 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
813 where
814 E: de::Error,
815 {
816 match self.transformer.transform_bytes(v) {
817 Cow::Borrowed(v) => self.inner.visit_bytes(v),
818 Cow::Owned(v) => self.inner.visit_byte_buf(v),
819 }
820 }
821
822 fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
823 where
824 E: de::Error,
825 {
826 match self.transformer.transform_byte_buf(v) {
827 Cow::Borrowed(v) => self.inner.visit_bytes(v),
828 Cow::Owned(v) => self.inner.visit_byte_buf(v),
829 }
830 }
831}
832
833struct SeqAccess<'a, A, T>(A, &'a mut T);
834
835impl<'de, A, T> de::SeqAccess<'de> for SeqAccess<'_, A, T>
836where
837 A: de::SeqAccess<'de>,
838 T: Transform<'de>,
839{
840 type Error = A::Error;
841
842 fn size_hint(&self) -> Option<usize> {
843 self.0.size_hint()
844 }
845
846 fn next_element_seed<S>(&mut self, seed: S) -> Result<Option<S::Value>, Self::Error>
847 where
848 S: de::DeserializeSeed<'de>,
849 {
850 self.0
853 .next_element_seed(DeserializeSeqValueSeed(seed, self.1))
854 }
855}
856
857struct MapAccess<'a, A, T>(A, &'a mut T);
858
859impl<'de, A, T> de::MapAccess<'de> for MapAccess<'_, A, T>
860where
861 A: de::MapAccess<'de>,
862 T: Transform<'de>,
863{
864 type Error = A::Error;
865
866 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
867 where
868 K: de::DeserializeSeed<'de>,
869 {
870 self.0.next_key_seed(DeserializeKeySeed(seed, self.1))
872 }
873
874 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
875 where
876 V: de::DeserializeSeed<'de>,
877 {
878 self.0.next_value_seed(DeserializeValueSeed(seed, self.1))
879 }
880}
881
882struct DeserializeValueSeed<'a, D, T>(D, &'a mut T);
883
884impl<'de, D, T> de::DeserializeSeed<'de> for DeserializeValueSeed<'_, D, T>
885where
886 D: de::DeserializeSeed<'de>,
887 T: Transform<'de>,
888{
889 type Value = D::Value;
890
891 fn deserialize<X>(self, deserializer: X) -> Result<Self::Value, X::Error>
892 where
893 X: serde::Deserializer<'de>,
894 {
895 let res = self
896 .0
897 .deserialize(Deserializer::borrowed(deserializer, self.1));
898 self.1.pop_path();
902 res
903 }
904}
905
906struct DeserializeSeqValueSeed<'a, D, T>(D, &'a mut T);
907
908impl<'de, D, T> de::DeserializeSeed<'de> for DeserializeSeqValueSeed<'_, D, T>
909where
910 D: de::DeserializeSeed<'de>,
911 T: Transform<'de>,
912{
913 type Value = D::Value;
914
915 fn deserialize<X>(self, deserializer: X) -> Result<Self::Value, X::Error>
916 where
917 X: serde::Deserializer<'de>,
918 {
919 self.0
920 .deserialize(Deserializer::borrowed(deserializer, self.1))
921 }
922}
923
924struct DeserializeKeySeed<'a, D, T>(D, &'a mut T);
925
926impl<'de, D, T> de::DeserializeSeed<'de> for DeserializeKeySeed<'_, D, T>
927where
928 D: de::DeserializeSeed<'de>,
929 T: Transform<'de>,
930{
931 type Value = D::Value;
932
933 fn deserialize<X>(self, deserializer: X) -> Result<Self::Value, X::Error>
934 where
935 X: serde::Deserializer<'de>,
936 {
937 self.0.deserialize(Deserializer::key(deserializer, self.1))
938 }
939}