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