serde_path_to_error/
ser.rs

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

serde_path_to_error/
ser.rs
