sonic_rs/serde/
ser.rs

1//! Serialize a Rust data structure into JSON data.
2
3// The code is cloned from [serde_json](https://github.com/serde-rs/json) and modified necessary parts.
4
5use core::{
6    fmt::{self, Display},
7    num::FpCategory,
8};
9use std::{io, str};
10
11use faststr::FastStr;
12use serde::{
13    de::Unexpected,
14    ser::{self, Impossible, Serialize, Serializer as SerdeSerializer},
15};
16
17use super::de::tri;
18use crate::{
19    config::SerializeCfg,
20    error::{Error, ErrorCode, Result},
21    format::{CompactFormatter, Formatter, PrettyFormatter},
22    lazyvalue::value::HasEsc,
23    writer::WriteExt,
24    OwnedLazyValue,
25};
26/// A structure for serializing Rust values into JSON.
27pub struct Serializer<W, F = CompactFormatter> {
28    writer: W,
29    formatter: F,
30    // TODO: record has_escape to optimize lazyvalue
31    // has_escape: bool,
32    cfg: SerializeCfg,
33}
34
35impl<W> Serializer<W>
36where
37    W: WriteExt,
38{
39    /// Creates a new JSON serializer.
40    #[inline]
41    pub fn new(writer: W) -> Self {
42        Serializer::with_formatter(writer, CompactFormatter)
43    }
44}
45
46impl<'a, W> Serializer<W, PrettyFormatter<'a>>
47where
48    W: WriteExt,
49{
50    /// Creates a new JSON pretty print serializer.
51    #[inline]
52    pub fn pretty(writer: W) -> Self {
53        Serializer::with_formatter(writer, PrettyFormatter::new())
54    }
55}
56
57impl<W, F> Serializer<W, F>
58where
59    W: WriteExt,
60    F: Formatter,
61{
62    /// Creates a new JSON visitor whose output will be written to the writer
63    /// specified.
64    #[inline]
65    pub fn with_formatter(writer: W, formatter: F) -> Self {
66        Serializer {
67            writer,
68            formatter,
69            cfg: SerializeCfg::default(),
70        }
71    }
72
73    /// Enable sorting map keys before serialization.
74    ///
75    /// # Examples
76    /// ```
77    /// use serde::Serialize;
78    /// use sonic_rs::{Serializer, json};
79    /// let mut ser = Serializer::new(Vec::new()).sort_map_keys();
80    /// let value = json!({"b": 1, "a": 2, "c": 3});
81    /// value.serialize(&mut ser).unwrap();
82    /// assert_eq!(ser.into_inner(), br#"{"a":2,"b":1,"c":3}"#);
83    /// ```
84    #[inline]
85    pub fn sort_map_keys(mut self) -> Self {
86        self.cfg.sort_map_keys = true;
87        self
88    }
89
90    pub(crate) fn with_cfg(mut self, cfg: SerializeCfg) -> Self {
91        self.cfg = cfg;
92        self
93    }
94
95    /// Unwrap the `Writer` from the `Serializer`.
96    #[inline]
97    pub fn into_inner(self) -> W {
98        self.writer
99    }
100}
101
102impl<'a, W, F> ser::Serializer for &'a mut Serializer<W, F>
103where
104    W: WriteExt,
105    F: Formatter + Clone,
106{
107    type Ok = ();
108    type Error = Error;
109
110    type SerializeSeq = Compound<'a, W, F>;
111    type SerializeTuple = Compound<'a, W, F>;
112    type SerializeTupleStruct = Compound<'a, W, F>;
113    type SerializeTupleVariant = Compound<'a, W, F>;
114    type SerializeMap = Compound<'a, W, F>;
115    type SerializeStruct = Compound<'a, W, F>;
116    type SerializeStructVariant = Compound<'a, W, F>;
117
118    #[inline]
119    fn serialize_bool(self, value: bool) -> Result<()> {
120        self.formatter
121            .write_bool(&mut self.writer, value)
122            .map_err(Error::io)
123    }
124
125    #[inline]
126    fn serialize_i8(self, value: i8) -> Result<()> {
127        self.formatter
128            .write_i8(&mut self.writer, value)
129            .map_err(Error::io)
130    }
131
132    #[inline]
133    fn serialize_i16(self, value: i16) -> Result<()> {
134        self.formatter
135            .write_i16(&mut self.writer, value)
136            .map_err(Error::io)
137    }
138
139    #[inline]
140    fn serialize_i32(self, value: i32) -> Result<()> {
141        self.formatter
142            .write_i32(&mut self.writer, value)
143            .map_err(Error::io)
144    }
145
146    #[inline]
147    fn serialize_i64(self, value: i64) -> Result<()> {
148        self.formatter
149            .write_i64(&mut self.writer, value)
150            .map_err(Error::io)
151    }
152
153    fn serialize_i128(self, value: i128) -> Result<()> {
154        self.formatter
155            .write_i128(&mut self.writer, value)
156            .map_err(Error::io)
157    }
158
159    #[inline]
160    fn serialize_u8(self, value: u8) -> Result<()> {
161        self.formatter
162            .write_u8(&mut self.writer, value)
163            .map_err(Error::io)
164    }
165
166    #[inline]
167    fn serialize_u16(self, value: u16) -> Result<()> {
168        self.formatter
169            .write_u16(&mut self.writer, value)
170            .map_err(Error::io)
171    }
172
173    #[inline]
174    fn serialize_u32(self, value: u32) -> Result<()> {
175        self.formatter
176            .write_u32(&mut self.writer, value)
177            .map_err(Error::io)
178    }
179
180    #[inline]
181    fn serialize_u64(self, value: u64) -> Result<()> {
182        self.formatter
183            .write_u64(&mut self.writer, value)
184            .map_err(Error::io)
185    }
186
187    fn serialize_u128(self, value: u128) -> Result<()> {
188        self.formatter
189            .write_u128(&mut self.writer, value)
190            .map_err(Error::io)
191    }
192
193    #[inline]
194    fn serialize_f32(self, value: f32) -> Result<()> {
195        match value.classify() {
196            FpCategory::Nan | FpCategory::Infinite => self
197                .formatter
198                .write_null(&mut self.writer)
199                .map_err(Error::io),
200            _ => self
201                .formatter
202                .write_f32(&mut self.writer, value)
203                .map_err(Error::io),
204        }
205    }
206
207    #[inline]
208    fn serialize_f64(self, value: f64) -> Result<()> {
209        match value.classify() {
210            FpCategory::Nan | FpCategory::Infinite => self
211                .formatter
212                .write_null(&mut self.writer)
213                .map_err(Error::io),
214            _ => self
215                .formatter
216                .write_f64(&mut self.writer, value)
217                .map_err(Error::io),
218        }
219    }
220
221    #[inline]
222    fn serialize_char(self, value: char) -> Result<()> {
223        // A char encoded as UTF-8 takes 4 bytes at most.
224        let mut buf = [0; 4];
225        self.serialize_str(value.encode_utf8(&mut buf))
226    }
227
228    #[inline]
229    fn serialize_str(self, value: &str) -> Result<()> {
230        self.formatter
231            .write_string_fast(&mut self.writer, value, true)
232            .map_err(Error::io)
233    }
234
235    #[inline]
236    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
237        use serde::ser::SerializeSeq;
238        let mut seq = tri!(self.serialize_seq(Some(value.len())));
239        for byte in value {
240            tri!(seq.serialize_element(byte));
241        }
242        seq.end()
243    }
244
245    #[inline]
246    fn serialize_unit(self) -> Result<()> {
247        self.formatter
248            .write_null(&mut self.writer)
249            .map_err(Error::io)
250    }
251
252    #[inline]
253    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
254        self.serialize_unit()
255    }
256
257    #[inline]
258    fn serialize_unit_variant(
259        self,
260        _name: &'static str,
261        _variant_index: u32,
262        variant: &'static str,
263    ) -> Result<()> {
264        self.serialize_str(variant)
265    }
266
267    /// Serialize newtypes without an object wrapper.
268    #[inline]
269    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
270    where
271        T: ?Sized + Serialize,
272    {
273        value.serialize(self)
274    }
275
276    #[inline]
277    fn serialize_newtype_variant<T>(
278        self,
279        _name: &'static str,
280        _variant_index: u32,
281        variant: &'static str,
282        value: &T,
283    ) -> Result<()>
284    where
285        T: ?Sized + Serialize,
286    {
287        tri!(self
288            .formatter
289            .begin_object(&mut self.writer)
290            .map_err(Error::io));
291        tri!(self
292            .formatter
293            .begin_object_key(&mut self.writer, true)
294            .map_err(Error::io));
295        tri!(self.serialize_str(variant));
296        tri!(self
297            .formatter
298            .end_object_key(&mut self.writer)
299            .map_err(Error::io));
300        tri!(self
301            .formatter
302            .begin_object_value(&mut self.writer)
303            .map_err(Error::io));
304        tri!(value.serialize(&mut *self));
305        tri!(self
306            .formatter
307            .end_object_value(&mut self.writer)
308            .map_err(Error::io));
309        self.formatter
310            .end_object(&mut self.writer)
311            .map_err(Error::io)
312    }
313
314    #[inline]
315    fn serialize_none(self) -> Result<()> {
316        self.serialize_unit()
317    }
318
319    #[inline]
320    fn serialize_some<T>(self, value: &T) -> Result<()>
321    where
322        T: ?Sized + Serialize,
323    {
324        value.serialize(self)
325    }
326
327    #[inline]
328    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
329        tri!(self
330            .formatter
331            .begin_array(&mut self.writer)
332            .map_err(Error::io));
333        if len == Some(0) {
334            tri!(self
335                .formatter
336                .end_array(&mut self.writer)
337                .map_err(Error::io));
338            Ok(Compound::Map {
339                ser: self,
340                state: MapState::Stream(State::Empty),
341            })
342        } else {
343            Ok(Compound::Map {
344                ser: self,
345                state: MapState::Stream(State::First),
346            })
347        }
348    }
349
350    #[inline]
351    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
352        self.serialize_seq(Some(len))
353    }
354
355    #[inline]
356    fn serialize_tuple_struct(
357        self,
358        _name: &'static str,
359        len: usize,
360    ) -> Result<Self::SerializeTupleStruct> {
361        self.serialize_seq(Some(len))
362    }
363
364    #[inline]
365    fn serialize_tuple_variant(
366        self,
367        _name: &'static str,
368        _variant_index: u32,
369        variant: &'static str,
370        len: usize,
371    ) -> Result<Self::SerializeTupleVariant> {
372        tri!(self
373            .formatter
374            .begin_object(&mut self.writer)
375            .map_err(Error::io));
376        tri!(self
377            .formatter
378            .begin_object_key(&mut self.writer, true)
379            .map_err(Error::io));
380        tri!(self.serialize_str(variant));
381        tri!(self
382            .formatter
383            .end_object_key(&mut self.writer)
384            .map_err(Error::io));
385        tri!(self
386            .formatter
387            .begin_object_value(&mut self.writer)
388            .map_err(Error::io));
389        self.serialize_seq(Some(len))
390    }
391
392    #[inline]
393    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
394        tri!(self
395            .formatter
396            .begin_object(&mut self.writer)
397            .map_err(Error::io));
398        if self.cfg.sort_map_keys {
399            Ok(Compound::Map {
400                ser: self,
401                state: MapState::Sorted {
402                    entries: Vec::with_capacity(len.unwrap_or(0)),
403                    next_key: None,
404                },
405            })
406        } else if len == Some(0) {
407            tri!(self
408                .formatter
409                .end_object(&mut self.writer)
410                .map_err(Error::io));
411            Ok(Compound::Map {
412                ser: self,
413                state: MapState::Stream(State::Empty),
414            })
415        } else {
416            Ok(Compound::Map {
417                ser: self,
418                state: MapState::Stream(State::First),
419            })
420        }
421    }
422
423    #[inline]
424    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
425        match name {
426            crate::serde::rawnumber::TOKEN | crate::lazyvalue::TOKEN => {
427                Ok(Compound::RawValue { ser: self })
428            }
429            _ => self.serialize_map(Some(len)),
430        }
431    }
432
433    #[inline]
434    fn serialize_struct_variant(
435        self,
436        _name: &'static str,
437        _variant_index: u32,
438        variant: &'static str,
439        len: usize,
440    ) -> Result<Self::SerializeStructVariant> {
441        tri!(self
442            .formatter
443            .begin_object(&mut self.writer)
444            .map_err(Error::io));
445        tri!(self
446            .formatter
447            .begin_object_key(&mut self.writer, true)
448            .map_err(Error::io));
449        tri!(self.serialize_str(variant));
450        tri!(self
451            .formatter
452            .end_object_key(&mut self.writer)
453            .map_err(Error::io));
454        tri!(self
455            .formatter
456            .begin_object_value(&mut self.writer)
457            .map_err(Error::io));
458        self.serialize_map(Some(len))
459    }
460
461    // Serialize a string produced by an implementation of Display. such as DataTime
462    fn collect_str<T>(self, value: &T) -> Result<()>
463    where
464        T: ?Sized + Display,
465    {
466        use self::fmt::Write;
467
468        struct Adapter<'ser, W: 'ser, F: 'ser> {
469            writer: &'ser mut W,
470            formatter: &'ser mut F,
471            error: Option<io::Error>,
472        }
473
474        impl<'ser, W, F> Write for Adapter<'ser, W, F>
475        where
476            W: WriteExt,
477            F: Formatter,
478        {
479            fn write_str(&mut self, s: &str) -> fmt::Result {
480                debug_assert!(self.error.is_none());
481                match self.formatter.write_string_fast(self.writer, s, false) {
482                    Ok(()) => Ok(()),
483                    Err(err) => {
484                        self.error = Some(err);
485                        Err(fmt::Error)
486                    }
487                }
488            }
489        }
490
491        tri!(self
492            .formatter
493            .begin_string(&mut self.writer)
494            .map_err(Error::io));
495        let mut adapter = Adapter {
496            writer: &mut self.writer,
497            formatter: &mut self.formatter,
498            error: None,
499        };
500
501        match write!(adapter, "{value}") {
502            Ok(()) => {
503                debug_assert!(adapter.error.is_none());
504            }
505            Err(fmt::Error) => {
506                return Err(Error::io(adapter.error.expect("there should be an error")))
507            }
508        }
509        tri!(self
510            .formatter
511            .end_string(&mut self.writer)
512            .map_err(Error::io));
513        Ok(())
514    }
515}
516
517// Not public API. Should be pub(crate).
518#[doc(hidden)]
519#[derive(Eq, PartialEq)]
520pub enum State {
521    Empty,
522    First,
523    Rest,
524}
525
526// Not public API. Should be pub(crate).
527#[doc(hidden)]
528pub enum Compound<'a, W: 'a, F: 'a> {
529    Map {
530        ser: &'a mut Serializer<W, F>,
531        state: MapState,
532    },
533
534    RawValue {
535        ser: &'a mut Serializer<W, F>,
536    },
537}
538
539pub enum MapState {
540    Stream(State),
541    Sorted {
542        entries: Vec<(String, Vec<u8>)>,
543        next_key: Option<String>,
544    },
545}
546
547fn write_sorted_entries<W, F>(
548    ser: &mut Serializer<W, F>,
549    mut entries: Vec<(String, Vec<u8>)>,
550) -> Result<()>
551where
552    W: WriteExt,
553    F: Formatter,
554{
555    entries.sort_by(|a, b| a.0.cmp(&b.0));
556
557    let mut first = true;
558    for (key, value_buf) in entries.into_iter() {
559        tri!(ser
560            .formatter
561            .begin_object_key(&mut ser.writer, first)
562            .map_err(Error::io));
563        first = false;
564
565        tri!(SerdeSerializer::serialize_str(&mut *ser, &key));
566
567        tri!(ser
568            .formatter
569            .end_object_key(&mut ser.writer)
570            .map_err(Error::io));
571
572        tri!(ser
573            .formatter
574            .begin_object_value(&mut ser.writer)
575            .map_err(Error::io));
576        let raw = unsafe { str::from_utf8_unchecked(&value_buf) };
577        tri!(ser
578            .formatter
579            .write_raw_value(&mut ser.writer, raw)
580            .map_err(Error::io));
581        tri!(ser
582            .formatter
583            .end_object_value(&mut ser.writer)
584            .map_err(Error::io));
585    }
586
587    ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
588}
589
590impl<'a, W, F> ser::SerializeSeq for Compound<'a, W, F>
591where
592    W: WriteExt,
593    F: Formatter,
594{
595    type Ok = ();
596    type Error = Error;
597
598    #[inline]
599    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
600    where
601        T: ?Sized + Serialize,
602    {
603        match self {
604            Compound::Map { ser, state } => match state {
605                MapState::Stream(ref mut map_state) => {
606                    tri!(ser
607                        .formatter
608                        .begin_array_value(&mut ser.writer, *map_state == State::First)
609                        .map_err(Error::io));
610                    *map_state = State::Rest;
611                    tri!(value.serialize(&mut **ser));
612                    ser.formatter
613                        .end_array_value(&mut ser.writer)
614                        .map_err(Error::io)
615                }
616
617                MapState::Sorted { .. } => unreachable!(),
618            },
619
620            Compound::RawValue { .. } => unreachable!(),
621        }
622    }
623
624    #[inline]
625    fn end(self) -> Result<()> {
626        match self {
627            Compound::Map { ser, state } => match state {
628                MapState::Stream(map_state) => match map_state {
629                    State::Empty => Ok(()),
630                    _ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io),
631                },
632
633                MapState::Sorted { .. } => unreachable!(),
634            },
635
636            Compound::RawValue { .. } => unreachable!(),
637        }
638    }
639}
640
641impl<'a, W, F> ser::SerializeTuple for Compound<'a, W, F>
642where
643    W: WriteExt,
644    F: Formatter,
645{
646    type Ok = ();
647    type Error = Error;
648
649    #[inline]
650    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
651    where
652        T: ?Sized + Serialize,
653    {
654        ser::SerializeSeq::serialize_element(self, value)
655    }
656
657    #[inline]
658    fn end(self) -> Result<()> {
659        ser::SerializeSeq::end(self)
660    }
661}
662
663impl<'a, W, F> ser::SerializeTupleStruct for Compound<'a, W, F>
664where
665    W: WriteExt,
666    F: Formatter,
667{
668    type Ok = ();
669    type Error = Error;
670
671    #[inline]
672    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
673    where
674        T: ?Sized + Serialize,
675    {
676        ser::SerializeSeq::serialize_element(self, value)
677    }
678
679    #[inline]
680    fn end(self) -> Result<()> {
681        ser::SerializeSeq::end(self)
682    }
683}
684
685impl<'a, W, F> ser::SerializeTupleVariant for Compound<'a, W, F>
686where
687    W: WriteExt,
688    F: Formatter,
689{
690    type Ok = ();
691    type Error = Error;
692
693    #[inline]
694    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
695    where
696        T: ?Sized + Serialize,
697    {
698        ser::SerializeSeq::serialize_element(self, value)
699    }
700
701    #[inline]
702    fn end(self) -> Result<()> {
703        match self {
704            Compound::Map { ser, state } => match state {
705                MapState::Stream(map_state) => {
706                    match map_state {
707                        State::Empty => {}
708                        _ => tri!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
709                    }
710                    tri!(ser
711                        .formatter
712                        .end_object_value(&mut ser.writer)
713                        .map_err(Error::io));
714                    ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
715                }
716
717                MapState::Sorted { entries, next_key } => {
718                    debug_assert!(next_key.is_none());
719                    write_sorted_entries(ser, entries)
720                }
721            },
722
723            Compound::RawValue { .. } => unreachable!(),
724        }
725    }
726}
727
728impl<'a, W, F> ser::SerializeMap for Compound<'a, W, F>
729where
730    W: WriteExt,
731    F: Formatter + Clone,
732{
733    type Ok = ();
734    type Error = Error;
735
736    #[inline]
737    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
738    where
739        T: ?Sized + Serialize,
740    {
741        match self {
742            Compound::Map { ser, state } => match state {
743                MapState::Stream(ref mut map_state) => {
744                    tri!(ser
745                        .formatter
746                        .begin_object_key(&mut ser.writer, *map_state == State::First)
747                        .map_err(Error::io));
748                    *map_state = State::Rest;
749
750                    tri!(key.serialize(MapKeySerializer { ser: *ser }));
751
752                    ser.formatter
753                        .end_object_key(&mut ser.writer)
754                        .map_err(Error::io)
755                }
756
757                MapState::Sorted { next_key, .. } => {
758                    let key_str = tri!(key.serialize(SortedKeySerializer));
759                    *next_key = Some(key_str);
760                    Ok(())
761                }
762            },
763
764            Compound::RawValue { .. } => unreachable!(),
765        }
766    }
767
768    #[inline]
769    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
770    where
771        T: ?Sized + Serialize,
772    {
773        match self {
774            Compound::Map { ser, state } => match state {
775                MapState::Stream(_) => {
776                    tri!(ser
777                        .formatter
778                        .begin_object_value(&mut ser.writer)
779                        .map_err(Error::io));
780                    tri!(value.serialize(&mut **ser));
781                    ser.formatter
782                        .end_object_value(&mut ser.writer)
783                        .map_err(Error::io)
784                }
785
786                MapState::Sorted { entries, next_key } => {
787                    let key = next_key
788                        .take()
789                        .expect("serialize_value called before serialize_key");
790                    let mut entry_ser =
791                        Serializer::with_formatter(Vec::with_capacity(128), ser.formatter.clone())
792                            .with_cfg(ser.cfg);
793                    tri!(value.serialize(&mut entry_ser));
794                    let stored = entry_ser.into_inner();
795                    entries.push((key, stored));
796                    Ok(())
797                }
798            },
799
800            Compound::RawValue { .. } => unreachable!(),
801        }
802    }
803
804    #[inline]
805    fn end(self) -> Result<()> {
806        match self {
807            Compound::Map { ser, state } => match state {
808                MapState::Stream(map_state) => match map_state {
809                    State::Empty => Ok(()),
810                    _ => ser.formatter.end_object(&mut ser.writer).map_err(Error::io),
811                },
812
813                MapState::Sorted { entries, next_key } => {
814                    debug_assert!(next_key.is_none());
815                    write_sorted_entries(ser, entries)
816                }
817            },
818
819            Compound::RawValue { .. } => unreachable!(),
820        }
821    }
822}
823
824impl<'a, W, F> ser::SerializeStruct for Compound<'a, W, F>
825where
826    W: WriteExt,
827    F: Formatter,
828{
829    type Ok = ();
830    type Error = Error;
831
832    #[inline]
833    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
834    where
835        T: ?Sized + Serialize,
836    {
837        match self {
838            Compound::Map { .. } => ser::SerializeMap::serialize_entry(self, key, value),
839
840            Compound::RawValue { ser, .. } => {
841                if key == crate::serde::rawnumber::TOKEN || key == crate::lazyvalue::TOKEN {
842                    value.serialize(RawValueStrEmitter(ser))
843                } else {
844                    Err(invalid_raw_value())
845                }
846            }
847        }
848    }
849
850    #[inline]
851    fn end(self) -> Result<()> {
852        match self {
853            Compound::Map { .. } => ser::SerializeMap::end(self),
854
855            Compound::RawValue { .. } => Ok(()),
856        }
857    }
858}
859
860impl<'a, W, F> ser::SerializeStructVariant for Compound<'a, W, F>
861where
862    W: WriteExt,
863    F: Formatter,
864{
865    type Ok = ();
866    type Error = Error;
867
868    #[inline]
869    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
870    where
871        T: ?Sized + Serialize,
872    {
873        match *self {
874            Compound::Map { .. } => ser::SerializeStruct::serialize_field(self, key, value),
875
876            Compound::RawValue { .. } => unreachable!(),
877        }
878    }
879
880    #[inline]
881    fn end(self) -> Result<()> {
882        match self {
883            Compound::Map { ser, state } => match state {
884                MapState::Stream(map_state) => {
885                    match map_state {
886                        State::Empty => {}
887                        _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
888                    }
889                    tri!(ser
890                        .formatter
891                        .end_object_value(&mut ser.writer)
892                        .map_err(Error::io));
893                    ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
894                }
895
896                MapState::Sorted { entries, next_key } => {
897                    debug_assert!(next_key.is_none());
898                    write_sorted_entries(ser, entries)
899                }
900            },
901
902            Compound::RawValue { .. } => unreachable!(),
903        }
904    }
905}
906
907struct MapKeySerializer<'a, W: 'a, F: 'a> {
908    ser: &'a mut Serializer<W, F>,
909}
910
911struct SortedKeySerializer;
912
913impl serde::Serializer for SortedKeySerializer {
914    type Ok = String;
915    type Error = Error;
916
917    type SerializeSeq = Impossible<String, Error>;
918    type SerializeTuple = Impossible<String, Error>;
919    type SerializeTupleStruct = Impossible<String, Error>;
920    type SerializeTupleVariant = Impossible<String, Error>;
921    type SerializeMap = Impossible<String, Error>;
922    type SerializeStruct = Impossible<String, Error>;
923    type SerializeStructVariant = Impossible<String, Error>;
924
925    #[inline]
926    fn serialize_bool(self, value: bool) -> Result<String> {
927        Ok(if value { "true" } else { "false" }.to_owned())
928    }
929
930    #[inline]
931    fn serialize_i8(self, value: i8) -> Result<String> {
932        self.serialize_i64(value as i64)
933    }
934
935    #[inline]
936    fn serialize_i16(self, value: i16) -> Result<String> {
937        self.serialize_i64(value as i64)
938    }
939
940    #[inline]
941    fn serialize_i32(self, value: i32) -> Result<String> {
942        self.serialize_i64(value as i64)
943    }
944
945    fn serialize_i64(self, value: i64) -> Result<String> {
946        let mut buf = itoa::Buffer::new();
947        Ok(buf.format(value).to_owned())
948    }
949
950    fn serialize_i128(self, value: i128) -> Result<String> {
951        Ok(value.to_string())
952    }
953
954    #[inline]
955    fn serialize_u8(self, value: u8) -> Result<String> {
956        self.serialize_u64(value as u64)
957    }
958
959    #[inline]
960    fn serialize_u16(self, value: u16) -> Result<String> {
961        self.serialize_u64(value as u64)
962    }
963
964    #[inline]
965    fn serialize_u32(self, value: u32) -> Result<String> {
966        self.serialize_u64(value as u64)
967    }
968
969    fn serialize_u64(self, value: u64) -> Result<String> {
970        let mut buf = itoa::Buffer::new();
971        Ok(buf.format(value).to_owned())
972    }
973
974    fn serialize_u128(self, value: u128) -> Result<String> {
975        Ok(value.to_string())
976    }
977
978    fn serialize_f32(self, value: f32) -> Result<String> {
979        if value.is_finite() {
980            let mut buf = zmij::Buffer::new();
981            Ok(buf.format_finite(value).to_owned())
982        } else {
983            Err(key_must_be_str_or_num(Unexpected::Other(
984                "NaN or Infinite f32",
985            )))
986        }
987    }
988
989    fn serialize_f64(self, value: f64) -> Result<String> {
990        if value.is_finite() {
991            let mut buf = zmij::Buffer::new();
992            Ok(buf.format_finite(value).to_owned())
993        } else {
994            Err(key_must_be_str_or_num(Unexpected::Other(
995                "NaN or Infinite f64",
996            )))
997        }
998    }
999
1000    #[inline]
1001    fn serialize_char(self, value: char) -> Result<String> {
1002        Ok(value.to_string())
1003    }
1004
1005    #[inline]
1006    fn serialize_str(self, value: &str) -> Result<String> {
1007        Ok(value.to_owned())
1008    }
1009
1010    fn serialize_bytes(self, _value: &[u8]) -> Result<String> {
1011        Err(key_must_be_str_or_num(Unexpected::Other("bytes")))
1012    }
1013
1014    fn serialize_unit(self) -> Result<String> {
1015        Err(key_must_be_str_or_num(Unexpected::Other("unit")))
1016    }
1017
1018    fn serialize_unit_struct(self, name: &'static str) -> Result<String> {
1019        Err(key_must_be_str_or_num(Unexpected::Other(name)))
1020    }
1021
1022    fn serialize_unit_variant(
1023        self,
1024        _name: &'static str,
1025        _variant_index: u32,
1026        variant: &'static str,
1027    ) -> Result<String> {
1028        Ok(variant.to_owned())
1029    }
1030
1031    fn serialize_newtype_variant<T>(
1032        self,
1033        _name: &'static str,
1034        _variant_index: u32,
1035        _variant: &'static str,
1036        _value: &T,
1037    ) -> Result<String>
1038    where
1039        T: ?Sized + Serialize,
1040    {
1041        Err(key_must_be_str_or_num(Unexpected::NewtypeVariant))
1042    }
1043
1044    fn serialize_none(self) -> Result<String> {
1045        Err(key_must_be_str_or_num(Unexpected::Other("none")))
1046    }
1047
1048    fn serialize_some<T>(self, value: &T) -> Result<String>
1049    where
1050        T: ?Sized + Serialize,
1051    {
1052        value.serialize(self)
1053    }
1054
1055    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<String>
1056    where
1057        T: ?Sized + Serialize,
1058    {
1059        value.serialize(self)
1060    }
1061
1062    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1063        Err(key_must_be_str_or_num(Unexpected::Seq))
1064    }
1065
1066    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1067        Err(key_must_be_str_or_num(Unexpected::Other("tuple")))
1068    }
1069
1070    fn serialize_tuple_struct(
1071        self,
1072        _name: &'static str,
1073        _len: usize,
1074    ) -> Result<Self::SerializeTupleStruct> {
1075        Err(key_must_be_str_or_num(Unexpected::Other("tuple_struct")))
1076    }
1077
1078    fn serialize_tuple_variant(
1079        self,
1080        _name: &'static str,
1081        _variant_index: u32,
1082        _variant: &'static str,
1083        _len: usize,
1084    ) -> Result<Self::SerializeTupleVariant> {
1085        Err(key_must_be_str_or_num(Unexpected::TupleVariant))
1086    }
1087
1088    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1089        Err(key_must_be_str_or_num(Unexpected::Map))
1090    }
1091
1092    fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1093        Err(key_must_be_str_or_num(Unexpected::Other(name)))
1094    }
1095
1096    fn serialize_struct_variant(
1097        self,
1098        _name: &'static str,
1099        _variant_index: u32,
1100        _variant: &'static str,
1101        _len: usize,
1102    ) -> Result<Self::SerializeStructVariant> {
1103        Err(key_must_be_str_or_num(Unexpected::StructVariant))
1104    }
1105
1106    fn collect_str<T>(self, value: &T) -> Result<String>
1107    where
1108        T: ?Sized + Display,
1109    {
1110        Ok(value.to_string())
1111    }
1112}
1113
1114// TODO: fix the error info
1115fn invalid_raw_value() -> Error {
1116    Error::ser_error(ErrorCode::InvalidJsonValue)
1117}
1118
1119pub(crate) fn key_must_be_str_or_num(cur: Unexpected<'static>) -> Error {
1120    Error::ser_error(ErrorCode::SerExpectKeyIsStrOrNum(cur))
1121}
1122
1123macro_rules! quote {
1124    ($self:ident, $value:expr) => {{
1125        tri!($self
1126            .ser
1127            .formatter
1128            .begin_string(&mut $self.ser.writer)
1129            .map_err(Error::io));
1130        tri!($value.map_err(Error::io));
1131        return $self
1132            .ser
1133            .formatter
1134            .end_string(&mut $self.ser.writer)
1135            .map_err(Error::io);
1136    }};
1137}
1138
1139impl<'a, W, F> ser::Serializer for MapKeySerializer<'a, W, F>
1140where
1141    W: WriteExt,
1142    F: Formatter,
1143{
1144    type Ok = ();
1145    type Error = Error;
1146
1147    #[inline]
1148    fn serialize_str(self, value: &str) -> Result<()> {
1149        self.ser.serialize_str(value)
1150    }
1151
1152    #[inline]
1153    fn serialize_unit_variant(
1154        self,
1155        _name: &'static str,
1156        _variant_index: u32,
1157        variant: &'static str,
1158    ) -> Result<()> {
1159        self.ser.serialize_str(variant)
1160    }
1161
1162    #[inline]
1163    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
1164    where
1165        T: ?Sized + Serialize,
1166    {
1167        value.serialize(self)
1168    }
1169
1170    type SerializeSeq = Impossible<(), Error>;
1171    type SerializeTuple = Impossible<(), Error>;
1172    type SerializeTupleStruct = Impossible<(), Error>;
1173    type SerializeTupleVariant = Impossible<(), Error>;
1174    type SerializeMap = Impossible<(), Error>;
1175    type SerializeStruct = Compound<'a, W, F>;
1176    type SerializeStructVariant = Impossible<(), Error>;
1177
1178    fn serialize_bool(self, value: bool) -> Result<()> {
1179        quote!(
1180            self,
1181            self.ser.formatter.write_bool(&mut self.ser.writer, value)
1182        );
1183    }
1184
1185    fn serialize_i8(self, value: i8) -> Result<()> {
1186        quote!(
1187            self,
1188            self.ser.formatter.write_i8(&mut self.ser.writer, value)
1189        );
1190    }
1191
1192    fn serialize_i16(self, value: i16) -> Result<()> {
1193        quote!(
1194            self,
1195            self.ser.formatter.write_i16(&mut self.ser.writer, value)
1196        );
1197    }
1198
1199    fn serialize_i32(self, value: i32) -> Result<()> {
1200        quote!(
1201            self,
1202            self.ser.formatter.write_i32(&mut self.ser.writer, value)
1203        );
1204    }
1205
1206    fn serialize_i64(self, value: i64) -> Result<()> {
1207        quote!(
1208            self,
1209            self.ser.formatter.write_i64(&mut self.ser.writer, value)
1210        );
1211    }
1212
1213    fn serialize_i128(self, value: i128) -> Result<()> {
1214        quote!(
1215            self,
1216            self.ser.formatter.write_i128(&mut self.ser.writer, value)
1217        );
1218    }
1219
1220    fn serialize_u8(self, value: u8) -> Result<()> {
1221        quote!(
1222            self,
1223            self.ser.formatter.write_u8(&mut self.ser.writer, value)
1224        );
1225    }
1226
1227    fn serialize_u16(self, value: u16) -> Result<()> {
1228        quote!(
1229            self,
1230            self.ser.formatter.write_u16(&mut self.ser.writer, value)
1231        );
1232    }
1233
1234    fn serialize_u32(self, value: u32) -> Result<()> {
1235        quote!(
1236            self,
1237            self.ser.formatter.write_u32(&mut self.ser.writer, value)
1238        );
1239    }
1240
1241    fn serialize_u64(self, value: u64) -> Result<()> {
1242        quote!(
1243            self,
1244            self.ser.formatter.write_u64(&mut self.ser.writer, value)
1245        );
1246    }
1247
1248    fn serialize_u128(self, value: u128) -> Result<()> {
1249        quote!(
1250            self,
1251            self.ser.formatter.write_u128(&mut self.ser.writer, value)
1252        );
1253    }
1254
1255    fn serialize_f32(self, value: f32) -> Result<()> {
1256        if value.is_finite() {
1257            quote!(
1258                self,
1259                self.ser.formatter.write_f32(&mut self.ser.writer, value)
1260            )
1261        } else {
1262            Err(key_must_be_str_or_num(Unexpected::Other(
1263                "NaN or Infinite f32",
1264            )))
1265        }
1266    }
1267
1268    fn serialize_f64(self, value: f64) -> Result<()> {
1269        if value.is_finite() {
1270            quote!(
1271                self,
1272                self.ser.formatter.write_f64(&mut self.ser.writer, value)
1273            );
1274        } else {
1275            Err(key_must_be_str_or_num(Unexpected::Other(
1276                "NaN or Infinite f64",
1277            )))
1278        }
1279    }
1280
1281    fn serialize_char(self, value: char) -> Result<()> {
1282        self.ser.serialize_str(&value.to_string())
1283    }
1284
1285    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
1286        Err(key_must_be_str_or_num(Unexpected::Other("bytes")))
1287    }
1288
1289    fn serialize_unit(self) -> Result<()> {
1290        Err(key_must_be_str_or_num(Unexpected::Other("uint")))
1291    }
1292
1293    fn serialize_unit_struct(self, name: &'static str) -> Result<()> {
1294        Err(key_must_be_str_or_num(Unexpected::Other(name)))
1295    }
1296
1297    fn serialize_newtype_variant<T>(
1298        self,
1299        _name: &'static str,
1300        _variant_index: u32,
1301        _variant: &'static str,
1302        _value: &T,
1303    ) -> Result<()>
1304    where
1305        T: ?Sized + Serialize,
1306    {
1307        Err(key_must_be_str_or_num(Unexpected::NewtypeVariant))
1308    }
1309
1310    fn serialize_none(self) -> Result<()> {
1311        Err(key_must_be_str_or_num(Unexpected::Other("none")))
1312    }
1313
1314    fn serialize_some<T>(self, value: &T) -> Result<()>
1315    where
1316        T: ?Sized + Serialize,
1317    {
1318        value.serialize(self)
1319    }
1320
1321    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1322        Err(key_must_be_str_or_num(Unexpected::Seq))
1323    }
1324
1325    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1326        Err(key_must_be_str_or_num(Unexpected::Other("tuple")))
1327    }
1328
1329    fn serialize_tuple_struct(
1330        self,
1331        _name: &'static str,
1332        _len: usize,
1333    ) -> Result<Self::SerializeTupleStruct> {
1334        Err(key_must_be_str_or_num(Unexpected::Other("tuple_struct")))
1335    }
1336
1337    fn serialize_tuple_variant(
1338        self,
1339        _name: &'static str,
1340        _variant_index: u32,
1341        _variant: &'static str,
1342        _len: usize,
1343    ) -> Result<Self::SerializeTupleVariant> {
1344        Err(key_must_be_str_or_num(Unexpected::TupleVariant))
1345    }
1346
1347    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1348        Err(key_must_be_str_or_num(Unexpected::Map))
1349    }
1350
1351    fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1352        Err(key_must_be_str_or_num(Unexpected::Other(name)))
1353    }
1354
1355    fn serialize_struct_variant(
1356        self,
1357        _name: &'static str,
1358        _variant_index: u32,
1359        _variant: &'static str,
1360        _len: usize,
1361    ) -> Result<Self::SerializeStructVariant> {
1362        Err(key_must_be_str_or_num(Unexpected::StructVariant))
1363    }
1364
1365    fn collect_str<T>(self, value: &T) -> Result<()>
1366    where
1367        T: ?Sized + Display,
1368    {
1369        self.ser.collect_str(value)
1370    }
1371}
1372
1373struct RawValueStrEmitter<'a, W: 'a + WriteExt, F: 'a + Formatter>(&'a mut Serializer<W, F>);
1374
1375impl<'a, W: WriteExt, F: Formatter> ser::Serializer for RawValueStrEmitter<'a, W, F> {
1376    type Ok = ();
1377    type Error = Error;
1378
1379    type SerializeSeq = Impossible<(), Error>;
1380    type SerializeTuple = Impossible<(), Error>;
1381    type SerializeTupleStruct = Impossible<(), Error>;
1382    type SerializeTupleVariant = Impossible<(), Error>;
1383    type SerializeMap = Impossible<(), Error>;
1384    type SerializeStruct = Impossible<(), Error>;
1385    type SerializeStructVariant = Impossible<(), Error>;
1386
1387    fn serialize_bool(self, _v: bool) -> Result<()> {
1388        Err(ser::Error::custom("expected RawValue"))
1389    }
1390
1391    fn serialize_i8(self, _v: i8) -> Result<()> {
1392        Err(ser::Error::custom("expected RawValue"))
1393    }
1394
1395    fn serialize_i16(self, _v: i16) -> Result<()> {
1396        Err(ser::Error::custom("expected RawValue"))
1397    }
1398
1399    fn serialize_i32(self, _v: i32) -> Result<()> {
1400        Err(ser::Error::custom("expected RawValue"))
1401    }
1402
1403    fn serialize_i64(self, _v: i64) -> Result<()> {
1404        Err(ser::Error::custom("expected RawValue"))
1405    }
1406
1407    fn serialize_i128(self, _v: i128) -> Result<()> {
1408        Err(ser::Error::custom("expected RawValue"))
1409    }
1410
1411    fn serialize_u8(self, _v: u8) -> Result<()> {
1412        Err(ser::Error::custom("expected RawValue"))
1413    }
1414
1415    fn serialize_u16(self, _v: u16) -> Result<()> {
1416        Err(ser::Error::custom("expected RawValue"))
1417    }
1418
1419    fn serialize_u32(self, _v: u32) -> Result<()> {
1420        Err(ser::Error::custom("expected RawValue"))
1421    }
1422
1423    fn serialize_u64(self, _v: u64) -> Result<()> {
1424        Err(ser::Error::custom("expected RawValue"))
1425    }
1426
1427    fn serialize_u128(self, _v: u128) -> Result<()> {
1428        Err(ser::Error::custom("expected RawValue"))
1429    }
1430
1431    fn serialize_f32(self, _v: f32) -> Result<()> {
1432        Err(ser::Error::custom("expected RawValue"))
1433    }
1434
1435    fn serialize_f64(self, _v: f64) -> Result<()> {
1436        Err(ser::Error::custom("expected RawValue"))
1437    }
1438
1439    fn serialize_char(self, _v: char) -> Result<()> {
1440        Err(ser::Error::custom("expected RawValue"))
1441    }
1442
1443    fn serialize_str(self, value: &str) -> Result<()> {
1444        let RawValueStrEmitter(serializer) = self;
1445        serializer
1446            .formatter
1447            .write_raw_value(&mut serializer.writer, value)
1448            .map_err(Error::io)
1449    }
1450
1451    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
1452        Err(ser::Error::custom("expected RawValue"))
1453    }
1454
1455    fn serialize_none(self) -> Result<()> {
1456        Err(ser::Error::custom("expected RawValue"))
1457    }
1458
1459    fn serialize_some<T>(self, _value: &T) -> Result<()>
1460    where
1461        T: ?Sized + Serialize,
1462    {
1463        Err(ser::Error::custom("expected RawValue"))
1464    }
1465
1466    fn serialize_unit(self) -> Result<()> {
1467        Err(ser::Error::custom("expected RawValue"))
1468    }
1469
1470    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
1471        Err(ser::Error::custom("expected RawValue"))
1472    }
1473
1474    fn serialize_unit_variant(
1475        self,
1476        _name: &'static str,
1477        _variant_index: u32,
1478        _variant: &'static str,
1479    ) -> Result<()> {
1480        Err(ser::Error::custom("expected RawValue"))
1481    }
1482
1483    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
1484    where
1485        T: ?Sized + Serialize,
1486    {
1487        Err(ser::Error::custom("expected RawValue"))
1488    }
1489
1490    fn serialize_newtype_variant<T>(
1491        self,
1492        _name: &'static str,
1493        _variant_index: u32,
1494        _variant: &'static str,
1495        _value: &T,
1496    ) -> Result<()>
1497    where
1498        T: ?Sized + Serialize,
1499    {
1500        Err(ser::Error::custom("expected RawValue"))
1501    }
1502
1503    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
1504        Err(ser::Error::custom("expected RawValue"))
1505    }
1506
1507    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
1508        Err(ser::Error::custom("expected RawValue"))
1509    }
1510
1511    fn serialize_tuple_struct(
1512        self,
1513        _name: &'static str,
1514        _len: usize,
1515    ) -> Result<Self::SerializeTupleStruct> {
1516        Err(ser::Error::custom("expected RawValue"))
1517    }
1518
1519    fn serialize_tuple_variant(
1520        self,
1521        _name: &'static str,
1522        _variant_index: u32,
1523        _variant: &'static str,
1524        _len: usize,
1525    ) -> Result<Self::SerializeTupleVariant> {
1526        Err(ser::Error::custom("expected RawValue"))
1527    }
1528
1529    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
1530        Err(ser::Error::custom("expected RawValue"))
1531    }
1532
1533    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
1534        Err(ser::Error::custom("expected RawValue"))
1535    }
1536
1537    fn serialize_struct_variant(
1538        self,
1539        _name: &'static str,
1540        _variant_index: u32,
1541        _variant: &'static str,
1542        _len: usize,
1543    ) -> Result<Self::SerializeStructVariant> {
1544        Err(ser::Error::custom("expected RawValue"))
1545    }
1546
1547    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
1548    where
1549        T: ?Sized + Display,
1550    {
1551        self.serialize_str(&value.to_string())
1552    }
1553}
1554
1555/// Serialize the given data structure as JSON into the I/O stream.
1556///
1557/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
1558///
1559/// # Errors
1560///
1561/// Serialization can fail if `T`'s implementation of `Serialize` decides to
1562/// fail, or if `T` contains a map with non-string keys.
1563#[inline]
1564pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
1565where
1566    W: WriteExt,
1567    T: ?Sized + Serialize,
1568{
1569    let mut ser = Serializer::new(writer);
1570    value.serialize(&mut ser)
1571}
1572
1573/// Serialize the given data structure as pretty-printed JSON into the I/O
1574/// stream.
1575///
1576/// Serialization guarantees it only feeds valid UTF-8 sequences to the writer.
1577///
1578/// # Errors
1579///
1580/// Serialization can fail if `T`'s implementation of `Serialize` decides to
1581/// fail, or if `T` contains a map with non-string keys.
1582#[inline]
1583pub fn to_writer_pretty<W, T>(writer: W, value: &T) -> Result<()>
1584where
1585    W: WriteExt,
1586    T: ?Sized + Serialize,
1587{
1588    let mut ser = Serializer::with_formatter(writer, PrettyFormatter::new());
1589    value.serialize(&mut ser)
1590}
1591
1592/// Serialize the given data structure as a JSON byte vector.
1593///
1594/// # Errors
1595///
1596/// Serialization can fail if `T`'s implementation of `Serialize` decides to
1597/// fail, or if `T` contains a map with non-string keys.
1598#[inline]
1599pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
1600where
1601    T: ?Sized + Serialize,
1602{
1603    let mut writer = Vec::with_capacity(128);
1604    tri!(to_writer(&mut writer, value));
1605    Ok(writer)
1606}
1607
1608/// Serialize the given data structure as a pretty-printed JSON byte vector.
1609///
1610/// # Errors
1611///
1612/// Serialization can fail if `T`'s implementation of `Serialize` decides to
1613/// fail, or if `T` contains a map with non-string keys.
1614#[inline]
1615pub fn to_vec_pretty<T>(value: &T) -> Result<Vec<u8>>
1616where
1617    T: ?Sized + Serialize,
1618{
1619    let mut writer = Vec::with_capacity(128);
1620    tri!(to_writer_pretty(&mut writer, value));
1621    Ok(writer)
1622}
1623
1624/// Serialize the given data structure as a String of JSON.
1625///
1626/// # Errors
1627///
1628/// Serialization can fail if `T`'s implementation of `Serialize` decides to
1629/// fail, or if `T` contains a map with non-string keys.
1630#[inline]
1631pub fn to_string<T>(value: &T) -> Result<String>
1632where
1633    T: ?Sized + Serialize,
1634{
1635    let vec = tri!(to_vec(value));
1636    let string = unsafe {
1637        // We do not emit Invalid UTF-8.
1638        String::from_utf8_unchecked(vec)
1639    };
1640    Ok(string)
1641}
1642
1643/// Serialize the given data structure as a OwnedLazyValue of JSON.
1644#[inline]
1645pub fn to_lazyvalue<T>(value: &T) -> Result<OwnedLazyValue>
1646where
1647    T: ?Sized + Serialize,
1648{
1649    let vec = tri!(to_vec(value));
1650    let string = unsafe {
1651        // We do not emit Invalid UTF-8.
1652        String::from_utf8_unchecked(vec)
1653    };
1654
1655    Ok(OwnedLazyValue::new(
1656        FastStr::new(string).into(),
1657        HasEsc::Possible,
1658    ))
1659}
1660
1661/// Serialize the given data structure as a pretty-printed String of JSON.
1662///
1663/// # Errors
1664///
1665/// Serialization can fail if `T`'s implementation of `Serialize` decides to
1666/// fail, or if `T` contains a map with non-string keys.
1667#[inline]
1668pub fn to_string_pretty<T>(value: &T) -> Result<String>
1669where
1670    T: ?Sized + Serialize,
1671{
1672    let vec = tri!(to_vec_pretty(value));
1673    let string = unsafe {
1674        // We do not emit Invalid UTF-8.
1675        String::from_utf8_unchecked(vec)
1676    };
1677    Ok(string)
1678}
1679
1680#[cfg(test)]
1681mod test {
1682    use std::io;
1683
1684    use crate::{json, writer::BufferedWriter};
1685
1686    #[test]
1687    fn behaves_equal() {
1688        let object = json!({
1689            "hello": "world",
1690            "this_is_considered": "fast"
1691        });
1692
1693        let mut cursor: io::Cursor<Vec<u8>> = io::Cursor::new(Vec::new());
1694        let writer = BufferedWriter::new(&mut cursor);
1695        crate::to_writer(writer, &object).unwrap();
1696
1697        let vec = crate::to_vec(&object).unwrap();
1698
1699        assert_eq!(vec, cursor.into_inner());
1700    }
1701}
sonic_rs/serde/ser.rs

sonic_rs/serde/
ser.rs
