serde_json/
ser.rs

Help
1//! Serialize a Rust data structure into JSON data.
2
3use crate::error::{Error, ErrorCode, Result};
4use crate::io;
5use alloc::string::{String, ToString};
6use alloc::vec::Vec;
7use core::fmt::{self, Display};
8use core::num::FpCategory;
9use serde::ser::{self, Impossible, Serialize};
10
11/// A structure for serializing Rust values into JSON.
12#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
13pub struct Serializer<W, F = CompactFormatter> {
14    writer: W,
15    formatter: F,
16}
17
18impl<W> Serializer<W>
19where
20    W: io::Write,
21{
22    /// Creates a new JSON serializer.
23    #[inline]
24    pub fn new(writer: W) -> Self {
25        Serializer::with_formatter(writer, CompactFormatter)
26    }
27}
28
29impl<'a, W> Serializer<W, PrettyFormatter<'a>>
30where
31    W: io::Write,
32{
33    /// Creates a new JSON pretty print serializer.
34    #[inline]
35    pub fn pretty(writer: W) -> Self {
36        Serializer::with_formatter(writer, PrettyFormatter::new())
37    }
38}
39
40impl<W, F> Serializer<W, F>
41where
42    W: io::Write,
43    F: Formatter,
44{
45    /// Creates a new JSON visitor whose output will be written to the writer
46    /// specified.
47    #[inline]
48    pub fn with_formatter(writer: W, formatter: F) -> Self {
49        Serializer { writer, formatter }
50    }
51
52    /// Unwrap the `Writer` from the `Serializer`.
53    #[inline]
54    pub fn into_inner(self) -> W {
55        self.writer
56    }
57}
58
59impl<'a, W, F> ser::Serializer for &'a mut Serializer<W, F>
60where
61    W: io::Write,
62    F: Formatter,
63{
64    type Ok = ();
65    type Error = Error;
66
67    type SerializeSeq = Compound<'a, W, F>;
68    type SerializeTuple = Compound<'a, W, F>;
69    type SerializeTupleStruct = Compound<'a, W, F>;
70    type SerializeTupleVariant = Compound<'a, W, F>;
71    type SerializeMap = Compound<'a, W, F>;
72    type SerializeStruct = Compound<'a, W, F>;
73    type SerializeStructVariant = Compound<'a, W, F>;
74
75    #[inline]
76    fn serialize_bool(self, value: bool) -> Result<()> {
77        self.formatter
78            .write_bool(&mut self.writer, value)
79            .map_err(Error::io)
80    }
81
82    #[inline]
83    fn serialize_i8(self, value: i8) -> Result<()> {
84        self.formatter
85            .write_i8(&mut self.writer, value)
86            .map_err(Error::io)
87    }
88
89    #[inline]
90    fn serialize_i16(self, value: i16) -> Result<()> {
91        self.formatter
92            .write_i16(&mut self.writer, value)
93            .map_err(Error::io)
94    }
95
96    #[inline]
97    fn serialize_i32(self, value: i32) -> Result<()> {
98        self.formatter
99            .write_i32(&mut self.writer, value)
100            .map_err(Error::io)
101    }
102
103    #[inline]
104    fn serialize_i64(self, value: i64) -> Result<()> {
105        self.formatter
106            .write_i64(&mut self.writer, value)
107            .map_err(Error::io)
108    }
109
110    fn serialize_i128(self, value: i128) -> Result<()> {
111        self.formatter
112            .write_i128(&mut self.writer, value)
113            .map_err(Error::io)
114    }
115
116    #[inline]
117    fn serialize_u8(self, value: u8) -> Result<()> {
118        self.formatter
119            .write_u8(&mut self.writer, value)
120            .map_err(Error::io)
121    }
122
123    #[inline]
124    fn serialize_u16(self, value: u16) -> Result<()> {
125        self.formatter
126            .write_u16(&mut self.writer, value)
127            .map_err(Error::io)
128    }
129
130    #[inline]
131    fn serialize_u32(self, value: u32) -> Result<()> {
132        self.formatter
133            .write_u32(&mut self.writer, value)
134            .map_err(Error::io)
135    }
136
137    #[inline]
138    fn serialize_u64(self, value: u64) -> Result<()> {
139        self.formatter
140            .write_u64(&mut self.writer, value)
141            .map_err(Error::io)
142    }
143
144    fn serialize_u128(self, value: u128) -> Result<()> {
145        self.formatter
146            .write_u128(&mut self.writer, value)
147            .map_err(Error::io)
148    }
149
150    #[inline]
151    fn serialize_f32(self, value: f32) -> Result<()> {
152        match value.classify() {
153            FpCategory::Nan | FpCategory::Infinite => self
154                .formatter
155                .write_null(&mut self.writer)
156                .map_err(Error::io),
157            _ => self
158                .formatter
159                .write_f32(&mut self.writer, value)
160                .map_err(Error::io),
161        }
162    }
163
164    #[inline]
165    fn serialize_f64(self, value: f64) -> Result<()> {
166        match value.classify() {
167            FpCategory::Nan | FpCategory::Infinite => self
168                .formatter
169                .write_null(&mut self.writer)
170                .map_err(Error::io),
171            _ => self
172                .formatter
173                .write_f64(&mut self.writer, value)
174                .map_err(Error::io),
175        }
176    }
177
178    #[inline]
179    fn serialize_char(self, value: char) -> Result<()> {
180        // A char encoded as UTF-8 takes 4 bytes at most.
181        let mut buf = [0; 4];
182        self.serialize_str(value.encode_utf8(&mut buf))
183    }
184
185    #[inline]
186    fn serialize_str(self, value: &str) -> Result<()> {
187        format_escaped_str(&mut self.writer, &mut self.formatter, value).map_err(Error::io)
188    }
189
190    #[inline]
191    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
192        self.formatter
193            .write_byte_array(&mut self.writer, value)
194            .map_err(Error::io)
195    }
196
197    #[inline]
198    fn serialize_unit(self) -> Result<()> {
199        self.formatter
200            .write_null(&mut self.writer)
201            .map_err(Error::io)
202    }
203
204    #[inline]
205    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
206        self.serialize_unit()
207    }
208
209    #[inline]
210    fn serialize_unit_variant(
211        self,
212        _name: &'static str,
213        _variant_index: u32,
214        variant: &'static str,
215    ) -> Result<()> {
216        self.serialize_str(variant)
217    }
218
219    /// Serialize newtypes without an object wrapper.
220    #[inline]
221    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
222    where
223        T: ?Sized + Serialize,
224    {
225        value.serialize(self)
226    }
227
228    #[inline]
229    fn serialize_newtype_variant<T>(
230        self,
231        _name: &'static str,
232        _variant_index: u32,
233        variant: &'static str,
234        value: &T,
235    ) -> Result<()>
236    where
237        T: ?Sized + Serialize,
238    {
239        tri!(self
240            .formatter
241            .begin_object(&mut self.writer)
242            .map_err(Error::io));
243        tri!(self
244            .formatter
245            .begin_object_key(&mut self.writer, true)
246            .map_err(Error::io));
247        tri!(self.serialize_str(variant));
248        tri!(self
249            .formatter
250            .end_object_key(&mut self.writer)
251            .map_err(Error::io));
252        tri!(self
253            .formatter
254            .begin_object_value(&mut self.writer)
255            .map_err(Error::io));
256        tri!(value.serialize(&mut *self));
257        tri!(self
258            .formatter
259            .end_object_value(&mut self.writer)
260            .map_err(Error::io));
261        self.formatter
262            .end_object(&mut self.writer)
263            .map_err(Error::io)
264    }
265
266    #[inline]
267    fn serialize_none(self) -> Result<()> {
268        self.serialize_unit()
269    }
270
271    #[inline]
272    fn serialize_some<T>(self, value: &T) -> Result<()>
273    where
274        T: ?Sized + Serialize,
275    {
276        value.serialize(self)
277    }
278
279    #[inline]
280    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
281        tri!(self
282            .formatter
283            .begin_array(&mut self.writer)
284            .map_err(Error::io));
285        if len == Some(0) {
286            tri!(self
287                .formatter
288                .end_array(&mut self.writer)
289                .map_err(Error::io));
290            Ok(Compound::Map {
291                ser: self,
292                state: State::Empty,
293            })
294        } else {
295            Ok(Compound::Map {
296                ser: self,
297                state: State::First,
298            })
299        }
300    }
301
302    #[inline]
303    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
304        self.serialize_seq(Some(len))
305    }
306
307    #[inline]
308    fn serialize_tuple_struct(
309        self,
310        _name: &'static str,
311        len: usize,
312    ) -> Result<Self::SerializeTupleStruct> {
313        self.serialize_seq(Some(len))
314    }
315
316    #[inline]
317    fn serialize_tuple_variant(
318        self,
319        _name: &'static str,
320        _variant_index: u32,
321        variant: &'static str,
322        len: usize,
323    ) -> Result<Self::SerializeTupleVariant> {
324        tri!(self
325            .formatter
326            .begin_object(&mut self.writer)
327            .map_err(Error::io));
328        tri!(self
329            .formatter
330            .begin_object_key(&mut self.writer, true)
331            .map_err(Error::io));
332        tri!(self.serialize_str(variant));
333        tri!(self
334            .formatter
335            .end_object_key(&mut self.writer)
336            .map_err(Error::io));
337        tri!(self
338            .formatter
339            .begin_object_value(&mut self.writer)
340            .map_err(Error::io));
341        self.serialize_seq(Some(len))
342    }
343
344    #[inline]
345    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
346        tri!(self
347            .formatter
348            .begin_object(&mut self.writer)
349            .map_err(Error::io));
350        if len == Some(0) {
351            tri!(self
352                .formatter
353                .end_object(&mut self.writer)
354                .map_err(Error::io));
355            Ok(Compound::Map {
356                ser: self,
357                state: State::Empty,
358            })
359        } else {
360            Ok(Compound::Map {
361                ser: self,
362                state: State::First,
363            })
364        }
365    }
366
367    #[inline]
368    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
369        match name {
370            #[cfg(feature = "arbitrary_precision")]
371            crate::number::TOKEN => Ok(Compound::Number { ser: self }),
372            #[cfg(feature = "raw_value")]
373            crate::raw::TOKEN => Ok(Compound::RawValue { ser: self }),
374            _ => self.serialize_map(Some(len)),
375        }
376    }
377
378    #[inline]
379    fn serialize_struct_variant(
380        self,
381        _name: &'static str,
382        _variant_index: u32,
383        variant: &'static str,
384        len: usize,
385    ) -> Result<Self::SerializeStructVariant> {
386        tri!(self
387            .formatter
388            .begin_object(&mut self.writer)
389            .map_err(Error::io));
390        tri!(self
391            .formatter
392            .begin_object_key(&mut self.writer, true)
393            .map_err(Error::io));
394        tri!(self.serialize_str(variant));
395        tri!(self
396            .formatter
397            .end_object_key(&mut self.writer)
398            .map_err(Error::io));
399        tri!(self
400            .formatter
401            .begin_object_value(&mut self.writer)
402            .map_err(Error::io));
403        self.serialize_map(Some(len))
404    }
405
406    fn collect_str<T>(self, value: &T) -> Result<()>
407    where
408        T: ?Sized + Display,
409    {
410        use self::fmt::Write;
411
412        struct Adapter<'ser, W: 'ser, F: 'ser> {
413            writer: &'ser mut W,
414            formatter: &'ser mut F,
415            error: Option<io::Error>,
416        }
417
418        impl<'ser, W, F> Write for Adapter<'ser, W, F>
419        where
420            W: io::Write,
421            F: Formatter,
422        {
423            fn write_str(&mut self, s: &str) -> fmt::Result {
424                debug_assert!(self.error.is_none());
425                match format_escaped_str_contents(self.writer, self.formatter, s) {
426                    Ok(()) => Ok(()),
427                    Err(err) => {
428                        self.error = Some(err);
429                        Err(fmt::Error)
430                    }
431                }
432            }
433        }
434
435        tri!(self
436            .formatter
437            .begin_string(&mut self.writer)
438            .map_err(Error::io));
439        let mut adapter = Adapter {
440            writer: &mut self.writer,
441            formatter: &mut self.formatter,
442            error: None,
443        };
444        match write!(adapter, "{}", value) {
445            Ok(()) => debug_assert!(adapter.error.is_none()),
446            Err(fmt::Error) => {
447                return Err(Error::io(adapter.error.expect("there should be an error")));
448            }
449        }
450        self.formatter
451            .end_string(&mut self.writer)
452            .map_err(Error::io)
453    }
454}
455
456// Not public API. Should be pub(crate).
457#[doc(hidden)]
458#[derive(Eq, PartialEq)]
459pub enum State {
460    Empty,
461    First,
462    Rest,
463}
464
465// Not public API. Should be pub(crate).
466#[doc(hidden)]
467pub enum Compound<'a, W: 'a, F: 'a> {
468    Map {
469        ser: &'a mut Serializer<W, F>,
470        state: State,
471    },
472    #[cfg(feature = "arbitrary_precision")]
473    Number { ser: &'a mut Serializer<W, F> },
474    #[cfg(feature = "raw_value")]
475    RawValue { ser: &'a mut Serializer<W, F> },
476}
477
478impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F>
479where
480    W: io::Write,
481    F: Formatter,
482{
483    type Ok = ();
484    type Error = Error;
485
486    #[inline]
487    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
488    where
489        T: ?Sized + Serialize,
490    {
491        match self {
492            Compound::Map { ser, state } => {
493                tri!(ser
494                    .formatter
495                    .begin_array_value(&mut ser.writer, *state == State::First)
496                    .map_err(Error::io));
497                *state = State::Rest;
498                tri!(value.serialize(&mut **ser));
499                ser.formatter
500                    .end_array_value(&mut ser.writer)
501                    .map_err(Error::io)
502            }
503            #[cfg(feature = "arbitrary_precision")]
504            Compound::Number { .. } => unreachable!(),
505            #[cfg(feature = "raw_value")]
506            Compound::RawValue { .. } => unreachable!(),
507        }
508    }
509
510    #[inline]
511    fn end(self) -> Result<()> {
512        match self {
513            Compound::Map { ser, state } => match state {
514                State::Empty => Ok(()),
515                _ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io),
516            },
517            #[cfg(feature = "arbitrary_precision")]
518            Compound::Number { .. } => unreachable!(),
519            #[cfg(feature = "raw_value")]
520            Compound::RawValue { .. } => unreachable!(),
521        }
522    }
523}
524
525impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F>
526where
527    W: io::Write,
528    F: Formatter,
529{
530    type Ok = ();
531    type Error = Error;
532
533    #[inline]
534    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
535    where
536        T: ?Sized + Serialize,
537    {
538        ser::SerializeSeq::serialize_element(self, value)
539    }
540
541    #[inline]
542    fn end(self) -> Result<()> {
543        ser::SerializeSeq::end(self)
544    }
545}
546
547impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F>
548where
549    W: io::Write,
550    F: Formatter,
551{
552    type Ok = ();
553    type Error = Error;
554
555    #[inline]
556    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
557    where
558        T: ?Sized + Serialize,
559    {
560        ser::SerializeSeq::serialize_element(self, value)
561    }
562
563    #[inline]
564    fn end(self) -> Result<()> {
565        ser::SerializeSeq::end(self)
566    }
567}
568
569impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F>
570where
571    W: io::Write,
572    F: Formatter,
573{
574    type Ok = ();
575    type Error = Error;
576
577    #[inline]
578    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
579    where
580        T: ?Sized + Serialize,
581    {
582        ser::SerializeSeq::serialize_element(self, value)
583    }
584
585    #[inline]
586    fn end(self) -> Result<()> {
587        match self {
588            Compound::Map { ser, state } => {
589                match state {
590                    State::Empty => {}
591                    _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
592                }
593                tri!(ser
594                    .formatter
595                    .end_object_value(&mut ser.writer)
596                    .map_err(Error::io));
597                ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
598            }
599            #[cfg(feature = "arbitrary_precision")]
600            Compound::Number { .. } => unreachable!(),
601            #[cfg(feature = "raw_value")]
602            Compound::RawValue { .. } => unreachable!(),
603        }
604    }
605}
606
607impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F>
608where
609    W: io::Write,
610    F: Formatter,
611{
612    type Ok = ();
613    type Error = Error;
614
615    #[inline]
616    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
617    where
618        T: ?Sized + Serialize,
619    {
620        match self {
621            Compound::Map { ser, state } => {
622                tri!(ser
623                    .formatter
624                    .begin_object_key(&mut ser.writer, *state == State::First)
625                    .map_err(Error::io));
626                *state = State::Rest;
627
628                tri!(key.serialize(MapKeySerializer { ser: *ser }));
629
630                ser.formatter
631                    .end_object_key(&mut ser.writer)
632                    .map_err(Error::io)
633            }
634            #[cfg(feature = "arbitrary_precision")]
635            Compound::Number { .. } => unreachable!(),
636            #[cfg(feature = "raw_value")]
637            Compound::RawValue { .. } => unreachable!(),
638        }
639    }
640
641    #[inline]
642    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
643    where
644        T: ?Sized + Serialize,
645    {
646        match self {
647            Compound::Map { ser, .. } => {
648                tri!(ser
649                    .formatter
650                    .begin_object_value(&mut ser.writer)
651                    .map_err(Error::io));
652                tri!(value.serialize(&mut **ser));
653                ser.formatter
654                    .end_object_value(&mut ser.writer)
655                    .map_err(Error::io)
656            }
657            #[cfg(feature = "arbitrary_precision")]
658            Compound::Number { .. } => unreachable!(),
659            #[cfg(feature = "raw_value")]
660            Compound::RawValue { .. } => unreachable!(),
661        }
662    }
663
664    #[inline]
665    fn end(self) -> Result<()> {
666        match self {
667            Compound::Map { ser, state } => match state {
668                State::Empty => Ok(()),
669                _ => ser.formatter.end_object(&mut ser.writer).map_err(Error::io),
670            },
671            #[cfg(feature = "arbitrary_precision")]
672            Compound::Number { .. } => unreachable!(),
673            #[cfg(feature = "raw_value")]
674            Compound::RawValue { .. } => unreachable!(),
675        }
676    }
677}
678
679impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F>
680where
681    W: io::Write,
682    F: Formatter,
683{
684    type Ok = ();
685    type Error = Error;
686
687    #[inline]
688    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
689    where
690        T: ?Sized + Serialize,
691    {
692        match self {
693            Compound::Map { .. } => ser::SerializeMap::serialize_entry(self, key, value),
694            #[cfg(feature = "arbitrary_precision")]
695            Compound::Number { ser, .. } => {
696                if key == crate::number::TOKEN {
697                    value.serialize(NumberStrEmitter(ser))
698                } else {
699                    Err(invalid_number())
700                }
701            }
702            #[cfg(feature = "raw_value")]
703            Compound::RawValue { ser, .. } => {
704                if key == crate::raw::TOKEN {
705                    value.serialize(RawValueStrEmitter(ser))
706                } else {
707                    Err(invalid_raw_value())
708                }
709            }
710        }
711    }
712
713    #[inline]
714    fn end(self) -> Result<()> {
715        match self {
716            Compound::Map { .. } => ser::SerializeMap::end(self),
717            #[cfg(feature = "arbitrary_precision")]
718            Compound::Number { .. } => Ok(()),
719            #[cfg(feature = "raw_value")]
720            Compound::RawValue { .. } => Ok(()),
721        }
722    }
723}
724
725impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F>
726where
727    W: io::Write,
728    F: Formatter,
729{
730    type Ok = ();
731    type Error = Error;
732
733    #[inline]
734    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
735    where
736        T: ?Sized + Serialize,
737    {
738        match *self {
739            Compound::Map { .. } => ser::SerializeStruct::serialize_field(self, key, value),
740            #[cfg(feature = "arbitrary_precision")]
741            Compound::Number { .. } => unreachable!(),
742            #[cfg(feature = "raw_value")]
743            Compound::RawValue { .. } => unreachable!(),
744        }
745    }
746
747    #[inline]
748    fn end(self) -> Result<()> {
749        match self {
750            Compound::Map { ser, state } => {
751                match state {
752                    State::Empty => {}
753                    _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
754                }
755                tri!(ser
756                    .formatter
757                    .end_object_value(&mut ser.writer)
758                    .map_err(Error::io));
759                ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
760            }
761            #[cfg(feature = "arbitrary_precision")]
762            Compound::Number { .. } => unreachable!(),
763            #[cfg(feature = "raw_value")]
764            Compound::RawValue { .. } => unreachable!(),
765        }
766    }
767}
768
769struct MapKeySerializer<'a, W: 'a, F: 'a> {
770    ser: &'a mut Serializer<W, F>,
771}
772
773#[cfg(feature = "arbitrary_precision")]
774fn invalid_number() -> Error {
775    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
776}
777
778#[cfg(feature = "raw_value")]
779fn invalid_raw_value() -> Error {
780    Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0)
781}
782
783fn key_must_be_a_string() -> Error {
784    Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
785}
786
787fn float_key_must_be_finite() -> Error {
788    Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0)
789}
790
791impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F>
792where
793    W: io::Write,
794    F: Formatter,
795{
796    type Ok = ();
797    type Error = Error;
798
799    #[inline]
800    fn serialize_str(self, value: &str) -> Result<()> {
801        self.ser.serialize_str(value)
802    }
803
804    #[inline]
805    fn serialize_unit_variant(
806        self,
807        _name: &'static str,
808        _variant_index: u32,
809        variant: &'static str,
810    ) -> Result<()> {
811        self.ser.serialize_str(variant)
812    }
813
814    #[inline]
815    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
816    where
817        T: ?Sized + Serialize,
818    {
819        value.serialize(self)
820    }
821
822    type SerializeSeq = Impossible<(), Error>;
823    type SerializeTuple = Impossible<(), Error>;
824    type SerializeTupleStruct = Impossible<(), Error>;
825    type SerializeTupleVariant = Impossible<(), Error>;
826    type SerializeMap = Impossible<(), Error>;
827    type SerializeStruct = Impossible<(), Error>;
828    type SerializeStructVariant = Impossible<(), Error>;
829
830    fn serialize_bool(self, value: bool) -> Result<()> {
831        tri!(self
832            .ser
833            .formatter
834            .begin_string(&mut self.ser.writer)
835            .map_err(Error::io));
836        tri!(self
837            .ser
838            .formatter
839            .write_bool(&mut self.ser.writer, value)
840            .map_err(Error::io));
841        self.ser
842            .formatter
843            .end_string(&mut self.ser.writer)
844            .map_err(Error::io)
845    }
846
847    fn serialize_i8(self, value: i8) -> Result<()> {
848        tri!(self
849            .ser
850            .formatter
851            .begin_string(&mut self.ser.writer)
852            .map_err(Error::io));
853        tri!(self
854            .ser
855            .formatter
856            .write_i8(&mut self.ser.writer, value)
857            .map_err(Error::io));
858        self.ser
859            .formatter
860            .end_string(&mut self.ser.writer)
861            .map_err(Error::io)
862    }
863
864    fn serialize_i16(self, value: i16) -> Result<()> {
865        tri!(self
866            .ser
867            .formatter
868            .begin_string(&mut self.ser.writer)
869            .map_err(Error::io));
870        tri!(self
871            .ser
872            .formatter
873            .write_i16(&mut self.ser.writer, value)
874            .map_err(Error::io));
875        self.ser
876            .formatter
877            .end_string(&mut self.ser.writer)
878            .map_err(Error::io)
879    }
880
881    fn serialize_i32(self, value: i32) -> Result<()> {
882        tri!(self
883            .ser
884            .formatter
885            .begin_string(&mut self.ser.writer)
886            .map_err(Error::io));
887        tri!(self
888            .ser
889            .formatter
890            .write_i32(&mut self.ser.writer, value)
891            .map_err(Error::io));
892        self.ser
893            .formatter
894            .end_string(&mut self.ser.writer)
895            .map_err(Error::io)
896    }
897
898    fn serialize_i64(self, value: i64) -> Result<()> {
899        tri!(self
900            .ser
901            .formatter
902            .begin_string(&mut self.ser.writer)
903            .map_err(Error::io));
904        tri!(self
905            .ser
906            .formatter
907            .write_i64(&mut self.ser.writer, value)
908            .map_err(Error::io));
909        self.ser
910            .formatter
911            .end_string(&mut self.ser.writer)
912            .map_err(Error::io)
913    }
914
915    fn serialize_i128(self, value: i128) -> Result<()> {
916        tri!(self
917            .ser
918            .formatter
919            .begin_string(&mut self.ser.writer)
920            .map_err(Error::io));
921        tri!(self
922            .ser
923            .formatter
924            .write_i128(&mut self.ser.writer, value)
925            .map_err(Error::io));
926        self.ser
927            .formatter
928            .end_string(&mut self.ser.writer)
929            .map_err(Error::io)
930    }
931
932    fn serialize_u8(self, value: u8) -> Result<()> {
933        tri!(self
934            .ser
935            .formatter
936            .begin_string(&mut self.ser.writer)
937            .map_err(Error::io));
938        tri!(self
939            .ser
940            .formatter
941            .write_u8(&mut self.ser.writer, value)
942            .map_err(Error::io));
943        self.ser
944            .formatter
945            .end_string(&mut self.ser.writer)
946            .map_err(Error::io)
947    }
948
949    fn serialize_u16(self, value: u16) -> Result<()> {
950        tri!(self
951            .ser
952            .formatter
953            .begin_string(&mut self.ser.writer)
954            .map_err(Error::io));
955        tri!(self
956            .ser
957            .formatter
958            .write_u16(&mut self.ser.writer, value)
959            .map_err(Error::io));
960        self.ser
961            .formatter
962            .end_string(&mut self.ser.writer)
963            .map_err(Error::io)
964    }
965
966    fn serialize_u32(self, value: u32) -> Result<()> {
967        tri!(self
968            .ser
969            .formatter
970            .begin_string(&mut self.ser.writer)
971            .map_err(Error::io));
972        tri!(self
973            .ser
974            .formatter
975            .write_u32(&mut self.ser.writer, value)
976            .map_err(Error::io));
977        self.ser
978            .formatter
979            .end_string(&mut self.ser.writer)
980            .map_err(Error::io)
981    }
982
983    fn serialize_u64(self, value: u64) -> Result<()> {
984        tri!(self
985            .ser
986            .formatter
987            .begin_string(&mut self.ser.writer)
988            .map_err(Error::io));
989        tri!(self
990            .ser
991            .formatter
992            .write_u64(&mut self.ser.writer, value)
993            .map_err(Error::io));
994        self.ser
995            .formatter
996            .end_string(&mut self.ser.writer)
997            .map_err(Error::io)
998    }
999
1000    fn serialize_u128(self, value: u128) -> Result<()> {
1001        tri!(self
1002            .ser
1003            .formatter
1004            .begin_string(&mut self.ser.writer)
1005            .map_err(Error::io));
1006        tri!(self
1007            .ser
1008            .formatter
1009            .write_u128(&mut self.ser.writer, value)
1010            .map_err(Error::io));
1011        self.ser
1012            .formatter
1013            .end_string(&mut self.ser.writer)
1014            .map_err(Error::io)
1015    }
1016
1017    fn serialize_f32(self, value: f32) -> Result<()> {
1018        if !value.is_finite() {
1019            return Err(float_key_must_be_finite());
1020        }
1021
1022        tri!(self
1023            .ser
1024            .formatter
1025            .begin_string(&mut self.ser.writer)
1026            .map_err(Error::io));
1027        tri!(self
1028            .ser
1029            .formatter
1030            .write_f32(&mut self.ser.writer, value)
1031            .map_err(Error::io));
1032        self.ser
1033            .formatter
1034            .end_string(&mut self.ser.writer)
1035            .map_err(Error::io)
1036    }
1037
1038    fn serialize_f64(self, value: f64) -> Result<()> {
1039        if !value.is_finite() {
1040            return Err(float_key_must_be_finite());
1041        }
1042
1043        tri!(self
1044            .ser
1045            .formatter
1046            .begin_string(&mut self.ser.writer)
1047            .map_err(Error::io));
1048        tri!(self
1049            .ser
1050            .formatter
1051            .write_f64(&mut self.ser.writer, value)
1052            .map_err(Error::io));
1053        self.ser
1054            .formatter
1055            .end_string(&mut self.ser.writer)
1056            .map_err(Error::io)
1057    }
1058
1059    fn serialize_char(self, value: char) -> Result<()> {
1060        self.ser.serialize_str(&value.to_string())
1061    }
1062
1063    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
1064        Err(key_must_be_a_string())
1065    }
1066
1067    fn serialize_unit(self) -> Result<()> {
1068        Err(key_must_be_a_string())
1069    }
1070
1071    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
1072        Err(key_must_be_a_string())
1073    }
1074
1075    fn serialize_newtype_variant<T>(
1076        self,
1077        _name: &'static str,
1078        _variant_index: u32,
1079        _variant: &'static str,
1080        _value: &T,
1081    ) -> Result<()>
1082    where
1083        T: ?Sized + Serialize,
1084    {
1085        Err(key_must_be_a_string())
1086    }
1087
1088    fn serialize_none(self) -> Result<()> {
1089        Err(key_must_be_a_string())
1090    }
1091
1092    fn serialize_some<T>(self, value: &T) -> Result<()>
1093    where
1094        T: ?Sized + Serialize,
1095    {
1096        value.serialize(self)
1097    }
1098
1099    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1100        Err(key_must_be_a_string())
1101    }
1102
1103    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1104        Err(key_must_be_a_string())
1105    }
1106
1107    fn serialize_tuple_struct(
1108        self,
1109        _name: &'static str,
1110        _len: usize,
1111    ) -> Result<Self::SerializeTupleStruct> {
1112        Err(key_must_be_a_string())
1113    }
1114
1115    fn serialize_tuple_variant(
1116        self,
1117        _name: &'static str,
1118        _variant_index: u32,
1119        _variant: &'static str,
1120        _len: usize,
1121    ) -> Result<Self::SerializeTupleVariant> {
1122        Err(key_must_be_a_string())
1123    }
1124
1125    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1126        Err(key_must_be_a_string())
1127    }
1128
1129    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1130        Err(key_must_be_a_string())
1131    }
1132
1133    fn serialize_struct_variant(
1134        self,
1135        _name: &'static str,
1136        _variant_index: u32,
1137        _variant: &'static str,
1138        _len: usize,
1139    ) -> Result<Self::SerializeStructVariant> {
1140        Err(key_must_be_a_string())
1141    }
1142
1143    fn collect_str<T>(self, value: &T) -> Result<()>
1144    where
1145        T: ?Sized + Display,
1146    {
1147        self.ser.collect_str(value)
1148    }
1149}
1150
1151#[cfg(feature = "arbitrary_precision")]
1152struct NumberStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer<W, F>);
1153
1154#[cfg(feature = "arbitrary_precision")]
1155impl<'a, W: io::Write, F: Formatter> ser::Serializer for NumberStrEmitter<'a, W, F> {
1156    type Ok = ();
1157    type Error = Error;
1158
1159    type SerializeSeq = Impossible<(), Error>;
1160    type SerializeTuple = Impossible<(), Error>;
1161    type SerializeTupleStruct = Impossible<(), Error>;
1162    type SerializeTupleVariant = Impossible<(), Error>;
1163    type SerializeMap = Impossible<(), Error>;
1164    type SerializeStruct = Impossible<(), Error>;
1165    type SerializeStructVariant = Impossible<(), Error>;
1166
1167    fn serialize_bool(self, _v: bool) -> Result<()> {
1168        Err(invalid_number())
1169    }
1170
1171    fn serialize_i8(self, _v: i8) -> Result<()> {
1172        Err(invalid_number())
1173    }
1174
1175    fn serialize_i16(self, _v: i16) -> Result<()> {
1176        Err(invalid_number())
1177    }
1178
1179    fn serialize_i32(self, _v: i32) -> Result<()> {
1180        Err(invalid_number())
1181    }
1182
1183    fn serialize_i64(self, _v: i64) -> Result<()> {
1184        Err(invalid_number())
1185    }
1186
1187    fn serialize_i128(self, _v: i128) -> Result<()> {
1188        Err(invalid_number())
1189    }
1190
1191    fn serialize_u8(self, _v: u8) -> Result<()> {
1192        Err(invalid_number())
1193    }
1194
1195    fn serialize_u16(self, _v: u16) -> Result<()> {
1196        Err(invalid_number())
1197    }
1198
1199    fn serialize_u32(self, _v: u32) -> Result<()> {
1200        Err(invalid_number())
1201    }
1202
1203    fn serialize_u64(self, _v: u64) -> Result<()> {
1204        Err(invalid_number())
1205    }
1206
1207    fn serialize_u128(self, _v: u128) -> Result<()> {
1208        Err(invalid_number())
1209    }
1210
1211    fn serialize_f32(self, _v: f32) -> Result<()> {
1212        Err(invalid_number())
1213    }
1214
1215    fn serialize_f64(self, _v: f64) -> Result<()> {
1216        Err(invalid_number())
1217    }
1218
1219    fn serialize_char(self, _v: char) -> Result<()> {
1220        Err(invalid_number())
1221    }
1222
1223    fn serialize_str(self, value: &str) -> Result<()> {
1224        let NumberStrEmitter(serializer) = self;
1225        serializer
1226            .formatter
1227            .write_number_str(&mut serializer.writer, value)
1228            .map_err(Error::io)
1229    }
1230
1231    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
1232        Err(invalid_number())
1233    }
1234
1235    fn serialize_none(self) -> Result<()> {
1236        Err(invalid_number())
1237    }
1238
1239    fn serialize_some<T>(self, _value: &T) -> Result<()>
1240    where
1241        T: ?Sized + Serialize,
1242    {
1243        Err(invalid_number())
1244    }
1245
1246    fn serialize_unit(self) -> Result<()> {
1247        Err(invalid_number())
1248    }
1249
1250    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
1251        Err(invalid_number())
1252    }
1253
1254    fn serialize_unit_variant(
1255        self,
1256        _name: &'static str,
1257        _variant_index: u32,
1258        _variant: &'static str,
1259    ) -> Result<()> {
1260        Err(invalid_number())
1261    }
1262
1263    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
1264    where
1265        T: ?Sized + Serialize,
1266    {
1267        Err(invalid_number())
1268    }
1269
1270    fn serialize_newtype_variant<T>(
1271        self,
1272        _name: &'static str,
1273        _variant_index: u32,
1274        _variant: &'static str,
1275        _value: &T,
1276    ) -> Result<()>
1277    where
1278        T: ?Sized + Serialize,
1279    {
1280        Err(invalid_number())
1281    }
1282
1283    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1284        Err(invalid_number())
1285    }
1286
1287    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1288        Err(invalid_number())
1289    }
1290
1291    fn serialize_tuple_struct(
1292        self,
1293        _name: &'static str,
1294        _len: usize,
1295    ) -> Result<Self::SerializeTupleStruct> {
1296        Err(invalid_number())
1297    }
1298
1299    fn serialize_tuple_variant(
1300        self,
1301        _name: &'static str,
1302        _variant_index: u32,
1303        _variant: &'static str,
1304        _len: usize,
1305    ) -> Result<Self::SerializeTupleVariant> {
1306        Err(invalid_number())
1307    }
1308
1309    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1310        Err(invalid_number())
1311    }
1312
1313    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1314        Err(invalid_number())
1315    }
1316
1317    fn serialize_struct_variant(
1318        self,
1319        _name: &'static str,
1320        _variant_index: u32,
1321        _variant: &'static str,
1322        _len: usize,
1323    ) -> Result<Self::SerializeStructVariant> {
1324        Err(invalid_number())
1325    }
1326}
1327
1328#[cfg(feature = "raw_value")]
1329struct RawValueStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut Serializer<W, F>);
1330
1331#[cfg(feature = "raw_value")]
1332impl<'a, W: io::Write, F: Formatter> ser::Serializer for RawValueStrEmitter<'a, W, F> {
1333    type Ok = ();
1334    type Error = Error;
1335
1336    type SerializeSeq = Impossible<(), Error>;
1337    type SerializeTuple = Impossible<(), Error>;
1338    type SerializeTupleStruct = Impossible<(), Error>;
1339    type SerializeTupleVariant = Impossible<(), Error>;
1340    type SerializeMap = Impossible<(), Error>;
1341    type SerializeStruct = Impossible<(), Error>;
1342    type SerializeStructVariant = Impossible<(), Error>;
1343
1344    fn serialize_bool(self, _v: bool) -> Result<()> {
1345        Err(ser::Error::custom("expected RawValue"))
1346    }
1347
1348    fn serialize_i8(self, _v: i8) -> Result<()> {
1349        Err(ser::Error::custom("expected RawValue"))
1350    }
1351
1352    fn serialize_i16(self, _v: i16) -> Result<()> {
1353        Err(ser::Error::custom("expected RawValue"))
1354    }
1355
1356    fn serialize_i32(self, _v: i32) -> Result<()> {
1357        Err(ser::Error::custom("expected RawValue"))
1358    }
1359
1360    fn serialize_i64(self, _v: i64) -> Result<()> {
1361        Err(ser::Error::custom("expected RawValue"))
1362    }
1363
1364    fn serialize_i128(self, _v: i128) -> Result<()> {
1365        Err(ser::Error::custom("expected RawValue"))
1366    }
1367
1368    fn serialize_u8(self, _v: u8) -> Result<()> {
1369        Err(ser::Error::custom("expected RawValue"))
1370    }
1371
1372    fn serialize_u16(self, _v: u16) -> Result<()> {
1373        Err(ser::Error::custom("expected RawValue"))
1374    }
1375
1376    fn serialize_u32(self, _v: u32) -> Result<()> {
1377        Err(ser::Error::custom("expected RawValue"))
1378    }
1379
1380    fn serialize_u64(self, _v: u64) -> Result<()> {
1381        Err(ser::Error::custom("expected RawValue"))
1382    }
1383
1384    fn serialize_u128(self, _v: u128) -> Result<()> {
1385        Err(ser::Error::custom("expected RawValue"))
1386    }
1387
1388    fn serialize_f32(self, _v: f32) -> Result<()> {
1389        Err(ser::Error::custom("expected RawValue"))
1390    }
1391
1392    fn serialize_f64(self, _v: f64) -> Result<()> {
1393        Err(ser::Error::custom("expected RawValue"))
1394    }
1395
1396    fn serialize_char(self, _v: char) -> Result<()> {
1397        Err(ser::Error::custom("expected RawValue"))
1398    }
1399
1400    fn serialize_str(self, value: &str) -> Result<()> {
1401        let RawValueStrEmitter(serializer) = self;
1402        serializer
1403            .formatter
1404            .write_raw_fragment(&mut serializer.writer, value)
1405            .map_err(Error::io)
1406    }
1407
1408    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
1409        Err(ser::Error::custom("expected RawValue"))
1410    }
1411
1412    fn serialize_none(self) -> Result<()> {
1413        Err(ser::Error::custom("expected RawValue"))
1414    }
1415
1416    fn serialize_some<T>(self, _value: &T) -> Result<()>
1417    where
1418        T: ?Sized + Serialize,
1419    {
1420        Err(ser::Error::custom("expected RawValue"))
1421    }
1422
1423    fn serialize_unit(self) -> Result<()> {
1424        Err(ser::Error::custom("expected RawValue"))
1425    }
1426
1427    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
1428        Err(ser::Error::custom("expected RawValue"))
1429    }
1430
1431    fn serialize_unit_variant(
1432        self,
1433        _name: &'static str,
1434        _variant_index: u32,
1435        _variant: &'static str,
1436    ) -> Result<()> {
1437        Err(ser::Error::custom("expected RawValue"))
1438    }
1439
1440    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
1441    where
1442        T: ?Sized + Serialize,
1443    {
1444        Err(ser::Error::custom("expected RawValue"))
1445    }
1446
1447    fn serialize_newtype_variant<T>(
1448        self,
1449        _name: &'static str,
1450        _variant_index: u32,
1451        _variant: &'static str,
1452        _value: &T,
1453    ) -> Result<()>
1454    where
1455        T: ?Sized + Serialize,
1456    {
1457        Err(ser::Error::custom("expected RawValue"))
1458    }
1459
1460    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1461        Err(ser::Error::custom("expected RawValue"))
1462    }
1463
1464    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1465        Err(ser::Error::custom("expected RawValue"))
1466    }
1467
1468    fn serialize_tuple_struct(
1469        self,
1470        _name: &'static str,
1471        _len: usize,
1472    ) -> Result<Self::SerializeTupleStruct> {
1473        Err(ser::Error::custom("expected RawValue"))
1474    }
1475
1476    fn serialize_tuple_variant(
1477        self,
1478        _name: &'static str,
1479        _variant_index: u32,
1480        _variant: &'static str,
1481        _len: usize,
1482    ) -> Result<Self::SerializeTupleVariant> {
1483        Err(ser::Error::custom("expected RawValue"))
1484    }
1485
1486    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1487        Err(ser::Error::custom("expected RawValue"))
1488    }
1489
1490    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1491        Err(ser::Error::custom("expected RawValue"))
1492    }
1493
1494    fn serialize_struct_variant(
1495        self,
1496        _name: &'static str,
1497        _variant_index: u32,
1498        _variant: &'static str,
1499        _len: usize,
1500    ) -> Result<Self::SerializeStructVariant> {
1501        Err(ser::Error::custom("expected RawValue"))
1502    }
1503
1504    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
1505    where
1506        T: ?Sized + Display,
1507    {
1508        self.serialize_str(&value.to_string())
1509    }
1510}
1511
1512/// Represents a character escape code in a type-safe manner.
1513pub enum CharEscape {
1514    /// An escaped quote `"`
1515    Quote,
1516    /// An escaped reverse solidus `\`
1517    ReverseSolidus,
1518    /// An escaped solidus `/`
1519    Solidus,
1520    /// An escaped backspace character (usually escaped as `\b`)
1521    Backspace,
1522    /// An escaped form feed character (usually escaped as `\f`)
1523    FormFeed,
1524    /// An escaped line feed character (usually escaped as `\n`)
1525    LineFeed,
1526    /// An escaped carriage return character (usually escaped as `\r`)
1527    CarriageReturn,
1528    /// An escaped tab character (usually escaped as `\t`)
1529    Tab,
1530    /// An escaped ASCII plane control character (usually escaped as
1531    /// `\u00XX` where `XX` are two hex characters)
1532    AsciiControl(u8),
1533}
1534
1535impl CharEscape {
1536    #[inline]
1537    fn from_escape_table(escape: u8, byte: u8) -> CharEscape {
1538        match escape {
1539            self::BB => CharEscape::Backspace,
1540            self::TT => CharEscape::Tab,
1541            self::NN => CharEscape::LineFeed,
1542            self::FF => CharEscape::FormFeed,
1543            self::RR => CharEscape::CarriageReturn,
1544            self::QU => CharEscape::Quote,
1545            self::BS => CharEscape::ReverseSolidus,
1546            self::UU => CharEscape::AsciiControl(byte),
1547            _ => unreachable!(),
1548        }
1549    }
1550}
1551
1552/// This trait abstracts away serializing the JSON control characters, which allows the user to
1553/// optionally pretty print the JSON output.
1554pub trait Formatter {
1555    /// Writes a `null` value to the specified writer.
1556    #[inline]
1557    fn write_null<W>(&mut self, writer: &mut W) -> io::Result<()>
1558    where
1559        W: ?Sized + io::Write,
1560    {
1561        writer.write_all(b"null")
1562    }
1563
1564    /// Writes a `true` or `false` value to the specified writer.
1565    #[inline]
1566    fn write_bool<W>(&mut self, writer: &mut W, value: bool) -> io::Result<()>
1567    where
1568        W: ?Sized + io::Write,
1569    {
1570        let s = if value {
1571            b"true" as &[u8]
1572        } else {
1573            b"false" as &[u8]
1574        };
1575        writer.write_all(s)
1576    }
1577
1578    /// Writes an integer value like `-123` to the specified writer.
1579    #[inline]
1580    fn write_i8<W>(&mut self, writer: &mut W, value: i8) -> io::Result<()>
1581    where
1582        W: ?Sized + io::Write,
1583    {
1584        let mut buffer = itoa::Buffer::new();
1585        let s = buffer.format(value);
1586        writer.write_all(s.as_bytes())
1587    }
1588
1589    /// Writes an integer value like `-123` to the specified writer.
1590    #[inline]
1591    fn write_i16<W>(&mut self, writer: &mut W, value: i16) -> io::Result<()>
1592    where
1593        W: ?Sized + io::Write,
1594    {
1595        let mut buffer = itoa::Buffer::new();
1596        let s = buffer.format(value);
1597        writer.write_all(s.as_bytes())
1598    }
1599
1600    /// Writes an integer value like `-123` to the specified writer.
1601    #[inline]
1602    fn write_i32<W>(&mut self, writer: &mut W, value: i32) -> io::Result<()>
1603    where
1604        W: ?Sized + io::Write,
1605    {
1606        let mut buffer = itoa::Buffer::new();
1607        let s = buffer.format(value);
1608        writer.write_all(s.as_bytes())
1609    }
1610
1611    /// Writes an integer value like `-123` to the specified writer.
1612    #[inline]
1613    fn write_i64<W>(&mut self, writer: &mut W, value: i64) -> io::Result<()>
1614    where
1615        W: ?Sized + io::Write,
1616    {
1617        let mut buffer = itoa::Buffer::new();
1618        let s = buffer.format(value);
1619        writer.write_all(s.as_bytes())
1620    }
1621
1622    /// Writes an integer value like `-123` to the specified writer.
1623    #[inline]
1624    fn write_i128<W>(&mut self, writer: &mut W, value: i128) -> io::Result<()>
1625    where
1626        W: ?Sized + io::Write,
1627    {
1628        let mut buffer = itoa::Buffer::new();
1629        let s = buffer.format(value);
1630        writer.write_all(s.as_bytes())
1631    }
1632
1633    /// Writes an integer value like `123` to the specified writer.
1634    #[inline]
1635    fn write_u8<W>(&mut self, writer: &mut W, value: u8) -> io::Result<()>
1636    where
1637        W: ?Sized + io::Write,
1638    {
1639        let mut buffer = itoa::Buffer::new();
1640        let s = buffer.format(value);
1641        writer.write_all(s.as_bytes())
1642    }
1643
1644    /// Writes an integer value like `123` to the specified writer.
1645    #[inline]
1646    fn write_u16<W>(&mut self, writer: &mut W, value: u16) -> io::Result<()>
1647    where
1648        W: ?Sized + io::Write,
1649    {
1650        let mut buffer = itoa::Buffer::new();
1651        let s = buffer.format(value);
1652        writer.write_all(s.as_bytes())
1653    }
1654
1655    /// Writes an integer value like `123` to the specified writer.
1656    #[inline]
1657    fn write_u32<W>(&mut self, writer: &mut W, value: u32) -> io::Result<()>
1658    where
1659        W: ?Sized + io::Write,
1660    {
1661        let mut buffer = itoa::Buffer::new();
1662        let s = buffer.format(value);
1663        writer.write_all(s.as_bytes())
1664    }
1665
1666    /// Writes an integer value like `123` to the specified writer.
1667    #[inline]
1668    fn write_u64<W>(&mut self, writer: &mut W, value: u64) -> io::Result<()>
1669    where
1670        W: ?Sized + io::Write,
1671    {
1672        let mut buffer = itoa::Buffer::new();
1673        let s = buffer.format(value);
1674        writer.write_all(s.as_bytes())
1675    }
1676
1677    /// Writes an integer value like `123` to the specified writer.
1678    #[inline]
1679    fn write_u128<W>(&mut self, writer: &mut W, value: u128) -> io::Result<()>
1680    where
1681        W: ?Sized + io::Write,
1682    {
1683        let mut buffer = itoa::Buffer::new();
1684        let s = buffer.format(value);
1685        writer.write_all(s.as_bytes())
1686    }
1687
1688    /// Writes a floating point value like `-31.26e+12` to the specified writer.
1689    #[inline]
1690    fn write_f32<W>(&mut self, writer: &mut W, value: f32) -> io::Result<()>
1691    where
1692        W: ?Sized + io::Write,
1693    {
1694        let mut buffer = ryu::Buffer::new();
1695        let s = buffer.format_finite(value);
1696        writer.write_all(s.as_bytes())
1697    }
1698
1699    /// Writes a floating point value like `-31.26e+12` to the specified writer.
1700    #[inline]
1701    fn write_f64<W>(&mut self, writer: &mut W, value: f64) -> io::Result<()>
1702    where
1703        W: ?Sized + io::Write,
1704    {
1705        let mut buffer = ryu::Buffer::new();
1706        let s = buffer.format_finite(value);
1707        writer.write_all(s.as_bytes())
1708    }
1709
1710    /// Writes a number that has already been rendered to a string.
1711    #[inline]
1712    fn write_number_str<W>(&mut self, writer: &mut W, value: &str) -> io::Result<()>
1713    where
1714        W: ?Sized + io::Write,
1715    {
1716        writer.write_all(value.as_bytes())
1717    }
1718
1719    /// Called before each series of `write_string_fragment` and
1720    /// `write_char_escape`.  Writes a `"` to the specified writer.
1721    #[inline]
1722    fn begin_string<W>(&mut self, writer: &mut W) -> io::Result<()>
1723    where
1724        W: ?Sized + io::Write,
1725    {
1726        writer.write_all(b"\"")
1727    }
1728
1729    /// Called after each series of `write_string_fragment` and
1730    /// `write_char_escape`.  Writes a `"` to the specified writer.
1731    #[inline]
1732    fn end_string<W>(&mut self, writer: &mut W) -> io::Result<()>
1733    where
1734        W: ?Sized + io::Write,
1735    {
1736        writer.write_all(b"\"")
1737    }
1738
1739    /// Writes a string fragment that doesn't need any escaping to the
1740    /// specified writer.
1741    #[inline]
1742    fn write_string_fragment<W>(&mut self, writer: &mut W, fragment: &str) -> io::Result<()>
1743    where
1744        W: ?Sized + io::Write,
1745    {
1746        writer.write_all(fragment.as_bytes())
1747    }
1748
1749    /// Writes a character escape code to the specified writer.
1750    #[inline]
1751    fn write_char_escape<W>(&mut self, writer: &mut W, char_escape: CharEscape) -> io::Result<()>
1752    where
1753        W: ?Sized + io::Write,
1754    {
1755        use self::CharEscape::*;
1756
1757        let s = match char_escape {
1758            Quote => b"\\\"",
1759            ReverseSolidus => b"\\\\",
1760            Solidus => b"\\/",
1761            Backspace => b"\\b",
1762            FormFeed => b"\\f",
1763            LineFeed => b"\\n",
1764            CarriageReturn => b"\\r",
1765            Tab => b"\\t",
1766            AsciiControl(byte) => {
1767                static HEX_DIGITS: [u8; 16] = *b"0123456789abcdef";
1768                let bytes = &[
1769                    b'\\',
1770                    b'u',
1771                    b'0',
1772                    b'0',
1773                    HEX_DIGITS[(byte >> 4) as usize],
1774                    HEX_DIGITS[(byte & 0xF) as usize],
1775                ];
1776                return writer.write_all(bytes);
1777            }
1778        };
1779
1780        writer.write_all(s)
1781    }
1782
1783    /// Writes the representation of a byte array. Formatters can choose whether
1784    /// to represent bytes as a JSON array of integers (the default), or some
1785    /// JSON string encoding like hex or base64.
1786    fn write_byte_array<W>(&mut self, writer: &mut W, value: &[u8]) -> io::Result<()>
1787    where
1788        W: ?Sized + io::Write,
1789    {
1790        tri!(self.begin_array(writer));
1791        let mut first = true;
1792        for byte in value {
1793            tri!(self.begin_array_value(writer, first));
1794            tri!(self.write_u8(writer, *byte));
1795            tri!(self.end_array_value(writer));
1796            first = false;
1797        }
1798        self.end_array(writer)
1799    }
1800
1801    /// Called before every array.  Writes a `[` to the specified
1802    /// writer.
1803    #[inline]
1804    fn begin_array<W>(&mut self, writer: &mut W) -> io::Result<()>
1805    where
1806        W: ?Sized + io::Write,
1807    {
1808        writer.write_all(b"[")
1809    }
1810
1811    /// Called after every array.  Writes a `]` to the specified
1812    /// writer.
1813    #[inline]
1814    fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
1815    where
1816        W: ?Sized + io::Write,
1817    {
1818        writer.write_all(b"]")
1819    }
1820
1821    /// Called before every array value.  Writes a `,` if needed to
1822    /// the specified writer.
1823    #[inline]
1824    fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
1825    where
1826        W: ?Sized + io::Write,
1827    {
1828        if first {
1829            Ok(())
1830        } else {
1831            writer.write_all(b",")
1832        }
1833    }
1834
1835    /// Called after every array value.
1836    #[inline]
1837    fn end_array_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
1838    where
1839        W: ?Sized + io::Write,
1840    {
1841        Ok(())
1842    }
1843
1844    /// Called before every object.  Writes a `{` to the specified
1845    /// writer.
1846    #[inline]
1847    fn begin_object<W>(&mut self, writer: &mut W) -> io::Result<()>
1848    where
1849        W: ?Sized + io::Write,
1850    {
1851        writer.write_all(b"{")
1852    }
1853
1854    /// Called after every object.  Writes a `}` to the specified
1855    /// writer.
1856    #[inline]
1857    fn end_object<W>(&mut self, writer: &mut W) -> io::Result<()>
1858    where
1859        W: ?Sized + io::Write,
1860    {
1861        writer.write_all(b"}")
1862    }
1863
1864    /// Called before every object key.
1865    #[inline]
1866    fn begin_object_key<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
1867    where
1868        W: ?Sized + io::Write,
1869    {
1870        if first {
1871            Ok(())
1872        } else {
1873            writer.write_all(b",")
1874        }
1875    }
1876
1877    /// Called after every object key.  A `:` should be written to the
1878    /// specified writer by either this method or
1879    /// `begin_object_value`.
1880    #[inline]
1881    fn end_object_key<W>(&mut self, _writer: &mut W) -> io::Result<()>
1882    where
1883        W: ?Sized + io::Write,
1884    {
1885        Ok(())
1886    }
1887
1888    /// Called before every object value.  A `:` should be written to
1889    /// the specified writer by either this method or
1890    /// `end_object_key`.
1891    #[inline]
1892    fn begin_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
1893    where
1894        W: ?Sized + io::Write,
1895    {
1896        writer.write_all(b":")
1897    }
1898
1899    /// Called after every object value.
1900    #[inline]
1901    fn end_object_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
1902    where
1903        W: ?Sized + io::Write,
1904    {
1905        Ok(())
1906    }
1907
1908    /// Writes a raw JSON fragment that doesn't need any escaping to the
1909    /// specified writer.
1910    #[inline]
1911    fn write_raw_fragment<W>(&mut self, writer: &mut W, fragment: &str) -> io::Result<()>
1912    where
1913        W: ?Sized + io::Write,
1914    {
1915        writer.write_all(fragment.as_bytes())
1916    }
1917}
1918
1919/// This structure compacts a JSON value with no extra whitespace.
1920#[derive(Clone, Debug)]
1921pub struct CompactFormatter;
1922
1923impl Formatter for CompactFormatter {}
1924
1925/// This structure pretty prints a JSON value to make it human readable.
1926#[derive(Clone, Debug)]
1927pub struct PrettyFormatter<'a> {
1928    current_indent: usize,
1929    has_value: bool,
1930    indent: &'a [u8],
1931}
1932
1933impl<'a> PrettyFormatter<'a> {
1934    /// Construct a pretty printer formatter that defaults to using two spaces for indentation.
1935    pub fn new() -> Self {
1936        PrettyFormatter::with_indent(b"  ")
1937    }
1938
1939    /// Construct a pretty printer formatter that uses the `indent` string for indentation.
1940    pub fn with_indent(indent: &'a [u8]) -> Self {
1941        PrettyFormatter {
1942            current_indent: 0,
1943            has_value: false,
1944            indent,
1945        }
1946    }
1947}
1948
1949impl<'a> Default for PrettyFormatter<'a> {
1950    fn default() -> Self {
1951        PrettyFormatter::new()
1952    }
1953}
1954
1955impl<'a> Formatter for PrettyFormatter<'a> {
1956    #[inline]
1957    fn begin_array<W>(&mut self, writer: &mut W) -> io::Result<()>
1958    where
1959        W: ?Sized + io::Write,
1960    {
1961        self.current_indent += 1;
1962        self.has_value = false;
1963        writer.write_all(b"[")
1964    }
1965
1966    #[inline]
1967    fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
1968    where
1969        W: ?Sized + io::Write,
1970    {
1971        self.current_indent -= 1;
1972
1973        if self.has_value {
1974            tri!(writer.write_all(b"\n"));
1975            tri!(indent(writer, self.current_indent, self.indent));
1976        }
1977
1978        writer.write_all(b"]")
1979    }
1980
1981    #[inline]
1982    fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
1983    where
1984        W: ?Sized + io::Write,
1985    {
1986        tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
1987        indent(writer, self.current_indent, self.indent)
1988    }
1989
1990    #[inline]
1991    fn end_array_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
1992    where
1993        W: ?Sized + io::Write,
1994    {
1995        self.has_value = true;
1996        Ok(())
1997    }
1998
1999    #[inline]
2000    fn begin_object<W>(&mut self, writer: &mut W) -> io::Result<()>
2001    where
2002        W: ?Sized + io::Write,
2003    {
2004        self.current_indent += 1;
2005        self.has_value = false;
2006        writer.write_all(b"{")
2007    }
2008
2009    #[inline]
2010    fn end_object<W>(&mut self, writer: &mut W) -> io::Result<()>
2011    where
2012        W: ?Sized + io::Write,
2013    {
2014        self.current_indent -= 1;
2015
2016        if self.has_value {
2017            tri!(writer.write_all(b"\n"));
2018            tri!(indent(writer, self.current_indent, self.indent));
2019        }
2020
2021        writer.write_all(b"}")
2022    }
2023
2024    #[inline]
2025    fn begin_object_key<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
2026    where
2027        W: ?Sized + io::Write,
2028    {
2029        tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
2030        indent(writer, self.current_indent, self.indent)
2031    }
2032
2033    #[inline]
2034    fn begin_object_value<W>(&mut self, writer: &mut W) -> io::Result<()>
2035    where
2036        W: ?Sized + io::Write,
2037    {
2038        writer.write_all(b": ")
2039    }
2040
2041    #[inline]
2042    fn end_object_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
2043    where
2044        W: ?Sized + io::Write,
2045    {
2046        self.has_value = true;
2047        Ok(())
2048    }
2049}
2050
2051fn format_escaped_str<W, F>(writer: &mut W, formatter: &mut F, value: &str) -> io::Result<()>
2052where
2053    W: ?Sized + io::Write,
2054    F: ?Sized + Formatter,
2055{
2056    tri!(formatter.begin_string(writer));
2057    tri!(format_escaped_str_contents(writer, formatter, value));
2058    formatter.end_string(writer)
2059}
2060
2061fn format_escaped_str_contents<W, F>(
2062    writer: &mut W,
2063    formatter: &mut F,
2064    value: &str,
2065) -> io::Result<()>
2066where
2067    W: ?Sized + io::Write,
2068    F: ?Sized + Formatter,
2069{
2070    let bytes = value.as_bytes();
2071
2072    let mut start = 0;
2073
2074    for (i, &byte) in bytes.iter().enumerate() {
2075        let escape = ESCAPE[byte as usize];
2076        if escape == 0 {
2077            continue;
2078        }
2079
2080        if start < i {
2081            tri!(formatter.write_string_fragment(writer, &value[start..i]));
2082        }
2083
2084        let char_escape = CharEscape::from_escape_table(escape, byte);
2085        tri!(formatter.write_char_escape(writer, char_escape));
2086
2087        start = i + 1;
2088    }
2089
2090    if start == bytes.len() {
2091        return Ok(());
2092    }
2093
2094    formatter.write_string_fragment(writer, &value[start..])
2095}
2096
2097const BB: u8 = b'b'; // \x08
2098const TT: u8 = b't'; // \x09
2099const NN: u8 = b'n'; // \x0A
2100const FF: u8 = b'f'; // \x0C
2101const RR: u8 = b'r'; // \x0D
2102const QU: u8 = b'"'; // \x22
2103const BS: u8 = b'\\'; // \x5C
2104const UU: u8 = b'u'; // \x00...\x1F except the ones above
2105const __: u8 = 0;
2106
2107// Lookup table of escape sequences. A value of b'x' at index i means that byte
2108// i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped.
2109static ESCAPE: [u8; 256] = [
2110    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
2111    UU, UU, UU, UU, UU, UU, UU, UU, BB, TT, NN, UU, FF, RR, UU, UU, // 0
2112    UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, // 1
2113    __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
2114    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3
2115    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4
2116    __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5
2117    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6
2118    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7
2119    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8
2120    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9
2121    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A
2122    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B
2123    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C
2124    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D
2125    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E
2126    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
2127];
2128
2129/// Serialize the given data structure as JSON into the I/O stream.
2130///
2131/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
2132///
2133/// # Errors
2134///
2135/// Serialization can fail if `T`'s implementation of `Serialize` decides to
2136/// fail, or if `T` contains a map with non-string keys.
2137#[inline]
2138#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
2139pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
2140where
2141    W: io::Write,
2142    T: ?Sized + Serialize,
2143{
2144    let mut ser = Serializer::new(writer);
2145    value.serialize(&mut ser)
2146}
2147
2148/// Serialize the given data structure as pretty-printed JSON into the I/O
2149/// stream.
2150///
2151/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
2152///
2153/// # Errors
2154///
2155/// Serialization can fail if `T`'s implementation of `Serialize` decides to
2156/// fail, or if `T` contains a map with non-string keys.
2157#[inline]
2158#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
2159pub fn to_writer_pretty<W, T>(writer: W, value: &T) -> Result<()>
2160where
2161    W: io::Write,
2162    T: ?Sized + Serialize,
2163{
2164    let mut ser = Serializer::pretty(writer);
2165    value.serialize(&mut ser)
2166}
2167
2168/// Serialize the given data structure as a JSON byte vector.
2169///
2170/// # Errors
2171///
2172/// Serialization can fail if `T`'s implementation of `Serialize` decides to
2173/// fail, or if `T` contains a map with non-string keys.
2174#[inline]
2175pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
2176where
2177    T: ?Sized + Serialize,
2178{
2179    let mut writer = Vec::with_capacity(128);
2180    tri!(to_writer(&mut writer, value));
2181    Ok(writer)
2182}
2183
2184/// Serialize the given data structure as a pretty-printed JSON byte vector.
2185///
2186/// # Errors
2187///
2188/// Serialization can fail if `T`'s implementation of `Serialize` decides to
2189/// fail, or if `T` contains a map with non-string keys.
2190#[inline]
2191pub fn to_vec_pretty<T>(value: &T) -> Result<Vec<u8>>
2192where
2193    T: ?Sized + Serialize,
2194{
2195    let mut writer = Vec::with_capacity(128);
2196    tri!(to_writer_pretty(&mut writer, value));
2197    Ok(writer)
2198}
2199
2200/// Serialize the given data structure as a String of JSON.
2201///
2202/// # Errors
2203///
2204/// Serialization can fail if `T`'s implementation of `Serialize` decides to
2205/// fail, or if `T` contains a map with non-string keys.
2206#[inline]
2207pub fn to_string<T>(value: &T) -> Result<String>
2208where
2209    T: ?Sized + Serialize,
2210{
2211    let vec = tri!(to_vec(value));
2212    let string = unsafe {
2213        // We do not emit invalid UTF-8.
2214        String::from_utf8_unchecked(vec)
2215    };
2216    Ok(string)
2217}
2218
2219/// Serialize the given data structure as a pretty-printed String of JSON.
2220///
2221/// # Errors
2222///
2223/// Serialization can fail if `T`'s implementation of `Serialize` decides to
2224/// fail, or if `T` contains a map with non-string keys.
2225#[inline]
2226pub fn to_string_pretty<T>(value: &T) -> Result<String>
2227where
2228    T: ?Sized + Serialize,
2229{
2230    let vec = tri!(to_vec_pretty(value));
2231    let string = unsafe {
2232        // We do not emit invalid UTF-8.
2233        String::from_utf8_unchecked(vec)
2234    };
2235    Ok(string)
2236}
2237
2238fn indent<W>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
2239where
2240    W: ?Sized + io::Write,
2241{
2242    for _ in 0..n {
2243        tri!(wr.write_all(s));
2244    }
2245
2246    Ok(())
2247}
serde_json/ser.rs

serde_json/
ser.rs
