serde_path_to_error/
ser.rs

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

serde_path_to_error/
ser.rs
