序列化一侧

pub struct Serializer<W, F = CompactFormatter> {
    writer: W,
    formatter: F,
}

    type Ok = ();
    type Error = Error;

    type SerializeSeq = Compound<'a, W, F>;
    type SerializeTuple = Compound<'a, W, F>;
    type SerializeTupleStruct = Compound<'a, W, F>;
    type SerializeTupleVariant = Compound<'a, W, F>;
    type SerializeMap = Compound<'a, W, F>;
    type SerializeStruct = Compound<'a, W, F>;
    type SerializeStructVariant = Compound<'a, W, F>;

fn main() {
  let text = serde_json::to_string(&vec![1.5f64, f64::NAN, f64::INFINITY]).unwrap();
  println!("to_string       {text}");
  let back: Result<Vec<f64>, _> = serde_json::from_str(&text);
  println!("from_str f64    {:?}", back.map_err(|e| e.to_string()));
  let opt: Vec<Option<f64>> = serde_json::from_str(&text).unwrap();
  println!("from_str Option {opt:?}");
}

to_string       [1.5,null,null]
from_str f64    Err("invalid type: null, expected f64 at line 1 column 9")
from_str Option [Some(1.5), None, None]

// Not public API. Should be pub(crate).
#[doc(hidden)]
#[derive(Eq, PartialEq)]
pub enum State {
    Empty,
    First,
    Rest,
}

// Not public API. Should be pub(crate).
#[doc(hidden)]
pub enum Compound<'a, W: 'a, F: 'a> {
    Map {
        ser: &'a mut Serializer<W, F>,
        state: State,
    },
    #[cfg(feature = "arbitrary_precision")]
    Number { ser: &'a mut Serializer<W, F> },
    #[cfg(feature = "raw_value")]
    RawValue { ser: &'a mut Serializer<W, F> },
}

    #[inline]
    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
    where
        T: ?Sized + Serialize,
    {
        match self {
            Compound::Map { ser, state } => {
                tri!(ser
                    .formatter
                    .begin_array_value(&mut ser.writer, *state == State::First)
                    .map_err(Error::io));
                *state = State::Rest;
                tri!(value.serialize(&mut **ser));
                ser.formatter
                    .end_array_value(&mut ser.writer)
                    .map_err(Error::io)
            }
            // ...
        }
    }

    #[inline]
    fn end(self) -> Result<()> {
        match self {
            Compound::Map { ser, state } => match state {
                State::Empty => Ok(()),
                _ => ser.formatter.end_array(&mut ser.writer).map_err(Error::io),
            },
            // ...
        }
    }

    #[inline]
    fn end(self) -> Result<()> {
        match self {
            Compound::Map { ser, state } => {
                match state {
                    State::Empty => {}
                    _ => tri!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
                }
                tri!(ser
                    .formatter
                    .end_object_value(&mut ser.writer)
                    .map_err(Error::io));
                ser.formatter.end_object(&mut ser.writer).map_err(Error::io)
            }
            // ...
        }
    }

impl Formatter for CompactFormatter {}

use serde::Serialize;
use serde_json::ser::{CompactFormatter, Formatter, Serializer};
use std::io::{self, Write};

#[derive(Serialize)]
struct Post {
  title: String,
  tags: Vec<&'static str>,
  draft: Option<bool>,
}

// Logs each Formatter hook, then lets CompactFormatter write the bytes.
struct Log(CompactFormatter);

macro_rules! hook {
  ($name:ident) => {
    fn $name<W: ?Sized + Write>(&mut self, w: &mut W) -> io::Result<()> {
      println!("{}", stringify!($name));
      self.0.$name(w)
    }
  };
  ($name:ident, first) => {
    fn $name<W: ?Sized + Write>(&mut self, w: &mut W, first: bool) -> io::Result<()> {
      println!("{}(first={first})", stringify!($name));
      self.0.$name(w, first)
    }
  };
}

impl Formatter for Log {
  hook!(begin_object);
  hook!(end_object);
  hook!(begin_object_key, first);
  hook!(end_object_key);
  hook!(begin_object_value);
  hook!(end_object_value);
  hook!(begin_array);
  hook!(end_array);
  hook!(begin_array_value, first);
  hook!(end_array_value);
  hook!(begin_string);
  hook!(end_string);
  hook!(write_null);

  fn write_string_fragment<W: ?Sized + Write>(&mut self, w: &mut W, s: &str) -> io::Result<()> {
    println!("write_string_fragment({s:?})");
    self.0.write_string_fragment(w, s)
  }
}

fn main() {
  let post = Post { title: "serde".into(), tags: vec!["rust", "json"], draft: None };
  let mut out = Vec::new();
  post.serialize(&mut Serializer::with_formatter(&mut out, Log(CompactFormatter))).unwrap();
  println!("=> {}", String::from_utf8(out).unwrap());
  println!("pretty =>\n{}", serde_json::to_string_pretty(&post).unwrap());
  let mut out = Vec::new();
  let fmt = serde_json::ser::PrettyFormatter::with_indent(b"\t");
  post.serialize(&mut Serializer::with_formatter(&mut out, fmt)).unwrap();
  println!("tab   => {:?}", String::from_utf8(out).unwrap());
  let empty: (Vec<u8>, std::collections::BTreeMap<String, u8>) = (vec![], Default::default());
  println!("empty => {}", serde_json::to_string_pretty(&empty).unwrap());
}

begin_object
begin_object_key(first=true)
begin_string
write_string_fragment("title")
end_string
end_object_key
begin_object_value
begin_string
write_string_fragment("serde")
end_string
end_object_value
begin_object_key(first=false)
begin_string
write_string_fragment("tags")
end_string
end_object_key
begin_object_value
begin_array
begin_array_value(first=true)
begin_string
write_string_fragment("rust")
end_string
end_array_value
begin_array_value(first=false)
begin_string
write_string_fragment("json")
end_string
end_array_value
end_array
end_object_value
begin_object_key(first=false)
begin_string
write_string_fragment("draft")
end_string
end_object_key
begin_object_value
write_null
end_object_value
end_object
=> {"title":"serde","tags":["rust","json"],"draft":null}
pretty =>
{
  "title": "serde",
  "tags": [
    "rust",
    "json"
  ],
  "draft": null
}
tab   => "{\n\t\"title\": \"serde\",\n\t\"tags\": [\n\t\t\"rust\",\n\t\t\"json\"\n\t],\n\t\"draft\": null\n}"
empty => [
  [],
  {}
]

pub struct PrettyFormatter<'a> {
    current_indent: usize,
    has_value: bool,
    indent: &'a [u8],
}

    #[inline]
    fn begin_array<W>(&mut self, writer: &mut W) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        self.current_indent += 1;
        self.has_value = false;
        writer.write_all(b"[")
    }

    #[inline]
    fn end_array<W>(&mut self, writer: &mut W) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        self.current_indent -= 1;

        if self.has_value {
            tri!(writer.write_all(b"\n"));
            tri!(indent(writer, self.current_indent, self.indent));
        }

        writer.write_all(b"]")
    }

    #[inline]
    fn begin_array_value<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        tri!(writer.write_all(if first { b"\n" } else { b",\n" }));
        indent(writer, self.current_indent, self.indent)
    }

    #[inline]
    fn end_array_value<W>(&mut self, _writer: &mut W) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        self.has_value = true;
        Ok(())
    }

const BB: u8 = b'b'; // \x08
const TT: u8 = b't'; // \x09
const NN: u8 = b'n'; // \x0A
const FF: u8 = b'f'; // \x0C
const RR: u8 = b'r'; // \x0D
const QU: u8 = b'"'; // \x22
const BS: u8 = b'\\'; // \x5C
const UU: u8 = b'u'; // \x00...\x1F except the ones above
const __: u8 = 0;

// Lookup table of escape sequences. A value of b'x' at index i means that byte
// i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped.
static ESCAPE: [u8; 256] = [
    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
    UU, UU, UU, UU, UU, UU, UU, UU, BB, TT, NN, UU, FF, RR, UU, UU, // 0
    UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, // 1
    __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
    // ...
    __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5
    // ...
    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
];

    let mut bytes = value.as_bytes();

    let mut i = 0;
    while i < bytes.len() {
        let (string_run, rest) = bytes.split_at(i);
        let (&byte, rest) = rest.split_first().unwrap();

        let escape = ESCAPE[byte as usize];

        i += 1;
        if escape == 0 {
            continue;
        }

        bytes = rest;
        i = 0;

        // Safety: string_run is a valid utf8 string, since we only split on ascii sequences
        let string_run = unsafe { str::from_utf8_unchecked(string_run) };
        if !string_run.is_empty() {
            tri!(formatter.write_string_fragment(writer, string_run));
        }

        let char_escape = match escape {
            self::BB => CharEscape::Backspace,
            // ...
            self::UU => CharEscape::AsciiControl(byte),
            // Safety: the escape table does not contain any other type of character.
            _ => unsafe { hint::unreachable_unchecked() },
        };
        tri!(formatter.write_char_escape(writer, char_escape));
    }

    // Safety: bytes is a valid utf8 string, since we only split on ascii sequences
    let string_run = unsafe { str::from_utf8_unchecked(bytes) };
    if string_run.is_empty() {
        return Ok(());
    }

    formatter.write_string_fragment(writer, string_run)

use serde_bytes_like::Bytes;

mod serde_bytes_like {
  // A &[u8] that calls serialize_bytes (Vec<u8> would call serialize_seq).
  pub struct Bytes<'a>(pub &'a [u8]);
  impl serde::Serialize for Bytes<'_> {
    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
      s.serialize_bytes(self.0)
    }
  }
}

fn show<T: serde::Serialize + ?Sized>(label: &str, v: &T) {
  let json = serde_json::to_string(v).unwrap();
  // Non-ASCII output bytes are shown as Rust escapes so they are visible.
  let shown: String = json.chars().map(|c| if c.is_ascii() { c.to_string() } else { c.escape_unicode().to_string() }).collect();
  let shown = shown.replace('\x7f', "<DEL>");
  println!("{label:<22} {shown}  ({} bytes)", json.len());
}

fn main() {
  show("quote backslash", "a\"b\\c");
  show("slash", "</script>");
  show("\\n \\t \\r \\x08 \\x0c", "\n\t\r\u{8}\u{c}");
  show("\\x01 \\x1f", "\u{1}\u{1f}");
  show("\\x7f (DEL)", "\u{7f}");
  show("non-ASCII", "é中😀");
  show("U+2028 (LS)", "\u{2028}");
  show("char '\\0'", &'\0');
  show("f64 1.0", &1.0f64);
  show("f64 0.1+0.2", &(0.1f64 + 0.2));
  show("f64 1e20", &1e20f64);
  show("f64 1e-7", &1e-7f64);
  show("f64 -0.0", &-0.0f64);
  show("f64 MAX", &f64::MAX);
  show("f32 0.1", &0.1f32);
  show("f64 from 0.1f32", &(0.1f32 as f64));
  show("f64 NaN", &f64::NAN);
  show("f64 -inf", &f64::NEG_INFINITY);
  show("u64 MAX", &u64::MAX);
  show("i128 MIN", &i128::MIN);
  show("u128 MAX", &u128::MAX);
  show("Vec<u8>", &vec![1u8, 2, 3]);
  show("serialize_bytes", &Bytes(&[1, 2, 3]));
  show("()", &());
  show("Some(()) ", &Some(()));
}

quote backslash        "a\"b\\c"  (9 bytes)
slash                  "</script>"  (11 bytes)
\n \t \r \x08 \x0c     "\n\t\r\b\f"  (12 bytes)
\x01 \x1f              "\u0001\u001f"  (14 bytes)
\x7f (DEL)             "<DEL>"  (3 bytes)
non-ASCII              "\u{e9}\u{4e2d}\u{1f600}"  (11 bytes)
U+2028 (LS)            "\u{2028}"  (5 bytes)
char '\0'              "\u0000"  (8 bytes)
f64 1.0                1.0  (3 bytes)
f64 0.1+0.2            0.30000000000000004  (19 bytes)
f64 1e20               1e+20  (5 bytes)
f64 1e-7               1e-7  (4 bytes)
f64 -0.0               -0.0  (4 bytes)
f64 MAX                1.7976931348623157e+308  (23 bytes)
f32 0.1                0.1  (3 bytes)
f64 from 0.1f32        0.10000000149011612  (19 bytes)
f64 NaN                null  (4 bytes)
f64 -inf               null  (4 bytes)
u64 MAX                18446744073709551615  (20 bytes)
i128 MIN               -170141183460469231731687303715884105728  (40 bytes)
u128 MAX               340282366920938463463374607431768211455  (39 bytes)
Vec<u8>                [1,2,3]  (7 bytes)
serialize_bytes        [1,2,3]  (7 bytes)
()                     null  (4 bytes)
Some(())               null  (4 bytes)

    #[inline]
    fn write_u64<W>(&mut self, writer: &mut W, value: u64) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        let mut buffer = itoa::Buffer::new();
        let s = buffer.format(value);
        writer.write_all(s.as_bytes())
    }

    #[inline]
    fn write_f64<W>(&mut self, writer: &mut W, value: f64) -> io::Result<()>
    where
        W: ?Sized + io::Write,
    {
        let mut buffer = zmij::Buffer::new();
        let s = buffer.format_finite(value);
        writer.write_all(s.as_bytes())
    }

            Compound::Map { ser, state } => {
                tri!(ser
                    .formatter
                    .begin_object_key(&mut ser.writer, *state == State::First)
                    .map_err(Error::io));
                *state = State::Rest;

                tri!(key.serialize(MapKeySerializer { ser: *ser }));

                ser.formatter
                    .end_object_key(&mut ser.writer)
                    .map_err(Error::io)
            }

use serde::Serialize;
use std::collections::BTreeMap;

#[derive(Serialize, PartialEq, Eq, PartialOrd, Ord)]
enum Color {
  Red,
}

#[derive(Serialize, PartialEq, Eq, PartialOrd, Ord)]
struct Id(u32);

#[derive(Serialize, PartialEq, Eq, PartialOrd, Ord)]
struct Point {
  x: u32,
}

fn one<K: Serialize>(label: &str, key: K) {
  // A one-entry map with no real map type behind it, so f64 keys need no Ord.
  struct M<K>(K);
  impl<K: Serialize> Serialize for M<K> {
    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
      use serde::ser::SerializeMap;
      let mut m = s.serialize_map(Some(1))?;
      m.serialize_entry(&self.0, &0)?;
      m.end()
    }
  }
  let text = serde_json::to_string(&M(&key));
  let value = serde_json::to_value(M(&key)).map(|v| v.to_string());
  println!("{label:<16} to_string={text:?}");
  println!("{:<16} to_value ={value:?}", "");
}

fn main() {
  one("&str", "a");
  one("char", 'c');
  one("u8", 7u8);
  one("i128", -1i128);
  one("bool", true);
  one("f64", 1.5f64);
  one("f64 NaN", f64::NAN);
  one("unit variant", Color::Red);
  one("newtype struct", Id(3));
  one("Some(1)", Some(1));
  one("None", None::<u32>);
  one("()", ());
  one("(u32, u32)", (1u32, 2u32));
  one("Vec<u8>", vec![1u8]);
  one("struct", Point { x: 1 });
  let mut m = BTreeMap::new();
  m.insert((1u32, 2u32), "a");
  println!("BTreeMap<(u32,u32),_>: {:?}", serde_json::to_string(&m));
}

&str             to_string=Ok("{\"a\":0}")
                 to_value =Ok("{\"a\":0}")
char             to_string=Ok("{\"c\":0}")
                 to_value =Ok("{\"c\":0}")
u8               to_string=Ok("{\"7\":0}")
                 to_value =Ok("{\"7\":0}")
i128             to_string=Ok("{\"-1\":0}")
                 to_value =Ok("{\"-1\":0}")
bool             to_string=Ok("{\"true\":0}")
                 to_value =Ok("{\"true\":0}")
f64              to_string=Ok("{\"1.5\":0}")
                 to_value =Ok("{\"1.5\":0}")
f64 NaN          to_string=Err(Error("float key must be finite (got NaN or +/-inf)", line: 0, column: 0))
                 to_value =Err(Error("float key must be finite (got NaN or +/-inf)", line: 0, column: 0))
unit variant     to_string=Ok("{\"Red\":0}")
                 to_value =Ok("{\"Red\":0}")
newtype struct   to_string=Ok("{\"3\":0}")
                 to_value =Ok("{\"3\":0}")
Some(1)          to_string=Ok("{\"1\":0}")
                 to_value =Err(Error("key must be a string", line: 0, column: 0))
None             to_string=Err(Error("key must be a string", line: 0, column: 0))
                 to_value =Err(Error("key must be a string", line: 0, column: 0))
()               to_string=Err(Error("key must be a string", line: 0, column: 0))
                 to_value =Err(Error("key must be a string", line: 0, column: 0))
(u32, u32)       to_string=Err(Error("key must be a string", line: 0, column: 0))
                 to_value =Err(Error("key must be a string", line: 0, column: 0))
Vec<u8>          to_string=Err(Error("key must be a string", line: 0, column: 0))
                 to_value =Err(Error("key must be a string", line: 0, column: 0))
struct           to_string=Err(Error("key must be a string", line: 0, column: 0))
                 to_value =Err(Error("key must be a string", line: 0, column: 0))
BTreeMap<(u32,u32),_>: Err(Error("key must be a string", line: 0, column: 0))

pub fn to_writer<W, T>(writer: W, value: &T) -> Result<()>
where
    W: io::Write,
    T: ?Sized + Serialize,
{
    let mut ser = Serializer::new(writer);
    value.serialize(&mut ser)
}

fn main() {
  let post = Post { id: 7, title: "serde".into(), tags: vec!["rust".into(), "json".into()] };

  let mut buffered = BufWriter::new(CountWrites::default());
  serde_json::to_writer(&mut buffered, &post).unwrap();
  let inner = buffered.into_inner().map_err(|e| e.into_error()).unwrap();
  println!("to_writer(BufWriter<CountWrites>) write calls={} bytes={}", inner.calls, inner.bytes);

  let mut pretty = CountWrites::default();
  serde_json::to_writer_pretty(&mut pretty, &post).unwrap();
  println!("to_writer_pretty(CountWrites)     write calls={} bytes={}", pretty.calls, pretty.bytes);

  for n in [1usize, 10, 100, 1000] {
    let posts: Vec<Post> = (0..n)
      .map(|i| Post { id: i as u32, title: format!("post {i}"), tags: vec!["rust".into()] })
      .collect();
    let before = ALLOCS.load(Relaxed);
    let v = serde_json::to_vec(&posts).unwrap();
    let to_vec = ALLOCS.load(Relaxed) - before;
    let before = ALLOCS.load(Relaxed);
    let s = serde_json::to_string(&posts).unwrap();
    let to_string = ALLOCS.load(Relaxed) - before;
    let mut reuse = Vec::with_capacity(v.len());
    let before = ALLOCS.load(Relaxed);
    serde_json::to_writer(&mut reuse, &posts).unwrap();
    let to_writer = ALLOCS.load(Relaxed) - before;
    println!(
      "{n:>4} posts: {:>6} bytes  to_vec allocs={to_vec}  to_string allocs={to_string}  to_writer(presized Vec) allocs={to_writer}",
      s.len()
    );
  }
}

to_writer(BufWriter<CountWrites>) write calls=1 bytes=47
to_writer_pretty(CountWrites)     write calls=41 bytes=73
   1 posts:     43 bytes  to_vec allocs=1  to_string allocs=1  to_writer(presized Vec) allocs=0
  10 posts:    421 bytes  to_vec allocs=3  to_string allocs=3  to_writer(presized Vec) allocs=0
 100 posts:   4381 bytes  to_vec allocs=7  to_string allocs=7  to_writer(presized Vec) allocs=0
1000 posts:  45781 bytes  to_vec allocs=10  to_string allocs=10  to_writer(presized Vec) allocs=0

write calls=29 bytes=47