Deserialize、Deserializer 与 Visitor

pub trait Deserialize<'de>: Sized {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>;
    // ...
}

/// 2. The various `deserialize_*` methods. Non-self-describing formats like
///    Postcard need to be told what is in the input in order to deserialize it.
///    The `deserialize_*` methods are hints to the deserializer for how to
///    interpret the next piece of input. Non-self-describing formats are not
///    able to deserialize something like `serde_json::Value` which relies on
///    `Deserializer::deserialize_any`.

macro_rules! forward_to_deserialize_any_method {
    ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
        #[inline]
        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, <Self as $crate::de::Deserializer<$l>>::Error>
        where
            $v: $crate::de::Visitor<$l>,
        {
            $(
                let _ = $arg;
            )*
            self.deserialize_any(visitor)
        }
    };
}

    deserialize_number!(deserialize_i8);
    deserialize_number!(deserialize_i16);
    deserialize_number!(deserialize_i32);
    deserialize_number!(deserialize_i64);
    deserialize_number!(deserialize_u8);
    deserialize_number!(deserialize_u16);
    deserialize_number!(deserialize_u32);
    deserialize_number!(deserialize_u64);

use bincode::Options;
use exp_serde_de::LogDe;
use serde::Deserialize;

fn json<'a, T: Deserialize<'a> + std::fmt::Debug>(label: &str, input: &'a str) {
  println!("== json {label}: {input}");
  let mut de = serde_json::Deserializer::from_str(input);
  let r = T::deserialize(LogDe::new(&mut de));
  println!("=> {r:?}");
}

fn bin<'a, T: Deserialize<'a> + std::fmt::Debug>(label: &str, input: &'a [u8]) {
  println!("== bincode {label}: {input:?}");
  let opts = bincode::options().with_fixint_encoding().allow_trailing_bytes();
  let mut de = bincode::Deserializer::from_slice(input, opts);
  let r = T::deserialize(LogDe::new(&mut de));
  println!("=> {r:?}");
}

fn main() {
  json::<u8>("u8", "7");
  json::<u8>("u8", "300");
  json::<u8>("u8", "\"7\"");
  json::<u8>("u8", "7.0");
  let bytes = bincode::serialize(&300u16).unwrap();
  bin::<u8>("u8", &bytes);
  bin::<u16>("u16", &bytes);
  json::<serde_json::Value>("Value", "300");
  bin::<serde_json::Value>("Value", &bytes);
}

== json u8: 7
deserialize_u8
  visit_u64(7)
=> Ok(7)
== json u8: 300
deserialize_u8
  visit_u64(300)
=> Err(Error("invalid value: integer `300`, expected u8", line: 1, column: 3))
== json u8: "7"
deserialize_u8
=> Err(Error("invalid type: string \"7\", expected u8", line: 1, column: 3))
== json u8: 7.0
deserialize_u8
  visit_f64(7.0)
=> Err(Error("invalid type: floating point `7.0`, expected u8", line: 1, column: 3))
== bincode u8: [44, 1]
deserialize_u8
  visit_u8(44)
=> Ok(44)
== bincode u16: [44, 1]
deserialize_u16
  visit_u16(300)
=> Ok(300)
== json Value: 300
deserialize_any
  visit_u64(300)
=> Ok(Number(300))
== bincode Value: [44, 1]
deserialize_any
=> Err(DeserializeAnyNotSupported)

use exp_serde_de::Logged;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct Q {
  n: Logged<u8>,
}

fn main() {
  for input in ["n=7", "n=300", "n=abc"] {
    println!("== urlencoded {input}");
    println!("=> {:?}", serde_urlencoded::from_str::<Q>(input));
  }
  println!("== json {{\"n\":\"7\"}}");
  println!("=> {:?}", serde_json::from_str::<Q>(r#"{"n":"7"}"#));
}

== urlencoded n=7
deserialize_u8
  visit_u8(7)
=> Ok(Q { n: Logged(7) })
== urlencoded n=300
deserialize_u8
=> Err(Error("number too large to fit in target type"))
== urlencoded n=abc
deserialize_u8
=> Err(Error("invalid digit found in string"))
== json {"n":"7"}
deserialize_u8
=> Err(Error("invalid type: string \"7\", expected u8", line: 1, column: 8))

    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        let _ = visitor;
        Err(Error::custom("i128 is not supported"))
    }

    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
    where
        E: Error,
    {
        Err(Error::invalid_type(Unexpected::Bool(v), &self))
    }

    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
    where
        E: Error,
    {
        self.visit_i64(v as i64)
    }

    #[inline]
    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
    where
        E: Error,
    {
        self.visit_str(v)
    }

use serde::de::{value::Error, Error as _, Visitor};
use std::fmt;

// Implements only five visit_* methods; everything else is the trait default.
struct Five;

impl<'de> Visitor<'de> for Five {
  type Value = String;

  fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
    f.write_str("something Five accepts")
  }
  fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<String, E> {
    Ok(format!("visit_i64({v})"))
  }
  fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<String, E> {
    Ok(format!("visit_u64({v})"))
  }
  fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<String, E> {
    Ok(format!("visit_f64({v})"))
  }
  fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<String, E> {
    Ok(format!("visit_str({v:?})"))
  }
  fn visit_bytes<E: serde::de::Error>(self, v: &[u8]) -> Result<String, E> {
    Ok(format!("visit_bytes({v:?})"))
  }
}

fn show(called: &str, r: Result<String, Error>) {
  match r {
    Ok(s) => println!("{called:<28} -> {s}"),
    Err(e) => println!("{called:<28} -> Err: {e}"),
  }
}

fn main() {
  show("visit_i8(-5)", Five.visit_i8(-5));
  show("visit_i16(-5)", Five.visit_i16(-5));
  // ... 其余每个 visit_* 一行，见下面的输出
  println!("---- through serde_json ----");
  for input in ["true", "null", "[1]", "{}", "-1", "1e3", "\"a\\nb\"", "\"ab\""] {
    let mut de = serde_json::Deserializer::from_str(input);
    let r = serde::Deserializer::deserialize_any(&mut de, Five);
    println!("{input:<10} -> {r:?}");
  }
}

visit_i8(-5)                 -> visit_i64(-5)
visit_i16(-5)                -> visit_i64(-5)
visit_i32(-5)                -> visit_i64(-5)
visit_u8(5)                  -> visit_u64(5)
visit_u16(5)                 -> visit_u64(5)
visit_u32(5)                 -> visit_u64(5)
visit_f32(1.5)               -> visit_f64(1.5)
visit_char('x')              -> visit_str("x")
visit_borrowed_str("b")      -> visit_str("b")
visit_string("s")            -> visit_str("s")
visit_borrowed_bytes(b"b")   -> visit_bytes([98])
visit_byte_buf(vec![1])      -> visit_bytes([1])
visit_bool(true)             -> Err: invalid type: boolean `true`, expected something Five accepts
visit_none()                 -> Err: invalid type: Option value, expected something Five accepts
visit_unit()                 -> Err: invalid type: unit value, expected something Five accepts
---- through serde_json ----
true       -> Err(Error("invalid type: boolean `true`, expected something Five accepts", line: 1, column: 4))
null       -> Err(Error("invalid type: null, expected something Five accepts", line: 1, column: 4))
[1]        -> Err(Error("invalid type: sequence, expected something Five accepts", line: 1, column: 1))
{}         -> Err(Error("invalid type: map, expected something Five accepts", line: 1, column: 2))
-1         -> Ok("visit_i64(-1)")
1e3        -> Ok("visit_f64(1000)")
"a\nb"     -> Ok("visit_str(\"a\\nb\")")
"ab"       -> Ok("visit_str(\"ab\")")

  for input in [r#""ab""#, r#""a\nb""#] {
    println!("== json {input}");
    let mut de = serde_json::Deserializer::from_str(input);
    println!("=> {:?}", String::deserialize(LogDe::new(&mut de)));
  }

== json "ab"
deserialize_string
  visit_borrowed_str("ab")
=> Ok("ab")
== json "a\nb"
deserialize_string
  visit_str("a\nb")
=> Ok("a\nb")

    /// This method is stable and an official public API, but hidden from the
    /// documentation because it is almost never what newbies are looking for.
    /// Showing it in rustdoc would cause it to be featured more prominently
    /// than it deserves.
    #[doc(hidden)]
    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
    where
        D: Deserializer<'de>,
    {
        // Default implementation just delegates to `deserialize` impl.
        *place = tri!(Deserialize::deserialize(deserializer));
        Ok(())
    }

                for i in 0..self.0.len() {
                    let next = {
                        let next_place = InPlaceSeed(&mut self.0[i]);
                        tri!(seq.next_element_seed(next_place))
                    };
                    if next.is_none() {
                        self.0.truncate(i);
                        return Ok(());
                    }
                }

                while let Some(value) = tri!(seq.next_element()) {
                    self.0.push(value);
                }

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct P {
  name: String,
}

fn ptrs(v: &[String]) -> Vec<*const u8> {
  v.iter().map(|s| s.as_ptr()).collect()
}

fn main() {
  let mut v: Vec<String> = vec![String::with_capacity(32), String::with_capacity(32), String::with_capacity(32)];
  let (vp, sp) = (v.as_ptr(), ptrs(&v));
  let mut de = serde_json::Deserializer::from_str(r#"["x", "y"]"#);
  Vec::<String>::deserialize_in_place(&mut de, &mut v).unwrap();
  println!("Vec<String> in place: {v:?}");
  println!("  vec buffer reused: {}", v.as_ptr() == vp);
  println!("  string buffers reused: {:?}", ptrs(&v).iter().zip(&sp).map(|(a, b)| a == b).collect::<Vec<_>>());
  println!("  capacities: {:?}", v.iter().map(|s| s.capacity()).collect::<Vec<_>>());

  let mut p = P { name: String::with_capacity(32) };
  let before = p.name.as_ptr();
  let mut de = serde_json::Deserializer::from_str(r#"{"name": "z"}"#);
  P::deserialize_in_place(&mut de, &mut p).unwrap();
  println!("derived P in place: {p:?}");
  println!("  name buffer reused: {}, capacity: {}", p.name.as_ptr() == before, p.name.capacity());
}

Vec<String> in place: ["x", "y"]
  vec buffer reused: true
  string buffers reused: [true, true]
  capacities: [32, 32]
derived P in place: P { name: "z" }
  name buffer reused: false, capacity: 1

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct P {
  name: String,
  tags: Vec<String>,
}

fn main() {
  let mut p = P { name: String::with_capacity(32), tags: vec![String::with_capacity(32)] };
  let (np, tp) = (p.name.as_ptr(), p.tags[0].as_ptr());
  let mut de = serde_json::Deserializer::from_str(r#"{"name": "z", "tags": ["t"]}"#);
  P::deserialize_in_place(&mut de, &mut p).unwrap();
  println!("derived P in place (feature on): {p:?}");
  println!("  name reused: {}, cap {}", p.name.as_ptr() == np, p.name.capacity());
  println!("  tags[0] reused: {}, cap {}", p.tags[0].as_ptr() == tp, p.tags[0].capacity());
}

derived P in place (feature on): P { name: "z", tags: ["t"] }
  name reused: true, cap 32
  tags[0] reused: true, cap 32

                                _serde::de::MapAccess::next_value_seed(
                                    &mut __map,
                                    _serde::__private229::de::InPlaceSeed(&mut self.place.name),
                                )?;

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

                if deserializer.is_human_readable() {
                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
                } else {
                    <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
                }

use bincode::Options;
use exp_serde_de::LogDe;
use serde::Deserialize;
use std::net::Ipv4Addr;

fn main() {
  for input in [r#""127.0.0.1""#, "[127,0,0,1]"] {
    println!("== json {input}");
    let mut de = serde_json::Deserializer::from_str(input);
    println!("=> {:?}", Ipv4Addr::deserialize(LogDe::new(&mut de)));
  }
  let bytes = bincode::serialize(&Ipv4Addr::new(127, 0, 0, 1)).unwrap();
  println!("== bincode {bytes:?}");
  let opts = bincode::options().with_fixint_encoding().allow_trailing_bytes();
  let mut de = bincode::Deserializer::from_slice(&bytes, opts);
  println!("=> {:?}", Ipv4Addr::deserialize(LogDe::new(&mut de)));
}

== json "127.0.0.1"
is_human_readable() = true
deserialize_str
  visit_borrowed_str("127.0.0.1")
=> Ok(127.0.0.1)
== json [127,0,0,1]
is_human_readable() = true
deserialize_str
=> Err(Error("invalid type: sequence, expected IPv4 address", line: 1, column: 0))
== bincode [127, 0, 0, 1]
is_human_readable() = false
deserialize_tuple(4)
  visit_seq
    next_element_seed
      deserialize_u8
        visit_u8(127)
    -> Some
    next_element_seed
      deserialize_u8
        visit_u8(0)
    -> Some
    next_element_seed
      deserialize_u8
        visit_u8(0)
    -> Some
    next_element_seed
      deserialize_u8
        visit_u8(1)
    -> Some
=> Ok(127.0.0.1)

visit_i128(5)                -> Err: invalid type: integer `5` as i128, expected something Five accepts
visit_u128(5)                -> Err: invalid type: integer `5` as u128, expected something Five accepts