serde_path_to_error/
ser.rs

Help
1use crate::wrap::Wrap;
2use crate::{Chain, Error, Track};
3use serde::ser::{self, Serialize};
4use serde::serde_if_integer128;
5use std::cell::Cell;
6use std::fmt::Display;
7
8/// Entry point for tracking path to Serialize error.
9///
10/// # Example
11///
12/// ```
13/// # use serde_derive::Serialize;
14/// #
15/// use serde::Serialize;
16/// use std::cell::RefCell;
17///
18/// #[derive(Serialize)]
19/// struct Outer<'a> {
20///     k: Inner<'a>,
21/// }
22///
23/// #[derive(Serialize)]
24/// struct Inner<'a> {
25///     refcell: &'a RefCell<String>,
26/// }
27///
28/// let refcell = RefCell::new(String::new());
29/// let value = Outer {
30///     k: Inner { refcell: &refcell },
31/// };
32///
33/// // A RefCell cannot be serialized while it is still mutably borrowed.
34/// let _borrowed = refcell.borrow_mut();
35///
36/// // Some Serializer.
37/// let mut out = Vec::new();
38/// let jser = &mut serde_json::Serializer::new(&mut out);
39///
40/// let result = serde_path_to_error::serialize(&value, jser);
41/// match result {
42///     Ok(_) => panic!("expected failure to serialize RefCell"),
43///     Err(err) => {
44///         let path = err.path().to_string();
45///         assert_eq!(path, "k.refcell");
46///     }
47/// }
48/// ```
49pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, Error<S::Error>>
50where
51    T: ?Sized + Serialize,
52    S: ser::Serializer,
53{
54    let mut track = Track::new();
55    match T::serialize(value, Serializer::new(serializer, &mut track)) {
56        Ok(ok) => Ok(ok),
57        Err(err) => Err(Error {
58            path: track.path(),
59            original: err,
60        }),
61    }
62}
63
64/// Serializer adapter that records path to serialization errors.
65///
66/// # Example
67///
68/// ```
69/// # use serde_derive::Serialize;
70/// #
71/// use serde::Serialize;
72/// use std::collections::BTreeMap;
73///
74/// // Maps with a non-string key are not valid in JSON.
75/// let mut inner_map = BTreeMap::new();
76/// inner_map.insert(vec!['w', 'a', 't'], 0);
77///
78/// let mut outer_map = BTreeMap::new();
79/// outer_map.insert("k", inner_map);
80///
81/// // Some Serializer.
82/// let mut out = Vec::new();
83/// let jser = &mut serde_json::Serializer::new(&mut out);
84///
85/// let mut track = serde_path_to_error::Track::new();
86/// let ps = serde_path_to_error::Serializer::new(jser, &mut track);
87///
88/// match outer_map.serialize(ps) {
89///     Ok(_) => panic!("expected failure to serialize non-string key"),
90///     Err(_) => {
91///         let path = track.path().to_string();
92///         assert_eq!(path, "k");
93///     }
94/// }
95/// ```
96pub struct Serializer<'a, 'b, S> {
97    ser: S,
98    chain: &'a Chain<'a>,
99    track: &'b Track,
100}
101
102impl<'a, 'b, S> Serializer<'a, 'b, S> {
103    pub fn new(ser: S, track: &'b mut Track) -> Self {
104        Serializer {
105            ser,
106            chain: &Chain::Root,
107            track,
108        }
109    }
110}
111
112impl<'a, 'b, S> ser::Serializer for Serializer<'a, 'b, S>
113where
114    S: ser::Serializer,
115{
116    type Ok = S::Ok;
117    type Error = S::Error;
118    type SerializeSeq = WrapSeq<'a, 'b, S::SerializeSeq>;
119    type SerializeTuple = WrapSeq<'a, 'b, S::SerializeTuple>;
120    type SerializeTupleStruct = WrapSeq<'a, 'b, S::SerializeTupleStruct>;
121    type SerializeTupleVariant = WrapSeq<'a, 'b, S::SerializeTupleVariant>;
122    type SerializeMap = WrapMap<'a, 'b, S::SerializeMap>;
123    type SerializeStruct = Wrap<'a, 'b, S::SerializeStruct>;
124    type SerializeStructVariant = Wrap<'a, 'b, S::SerializeStructVariant>;
125
126    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
127        let chain = self.chain;
128        let track = self.track;
129        self.ser
130            .serialize_bool(v)
131            .map_err(|err| track.trigger(chain, err))
132    }
133
134    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
135        let chain = self.chain;
136        let track = self.track;
137        self.ser
138            .serialize_i8(v)
139            .map_err(|err| track.trigger(chain, err))
140    }
141
142    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
143        let chain = self.chain;
144        let track = self.track;
145        self.ser
146            .serialize_i16(v)
147            .map_err(|err| track.trigger(chain, err))
148    }
149
150    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
151        let chain = self.chain;
152        let track = self.track;
153        self.ser
154            .serialize_i32(v)
155            .map_err(|err| track.trigger(chain, err))
156    }
157
158    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
159        let chain = self.chain;
160        let track = self.track;
161        self.ser
162            .serialize_i64(v)
163            .map_err(|err| track.trigger(chain, err))
164    }
165
166    serde_if_integer128! {
167        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
168            let chain = self.chain;
169            let track = self.track;
170            self.ser
171                .serialize_i128(v)
172                .map_err(|err| track.trigger(chain, err))
173        }
174    }
175
176    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
177        let chain = self.chain;
178        let track = self.track;
179        self.ser
180            .serialize_u8(v)
181            .map_err(|err| track.trigger(chain, err))
182    }
183
184    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
185        let chain = self.chain;
186        let track = self.track;
187        self.ser
188            .serialize_u16(v)
189            .map_err(|err| track.trigger(chain, err))
190    }
191
192    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
193        let chain = self.chain;
194        let track = self.track;
195        self.ser
196            .serialize_u32(v)
197            .map_err(|err| track.trigger(chain, err))
198    }
199
200    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
201        let chain = self.chain;
202        let track = self.track;
203        self.ser
204            .serialize_u64(v)
205            .map_err(|err| track.trigger(chain, err))
206    }
207
208    serde_if_integer128! {
209        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
210            let chain = self.chain;
211            let track = self.track;
212            self.ser
213                .serialize_u128(v)
214                .map_err(|err| track.trigger(chain, err))
215        }
216    }
217
218    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
219        let chain = self.chain;
220        let track = self.track;
221        self.ser
222            .serialize_f32(v)
223            .map_err(|err| track.trigger(chain, err))
224    }
225
226    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
227        let chain = self.chain;
228        let track = self.track;
229        self.ser
230            .serialize_f64(v)
231            .map_err(|err| track.trigger(chain, err))
232    }
233
234    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
235        let chain = self.chain;
236        let track = self.track;
237        self.ser
238            .serialize_char(v)
239            .map_err(|err| track.trigger(chain, err))
240    }
241
242    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
243        let chain = self.chain;
244        let track = self.track;
245        self.ser
246            .serialize_str(v)
247            .map_err(|err| track.trigger(chain, err))
248    }
249
250    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
251        let chain = self.chain;
252        let track = self.track;
253        self.ser
254            .serialize_bytes(v)
255            .map_err(|err| track.trigger(chain, err))
256    }
257
258    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
259        let chain = self.chain;
260        let track = self.track;
261        self.ser
262            .serialize_none()
263            .map_err(|err| track.trigger(chain, err))
264    }
265
266    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
267    where
268        T: ?Sized + Serialize,
269    {
270        let chain = self.chain;
271        let track = self.track;
272        self.ser
273            .serialize_some(value)
274            .map_err(|err| track.trigger(chain, err))
275    }
276
277    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
278        let chain = self.chain;
279        let track = self.track;
280        self.ser
281            .serialize_unit()
282            .map_err(|err| track.trigger(chain, err))
283    }
284
285    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
286        let chain = self.chain;
287        let track = self.track;
288        self.ser
289            .serialize_unit_struct(name)
290            .map_err(|err| track.trigger(chain, err))
291    }
292
293    fn serialize_unit_variant(
294        self,
295        name: &'static str,
296        variant_index: u32,
297        variant: &'static str,
298    ) -> Result<Self::Ok, Self::Error> {
299        let chain = self.chain;
300        let track = self.track;
301        self.ser
302            .serialize_unit_variant(name, variant_index, variant)
303            .map_err(|err| track.trigger(chain, err))
304    }
305
306    fn serialize_newtype_struct<T>(
307        self,
308        name: &'static str,
309        value: &T,
310    ) -> Result<Self::Ok, Self::Error>
311    where
312        T: ?Sized + Serialize,
313    {
314        let chain = self.chain;
315        let track = self.track;
316        self.ser
317            .serialize_newtype_struct(name, value)
318            .map_err(|err| track.trigger(chain, err))
319    }
320
321    fn serialize_newtype_variant<T>(
322        self,
323        name: &'static str,
324        variant_index: u32,
325        variant: &'static str,
326        value: &T,
327    ) -> Result<Self::Ok, Self::Error>
328    where
329        T: ?Sized + Serialize,
330    {
331        let chain = self.chain;
332        let track = self.track;
333        self.ser
334            .serialize_newtype_variant(name, variant_index, variant, value)
335            .map_err(|err| track.trigger(chain, err))
336    }
337
338    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
339        let chain = self.chain;
340        let track = self.track;
341        match self.ser.serialize_seq(len) {
342            Ok(delegate) => Ok(WrapSeq::new(delegate, chain, track)),
343            Err(err) => Err(track.trigger(chain, err)),
344        }
345    }
346
347    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
348        let chain = self.chain;
349        let track = self.track;
350        match self.ser.serialize_tuple(len) {
351            Ok(delegate) => Ok(WrapSeq::new(delegate, chain, track)),
352            Err(err) => Err(track.trigger(chain, err)),
353        }
354    }
355
356    fn serialize_tuple_struct(
357        self,
358        name: &'static str,
359        len: usize,
360    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
361        let chain = self.chain;
362        let track = self.track;
363        match self.ser.serialize_tuple_struct(name, len) {
364            Ok(delegate) => Ok(WrapSeq::new(delegate, chain, track)),
365            Err(err) => Err(track.trigger(chain, err)),
366        }
367    }
368
369    fn serialize_tuple_variant(
370        self,
371        name: &'static str,
372        variant_index: u32,
373        variant: &'static str,
374        len: usize,
375    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
376        let chain = self.chain;
377        let track = self.track;
378        match self
379            .ser
380            .serialize_tuple_variant(name, variant_index, variant, len)
381        {
382            Ok(delegate) => Ok(WrapSeq::new(delegate, chain, track)),
383            Err(err) => Err(track.trigger(chain, err)),
384        }
385    }
386
387    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
388        let chain = self.chain;
389        let track = self.track;
390        match self.ser.serialize_map(len) {
391            Ok(delegate) => Ok(WrapMap::new(delegate, chain, track)),
392            Err(err) => Err(track.trigger(chain, err)),
393        }
394    }
395
396    fn serialize_struct(
397        self,
398        name: &'static str,
399        len: usize,
400    ) -> Result<Self::SerializeStruct, Self::Error> {
401        let chain = self.chain;
402        let track = self.track;
403        match self.ser.serialize_struct(name, len) {
404            Ok(delegate) => Ok(Wrap::new(delegate, chain, track)),
405            Err(err) => Err(track.trigger(chain, err)),
406        }
407    }
408
409    fn serialize_struct_variant(
410        self,
411        name: &'static str,
412        variant_index: u32,
413        variant: &'static str,
414        len: usize,
415    ) -> Result<Self::SerializeStructVariant, Self::Error> {
416        let chain = self.chain;
417        let track = self.track;
418        match self
419            .ser
420            .serialize_struct_variant(name, variant_index, variant, len)
421        {
422            Ok(delegate) => Ok(Wrap::new(delegate, chain, track)),
423            Err(err) => Err(track.trigger(chain, err)),
424        }
425    }
426
427    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
428    where
429        T: ?Sized + Display,
430    {
431        let chain = self.chain;
432        let track = self.track;
433        self.ser
434            .collect_str(value)
435            .map_err(|err| track.trigger(chain, err))
436    }
437
438    fn is_human_readable(&self) -> bool {
439        self.ser.is_human_readable()
440    }
441}
442
443struct TrackedValue<'a, 'b, X> {
444    value: X,
445    chain: &'a Chain<'a>,
446    track: &'b Track,
447}
448
449impl<'a, 'b, X> TrackedValue<'a, 'b, X> {
450    fn new(value: X, chain: &'a Chain<'a>, track: &'b Track) -> Self {
451        TrackedValue {
452            value,
453            chain,
454            track,
455        }
456    }
457}
458
459impl<'a, 'b, X> Serialize for TrackedValue<'a, 'b, X>
460where
461    X: Serialize,
462{
463    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
464    where
465        S: ser::Serializer,
466    {
467        let chain = self.chain;
468        let track = self.track;
469        self.value
470            .serialize(Serializer {
471                ser: serializer,
472                chain,
473                track,
474            })
475            .map_err(|err| track.trigger(chain, err))
476    }
477}
478
479pub struct WrapSeq<'a, 'b, S> {
480    delegate: S,
481    chain: &'a Chain<'a>,
482    index: usize,
483    track: &'b Track,
484}
485
486impl<'a, 'b, S> WrapSeq<'a, 'b, S> {
487    fn new(delegate: S, chain: &'a Chain<'a>, track: &'b Track) -> Self {
488        WrapSeq {
489            delegate,
490            chain,
491            index: 0,
492            track,
493        }
494    }
495}
496
497impl<'a, 'b, S> ser::SerializeSeq for WrapSeq<'a, 'b, S>
498where
499    S: ser::SerializeSeq,
500{
501    type Ok = S::Ok;
502    type Error = S::Error;
503
504    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
505    where
506        T: ?Sized + Serialize,
507    {
508        let parent = self.chain;
509        let chain = Chain::Seq {
510            parent,
511            index: self.index,
512        };
513        let track = self.track;
514        self.index += 1;
515        self.delegate
516            .serialize_element(&TrackedValue::new(value, &chain, track))
517            .map_err(|err| track.trigger(parent, err))
518    }
519
520    fn end(self) -> Result<Self::Ok, Self::Error> {
521        let chain = self.chain;
522        let track = self.track;
523        self.delegate.end().map_err(|err| track.trigger(chain, err))
524    }
525}
526
527impl<'a, 'b, S> ser::SerializeTuple for WrapSeq<'a, 'b, S>
528where
529    S: ser::SerializeTuple,
530{
531    type Ok = S::Ok;
532    type Error = S::Error;
533
534    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
535    where
536        T: ?Sized + Serialize,
537    {
538        let parent = self.chain;
539        let chain = Chain::Seq {
540            parent,
541            index: self.index,
542        };
543        let track = self.track;
544        self.index += 1;
545        self.delegate
546            .serialize_element(&TrackedValue::new(value, &chain, track))
547            .map_err(|err| track.trigger(parent, err))
548    }
549
550    fn end(self) -> Result<Self::Ok, Self::Error> {
551        let chain = self.chain;
552        let track = self.track;
553        self.delegate.end().map_err(|err| track.trigger(chain, err))
554    }
555}
556
557impl<'a, 'b, S> ser::SerializeTupleStruct for WrapSeq<'a, 'b, S>
558where
559    S: ser::SerializeTupleStruct,
560{
561    type Ok = S::Ok;
562    type Error = S::Error;
563
564    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
565    where
566        T: ?Sized + Serialize,
567    {
568        let parent = self.chain;
569        let chain = Chain::Seq {
570            parent,
571            index: self.index,
572        };
573        let track = self.track;
574        self.index += 1;
575        self.delegate
576            .serialize_field(&TrackedValue::new(value, &chain, track))
577            .map_err(|err| track.trigger(parent, err))
578    }
579
580    fn end(self) -> Result<Self::Ok, Self::Error> {
581        let chain = self.chain;
582        let track = self.track;
583        self.delegate.end().map_err(|err| track.trigger(chain, err))
584    }
585}
586
587impl<'a, 'b, S> ser::SerializeTupleVariant for WrapSeq<'a, 'b, S>
588where
589    S: ser::SerializeTupleVariant,
590{
591    type Ok = S::Ok;
592    type Error = S::Error;
593
594    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
595    where
596        T: ?Sized + Serialize,
597    {
598        let parent = self.chain;
599        let chain = Chain::Seq {
600            parent,
601            index: self.index,
602        };
603        let track = self.track;
604        self.index += 1;
605        self.delegate
606            .serialize_field(&TrackedValue::new(value, &chain, track))
607            .map_err(|err| track.trigger(parent, err))
608    }
609
610    fn end(self) -> Result<Self::Ok, Self::Error> {
611        let chain = self.chain;
612        let track = self.track;
613        self.delegate.end().map_err(|err| track.trigger(chain, err))
614    }
615}
616
617pub struct WrapMap<'a, 'b, S> {
618    delegate: S,
619    chain: &'a Chain<'a>,
620    key: Cell<Option<String>>,
621    track: &'b Track,
622}
623
624impl<'a, 'b, S> WrapMap<'a, 'b, S> {
625    fn new(delegate: S, chain: &'a Chain<'a>, track: &'b Track) -> Self {
626        WrapMap {
627            delegate,
628            chain,
629            key: Cell::new(None),
630            track,
631        }
632    }
633}
634
635impl<'a, 'b, S> ser::SerializeMap for WrapMap<'a, 'b, S>
636where
637    S: ser::SerializeMap,
638{
639    type Ok = S::Ok;
640    type Error = S::Error;
641
642    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
643    where
644        T: ?Sized + Serialize,
645    {
646        let chain = self.chain;
647        let track = self.track;
648        self.key.set(None);
649        self.delegate
650            .serialize_key(&CaptureKey::new(&self.key, key))
651            .map_err(|err| track.trigger(chain, err))
652    }
653
654    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
655    where
656        T: ?Sized + Serialize,
657    {
658        let parent = self.chain;
659        let chain = match self.key.take() {
660            Some(key) => Chain::Map { parent, key },
661            None => Chain::NonStringKey { parent },
662        };
663        let track = self.track;
664        self.delegate
665            .serialize_value(&TrackedValue::new(value, &chain, track))
666            .map_err(|err| track.trigger(parent, err))
667    }
668
669    fn end(self) -> Result<Self::Ok, Self::Error> {
670        let chain = self.chain;
671        let track = self.track;
672        self.delegate.end().map_err(|err| track.trigger(chain, err))
673    }
674}
675
676impl<'a, 'b, S> ser::SerializeStruct for Wrap<'a, 'b, S>
677where
678    S: ser::SerializeStruct,
679{
680    type Ok = S::Ok;
681    type Error = S::Error;
682
683    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
684    where
685        T: ?Sized + Serialize,
686    {
687        let parent = self.chain;
688        let chain = Chain::Struct { parent, key };
689        let track = self.track;
690        self.delegate
691            .serialize_field(key, &TrackedValue::new(value, &chain, track))
692            .map_err(|err| track.trigger(parent, err))
693    }
694
695    fn end(self) -> Result<Self::Ok, Self::Error> {
696        let chain = self.chain;
697        let track = self.track;
698        self.delegate.end().map_err(|err| track.trigger(chain, err))
699    }
700
701    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
702        let chain = self.chain;
703        let track = self.track;
704        self.delegate
705            .skip_field(key)
706            .map_err(|err| track.trigger(chain, err))
707    }
708}
709
710impl<'a, 'b, S> ser::SerializeStructVariant for Wrap<'a, 'b, S>
711where
712    S: ser::SerializeStructVariant,
713{
714    type Ok = S::Ok;
715    type Error = S::Error;
716
717    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
718    where
719        T: ?Sized + Serialize,
720    {
721        let parent = self.chain;
722        let chain = Chain::Struct { parent, key };
723        let track = self.track;
724        self.delegate
725            .serialize_field(key, &TrackedValue::new(value, &chain, track))
726            .map_err(|err| track.trigger(parent, err))
727    }
728
729    fn end(self) -> Result<Self::Ok, Self::Error> {
730        let chain = self.chain;
731        let track = self.track;
732        self.delegate.end().map_err(|err| track.trigger(chain, err))
733    }
734
735    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
736        let chain = self.chain;
737        let track = self.track;
738        self.delegate
739            .skip_field(key)
740            .map_err(|err| track.trigger(chain, err))
741    }
742}
743
744struct CaptureKey<'a, T> {
745    out: &'a Cell<Option<String>>,
746    delegate: T,
747}
748
749impl<'a, T> CaptureKey<'a, T> {
750    fn new(out: &'a Cell<Option<String>>, delegate: T) -> Self {
751        CaptureKey { out, delegate }
752    }
753}
754
755impl<'a, T> Serialize for CaptureKey<'a, T>
756where
757    T: Serialize,
758{
759    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
760    where
761        S: ser::Serializer,
762    {
763        self.delegate
764            .serialize(CaptureKey::new(self.out, serializer))
765    }
766}
767
768impl<'a, S> ser::Serializer for CaptureKey<'a, S>
769where
770    S: ser::Serializer,
771{
772    type Ok = S::Ok;
773    type Error = S::Error;
774    type SerializeSeq = S::SerializeSeq;
775    type SerializeTuple = S::SerializeTuple;
776    type SerializeTupleStruct = S::SerializeTupleStruct;
777    type SerializeTupleVariant = S::SerializeTupleVariant;
778    type SerializeMap = S::SerializeMap;
779    type SerializeStruct = S::SerializeStruct;
780    type SerializeStructVariant = S::SerializeStructVariant;
781
782    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
783        self.out.set(Some(v.to_string()));
784        self.delegate.serialize_bool(v)
785    }
786
787    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
788        self.out.set(Some(v.to_string()));
789        self.delegate.serialize_i8(v)
790    }
791
792    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
793        self.out.set(Some(v.to_string()));
794        self.delegate.serialize_i16(v)
795    }
796
797    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
798        self.out.set(Some(v.to_string()));
799        self.delegate.serialize_i32(v)
800    }
801
802    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
803        self.out.set(Some(v.to_string()));
804        self.delegate.serialize_i64(v)
805    }
806
807    serde_if_integer128! {
808        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
809            self.out.set(Some(v.to_string()));
810            self.delegate.serialize_i128(v)
811        }
812    }
813
814    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
815        self.out.set(Some(v.to_string()));
816        self.delegate.serialize_u8(v)
817    }
818
819    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
820        self.out.set(Some(v.to_string()));
821        self.delegate.serialize_u16(v)
822    }
823
824    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
825        self.out.set(Some(v.to_string()));
826        self.delegate.serialize_u32(v)
827    }
828
829    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
830        self.out.set(Some(v.to_string()));
831        self.delegate.serialize_u64(v)
832    }
833
834    serde_if_integer128! {
835        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
836            self.out.set(Some(v.to_string()));
837            self.delegate.serialize_u128(v)
838        }
839    }
840
841    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
842        self.delegate.serialize_f32(v)
843    }
844
845    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
846        self.delegate.serialize_f64(v)
847    }
848
849    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
850        self.delegate.serialize_char(v)
851    }
852
853    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
854        self.out.set(Some(v.to_owned()));
855        self.delegate.serialize_str(v)
856    }
857
858    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
859        self.delegate.serialize_bytes(v)
860    }
861
862    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
863        self.delegate.serialize_none()
864    }
865
866    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
867    where
868        T: ?Sized + Serialize,
869    {
870        self.delegate
871            .serialize_some(&CaptureKey::new(self.out, value))
872    }
873
874    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
875        self.delegate.serialize_unit()
876    }
877
878    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
879        self.delegate.serialize_unit_struct(name)
880    }
881
882    fn serialize_unit_variant(
883        self,
884        name: &'static str,
885        variant_index: u32,
886        variant: &'static str,
887    ) -> Result<Self::Ok, Self::Error> {
888        self.out.set(Some(variant.to_owned()));
889        self.delegate
890            .serialize_unit_variant(name, variant_index, variant)
891    }
892
893    fn serialize_newtype_struct<T>(
894        self,
895        name: &'static str,
896        value: &T,
897    ) -> Result<Self::Ok, Self::Error>
898    where
899        T: ?Sized + Serialize,
900    {
901        self.delegate
902            .serialize_newtype_struct(name, &CaptureKey::new(self.out, value))
903    }
904
905    fn serialize_newtype_variant<T>(
906        self,
907        name: &'static str,
908        variant_index: u32,
909        variant: &'static str,
910        value: &T,
911    ) -> Result<Self::Ok, Self::Error>
912    where
913        T: ?Sized + Serialize,
914    {
915        self.delegate
916            .serialize_newtype_variant(name, variant_index, variant, value)
917    }
918
919    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
920        self.delegate.serialize_seq(len)
921    }
922
923    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
924        self.delegate.serialize_tuple(len)
925    }
926
927    fn serialize_tuple_struct(
928        self,
929        name: &'static str,
930        len: usize,
931    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
932        self.delegate.serialize_tuple_struct(name, len)
933    }
934
935    fn serialize_tuple_variant(
936        self,
937        name: &'static str,
938        variant_index: u32,
939        variant: &'static str,
940        len: usize,
941    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
942        self.delegate
943            .serialize_tuple_variant(name, variant_index, variant, len)
944    }
945
946    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
947        self.delegate.serialize_map(len)
948    }
949
950    fn serialize_struct(
951        self,
952        name: &'static str,
953        len: usize,
954    ) -> Result<Self::SerializeStruct, Self::Error> {
955        self.delegate.serialize_struct(name, len)
956    }
957
958    fn serialize_struct_variant(
959        self,
960        name: &'static str,
961        variant_index: u32,
962        variant: &'static str,
963        len: usize,
964    ) -> Result<Self::SerializeStructVariant, Self::Error> {
965        self.delegate
966            .serialize_struct_variant(name, variant_index, variant, len)
967    }
968
969    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
970    where
971        I: IntoIterator,
972        I::Item: Serialize,
973    {
974        self.delegate.collect_seq(iter)
975    }
976
977    fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
978    where
979        K: Serialize,
980        V: Serialize,
981        I: IntoIterator<Item = (K, V)>,
982    {
983        self.delegate.collect_map(iter)
984    }
985
986    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
987    where
988        T: ?Sized + Display,
989    {
990        self.out.set(Some(value.to_string()));
991        self.delegate.collect_str(value)
992    }
993
994    fn is_human_readable(&self) -> bool {
995        self.delegate.is_human_readable()
996    }
997}
serde_path_to_error/ser.rs

serde_path_to_error/
ser.rs
