Serialize 与 Serializer

pub trait Serialize {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer;
}

pub trait Serializer: Sized {
    type Ok;
    type Error: Error;
    type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
    type SerializeTuple: SerializeTuple<Ok = Self::Ok, Error = Self::Error>;
    type SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error = Self::Error>;
    type SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error = Self::Error>;
    type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
    type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>;
    type SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok, Error = Self::Error>;
    // ...
}

    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        let _ = v;
        Err(Error::custom("i128 is not supported"))
    }

impl<'a, W, F> ser::Serializer for &'a mut Serializer<W, F>
where
    W: io::Write,
    F: Formatter,
{
    type Ok = ();
    type Error = Error;

    type SerializeSeq = Compound<'a, W, F>;
    type SerializeTuple = Compound<'a, W, F>;
    // ... 七个复合类型都是 Compound<'a, W, F>

pub trait SerializeSeq {
    type Ok;
    type Error: Error;
    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize;
    fn end(self) -> Result<Self::Ok, Self::Error>;
}

pub enum Compound<'a, W: 'a, F: 'a> {
    Map {
        ser: &'a mut Serializer<W, F>,
        state: State,
    },
    // ... arbitrary_precision、raw_value 两个 feature 下的变体
}

    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        I: IntoIterator,
        <I as IntoIterator>::Item: Serialize,
    {
        let mut iter = iter.into_iter();
        let mut serializer = tri!(self.serialize_seq(iterator_len_hint(&iter)));
        tri!(iter.try_for_each(|item| serializer.serialize_element(&item)));
        serializer.end()
    }

fn iterator_len_hint<I>(iter: &I) -> Option<usize>
where
    I: Iterator,
{
    match iter.size_hint() {
        (lo, Some(hi)) if lo == hi => Some(lo),
        _ => None,
    }
}

use std::collections::{BTreeSet, HashMap};
use std::fmt;

use serde::Serialize;
use serde::ser::{self, Impossible, SerializeMap, SerializeSeq, SerializeStruct, Serializer};

// A Serializer that only reports which compound method was called and with what len.
// Elements are counted, not serialized, so the probe never recurses.
struct Probe;

#[derive(Debug)]
struct ProbeError(String);
// ... impl Display、std::error::Error、ser::Error for ProbeError

struct Counter {
  what: String,
  n: usize,
}

impl SerializeSeq for Counter {
  type Ok = String;
  type Error = ProbeError;
  fn serialize_element<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<(), ProbeError> {
    self.n += 1;
    Ok(())
  }
  fn end(self) -> Result<String, ProbeError> {
    Ok(format!("{} -> {} elements", self.what, self.n))
  }
}
// ... SerializeMap（serialize_key 计数）和 SerializeStruct（serialize_field 计数）同理

impl Serializer for Probe {
  type Ok = String;
  type Error = ProbeError;
  type SerializeSeq = Counter;
  type SerializeTuple = Impossible<String, ProbeError>;
  type SerializeTupleStruct = Impossible<String, ProbeError>;
  type SerializeTupleVariant = Impossible<String, ProbeError>;
  type SerializeMap = Counter;
  type SerializeStruct = Counter;
  type SerializeStructVariant = Impossible<String, ProbeError>;

  // ... 标量和其余复合类型的方法都返回 Err(方法名)
  fn serialize_seq(self, len: Option<usize>) -> Result<Counter, ProbeError> {
    Ok(Counter { what: format!("serialize_seq({len:?})"), n: 0 })
  }
  fn serialize_map(self, len: Option<usize>) -> Result<Counter, ProbeError> {
    Ok(Counter { what: format!("serialize_map({len:?})"), n: 0 })
  }
  fn serialize_struct(self, name: &'static str, len: usize) -> Result<Counter, ProbeError> {
    Ok(Counter { what: format!("serialize_struct({name:?}, {len})"), n: 0 })
  }
}

// Goes through the default collect_seq with an iterator whose size_hint is not exact.
struct Evens<'a>(&'a [u32]);

impl Serialize for Evens<'_> {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    s.collect_seq(self.0.iter().filter(|x| *x % 2 == 0))
  }
}

#[derive(Serialize)]
struct Post {
  title: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  draft: Option<bool>,
  #[serde(flatten)]
  extra: HashMap<String, u32>,
}

#[derive(Serialize)]
struct Plain {
  title: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  draft: Option<bool>,
}

fn show<T: Serialize>(label: &str, v: &T) {
  match v.serialize(Probe) {
    Ok(s) => println!("{label:<26} {s}"),
    Err(e) => println!("{label:<26} Err({e})"),
  }
}

fn main() {
  let v = vec![1u32, 2, 3, 4, 5];
  show("Vec<u32>", &v);
  show("&[u32][1..]", &&v[1..]);
  show("BTreeSet<u32>", &v.iter().copied().collect::<BTreeSet<_>>());
  show("HashMap<String, u32>", &HashMap::from([("a".to_string(), 1u32), ("b".to_string(), 2)]));
  show("Evens(filter)", &Evens(&v));
  show("Plain { draft: None }", &Plain { title: "t".into(), draft: None });
  show(
    "Post (flatten)",
    &Post { title: "t".into(), draft: None, extra: HashMap::from([("views".to_string(), 7u32)]) },
  );
  show("u32", &5u32);
  show("(u8, u8)", &(1u8, 2u8));
}

Vec<u32>                   serialize_seq(Some(5)) -> 5 elements
&[u32][1..]                serialize_seq(Some(4)) -> 4 elements
BTreeSet<u32>              serialize_seq(Some(5)) -> 5 elements
HashMap<String, u32>       serialize_map(Some(2)) -> 2 entries
Evens(filter)              serialize_seq(None) -> 2 elements
Plain { draft: None }      serialize_struct("Plain", 1) -> 1 fields
Post (flatten)             serialize_map(None) -> 2 entries
u32                        Err(serialize_u32)
(u8, u8)                   Err(serialize_tuple)

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
        tri!(self
            .formatter
            .begin_array(&mut self.writer)
            .map_err(Error::io));
        if len == Some(0) {
            tri!(self
                .formatter
                .end_array(&mut self.writer)
                .map_err(Error::io));
            Ok(Compound::Map {
                ser: self,
                state: State::Empty,
            })
        } else {
            Ok(Compound::Map {
                ser: self,
                state: State::First,
            })
        }
    }

use serde::Serialize;
use serde::ser::{SerializeSeq, Serializer};

// Same elements, three ways of announcing the length.
struct Seq {
  len: Option<usize>,
  items: Vec<u32>,
}

impl Serialize for Seq {
  fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    let mut seq = s.serialize_seq(self.len)?;
    for x in &self.items {
      seq.serialize_element(x)?;
    }
    seq.end()
  }
}

fn run(label: &str, v: &Seq) {
  println!("{label}");
  println!("  serde_json::to_string : {:?}", serde_json::to_string(v).map_err(|e| e.to_string()));
  println!("  serde_json::to_value  : {:?}", serde_json::to_value(v).map(|v| v.to_string()).map_err(|e| e.to_string()));
  match bincode::serialize(v) {
    Ok(bytes) => {
      println!("  bincode::serialize    : Ok({bytes:?})");
      println!("    back as Vec<u32>    : {:?}", bincode::deserialize::<Vec<u32>>(&bytes).map_err(|e| e.to_string()));
    }
    Err(e) => println!("  bincode::serialize    : Err({e})"),
  }
  println!("  postcard::to_allocvec : {:?}", postcard::to_allocvec(v).map_err(|e| e.to_string()));
}

fn main() {
  let items = vec![1u32, 2, 3];
  run("len = Some(3)", &Seq { len: Some(3), items: items.clone() });
  run("len = None", &Seq { len: None, items: items.clone() });
  run("len = Some(1), 3 elements", &Seq { len: Some(1), items });
}

len = Some(3)
  serde_json::to_string : Ok("[1,2,3]")
  serde_json::to_value  : Ok("[1,2,3]")
  bincode::serialize    : Ok([3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0])
    back as Vec<u32>    : Ok([1, 2, 3])
  postcard::to_allocvec : Ok([3, 1, 2, 3])
len = None
  serde_json::to_string : Ok("[1,2,3]")
  serde_json::to_value  : Ok("[1,2,3]")
  bincode::serialize    : Err(Bincode can only encode sequences and maps that have a knowable size ahead of time)
  postcard::to_allocvec : Err("The length of a sequence must be known")
len = Some(1), 3 elements
  serde_json::to_string : Ok("[1,2,3]")
  serde_json::to_value  : Ok("[1,2,3]")
  bincode::serialize    : Ok([1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0])
    back as Vec<u32>    : Ok([1])
  postcard::to_allocvec : Ok([1, 1, 2, 3])

    #[cfg(any(feature = "std", feature = "alloc"))]
    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ?Sized + Display,
    {
        self.serialize_str(&value.to_string())
    }

    #[cfg(not(any(feature = "std", feature = "alloc")))]
    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ?Sized + Display;

use std::alloc::{GlobalAlloc, Layout, System};
use std::fmt;
use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};

use serde::Serialize;

struct Counting;
static ALLOCS: AtomicUsize = AtomicUsize::new(0);

unsafe impl GlobalAlloc for Counting {
  unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
    ALLOCS.fetch_add(1, Relaxed);
    unsafe { System.alloc(layout) }
  }
  unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
    unsafe { System.dealloc(ptr, layout) }
  }
}

#[global_allocator]
static GLOBAL: Counting = Counting;

// A Display value with no String behind it.
struct Version(u32, u32, u32);

impl fmt::Display for Version {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "{}.{}.{}", self.0, self.1, self.2)
  }
}

impl Serialize for Version {
  fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    s.collect_str(self)
  }
}

fn count(label: &str, f: impl FnOnce(&mut Vec<u8>)) {
  let mut buf = Vec::with_capacity(1024);
  let before = ALLOCS.load(Relaxed);
  f(&mut buf);
  let n = ALLOCS.load(Relaxed) - before;
  println!("{label:<28} allocs={n} bytes={buf:?}");
}

fn main() {
  let v = Version(1, 0, 229);
  count("serde_json::to_writer", |buf| serde_json::to_writer(buf, &v).unwrap());
  count("postcard::to_slice", |buf| {
    let mut stack = [0u8; 64];
    let used = postcard::to_slice(&v, &mut stack).unwrap();
    buf.extend_from_slice(used);
  });
  count("bincode::serialize_into", |buf| bincode::serialize_into(buf, &v).unwrap());
}

serde_json::to_writer        allocs=0 bytes=[34, 49, 46, 48, 46, 50, 50, 57, 34]
postcard::to_slice           allocs=0 bytes=[7, 49, 46, 48, 46, 50, 50, 57]
bincode::serialize_into      allocs=1 bytes=[7, 0, 0, 0, 0, 0, 0, 0, 49, 46, 48, 46, 50, 50, 57]

    #[inline]
    fn is_human_readable(&self) -> bool {
        true
    }

impl Serialize for net::IpAddr {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        if serializer.is_human_readable() {
            match *self {
                net::IpAddr::V4(ref a) => a.serialize(serializer),
                net::IpAddr::V6(ref a) => a.serialize(serializer),
            }
        } else {
            match *self {
                net::IpAddr::V4(ref a) => {
                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
                }
                net::IpAddr::V6(ref a) => {
                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
                }
            }
        }
    }
}

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV6};
use std::time::{Duration, UNIX_EPOCH};

use serde::Serialize;

fn show<T: Serialize>(label: &str, v: &T) {
  let json = serde_json::to_string(v).unwrap();
  let bin = bincode::serialize(v).unwrap();
  let post = postcard::to_allocvec(v).unwrap();
  println!("{label}");
  println!("  json     ({:>2} bytes): {json}", json.len());
  println!("  bincode  ({:>2} bytes): {bin:?}", bin.len());
  println!("  postcard ({:>2} bytes): {post:?}", post.len());
}

fn main() {
  let v4 = Ipv4Addr::new(127, 0, 0, 1);
  show("IpAddr::V4(127.0.0.1)", &IpAddr::V4(v4));
  show("Ipv4Addr 127.0.0.1", &v4);
  let v6 = SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0);
  show("SocketAddr::V6([2001:db8::1]:8080)", &SocketAddr::V6(v6));
  show("SocketAddrV6 [2001:db8::1]:8080", &v6);
  show("Duration 1.5s", &Duration::from_millis(1500));
  show("SystemTime epoch+1.5s", &(UNIX_EPOCH + Duration::from_millis(1500)));
}

IpAddr::V4(127.0.0.1)
  json     (11 bytes): "127.0.0.1"
  bincode  ( 8 bytes): [0, 0, 0, 0, 127, 0, 0, 1]
  postcard ( 5 bytes): [0, 127, 0, 0, 1]
Ipv4Addr 127.0.0.1
  json     (11 bytes): "127.0.0.1"
  bincode  ( 4 bytes): [127, 0, 0, 1]
  postcard ( 4 bytes): [127, 0, 0, 1]
SocketAddr::V6([2001:db8::1]:8080)
  json     (20 bytes): "[2001:db8::1]:8080"
  bincode  (22 bytes): [1, 0, 0, 0, 32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 144, 31]
  postcard (19 bytes): [1, 32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 144, 63]
SocketAddrV6 [2001:db8::1]:8080
  json     (20 bytes): "[2001:db8::1]:8080"
  bincode  (18 bytes): [32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 144, 31]
  postcard (18 bytes): [32, 1, 13, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 144, 63]
Duration 1.5s
  json     (28 bytes): {"secs":1,"nanos":500000000}
  bincode  (12 bytes): [1, 0, 0, 0, 0, 0, 0, 0, 0, 101, 205, 29]
  postcard ( 6 bytes): [1, 128, 202, 181, 238, 1]
SystemTime epoch+1.5s
  json     (52 bytes): {"secs_since_epoch":1,"nanos_since_epoch":500000000}
  bincode  (12 bytes): [1, 0, 0, 0, 0, 0, 0, 0, 0, 101, 205, 29]
  postcard ( 6 bytes): [1, 128, 202, 181, 238, 1]

pub struct Impossible<Ok, Error> {
    void: Void,
    ok: PhantomData<Ok>,
    error: PhantomData<Error>,
}

enum Void {}

impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
where
    Error: ser::Error,
{
    type Ok = Ok;
    type Error = Error;

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
    where
        T: ?Sized + Serialize,
    {
        let _ = value;
        match self.void {}
    }

    fn end(self) -> Result<Ok, Error> {
        match self.void {}
    }
}

impl Display for MessageType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.serialize(f)
    }
}

use std::fmt::{self, Display, Write};

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "kebab-case")]
enum MessageType {
  StartRequest,
  EndRequest,
}

impl Display for MessageType {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    self.serialize(f)
  }
}

#[derive(Serialize)]
struct UserId(u64);

#[derive(Serialize)]
struct Point {
  x: i32,
  y: i32,
}

// Routes any Serialize value through `&mut fmt::Formatter`.
struct ViaFormatter<T>(T);

impl<T: Serialize> Display for ViaFormatter<T> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    self.0.serialize(f)
  }
}

fn show<T: Serialize>(label: &str, v: T) {
  let mut out = String::new();
  let r = write!(out, "{}", ViaFormatter(v));
  println!("{label:<22} {r:?} {out:?}");
}

fn main() {
  println!("{} {}", MessageType::StartRequest, MessageType::EndRequest);
  show("UserId(42)", UserId(42));
  show("u128::MAX", u128::MAX);
  show("'x'", 'x');
  show("Some(1)", Some(1));
  show("()", ());
  show("Point", Point { x: 1, y: 2 });
  show("format_args!", format_args!("{}-{}", 1, 2));
}

start-request end-request
UserId(42)             Ok(()) "42"
u128::MAX              Ok(()) "340282366920938463463374607431768211455"
'x'                    Ok(()) "x"
Some(1)                Err(Error) ""
()                     Err(Error) ""
Point                  Err(Error) ""
format_args!           Ok(()) "1-2"

to_string        : Ok("[],1,2]")
from_str back    : Err("trailing characters at line 1 column 3")
to_value         : Ok("[1,2]")

thread 'main' (2475833) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.154/src/ser.rs:1989:9:
attempt to subtract with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace