serde

[package]
name = "my-crate"
version = "0.1.0"
authors = ["Me <[email protected]>"]

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

use serde::{Serialize, Deserialize};

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

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = serde_json::to_string(&point).unwrap();

    // Prints serialized = {"x":1,"y":2}
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();

    // Prints deserialized = Point { x: 1, y: 2 }
    println!("deserialized = {:?}", deserialized);
}

#[derive(Serialize, Deserialize, Debug)]
enum Gentle {
    Male, // 序列化为 Male 字符串
    Female,
}

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    gentle: Gentle,
    info: (i32, String),
}

fn main() {
    let person = Person {
      name: "zhang".to_string(),
      gentle: Gentle::Male,
      info: (1, "test".to_string()),
    };

    let ps = serde_json::to_string(&person).unwrap();
    // ps: {"name":"zhang","gentle":"Male","info":[1,"test"]}
    println!("ps: {}", ps);
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
enum Gentle {
    Male, // 序列化为 male 字符串
    Female,
}

// ps: {"name":"zhang","gentle":"male","info":[1,"test"]}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "lowercase")]
enum Gentle {
    Male, // 序列化为字符串，male
    Female,
    Other(i32, String), // 序列化为 Map，值为 JSON 列表：{"other": [1, "unnown"]}
    OneType(i32)，// 序列化为 Map：{"onetype": 12}
    Complex { Id: i32, name: String }, // 序列化为 Map，Value 还是 Map：{"complex":{"Id":1,"name":"test"}}
}

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    gentle: Gentle, // 根据使用的 Gentle 类型可能是 字符串 或 Map
    info: (i32, String),
}

fn test_serde() {
    let person = Person {
        name: "zhang".to_string(),
        gentle: Gentle::Other(1, "unknown".to_string()),
        info: (1, "test".to_string()),
    };

    let ps = serde_json::to_string(&person).unwrap();
    // ps: {"name":"zhang","gentle":{"other":[1,"unknown"]},"info":[1,"test"]}
    println!("ps: {}", ps);
}

struct W {
    a: i32,
    b: i32,
}
let w = W { a: 0, b: 0 }; // Represented as `{"a":0,"b":0}`

struct X(i32, i32);
let x = X(0, 0); // Represented as `[0,0]`

struct Y(i32);
let y = Y(0); // Represented as just the inner value `0`

struct Z;
let z = Z; // Represented as `null`

enum E {
    W { a: i32, b: i32 },
    X(i32, i32),
    Y(i32),
    Z,
}
let w = E::W { a: 0, b: 0 }; // Represented as `{"W":{"a":0,"b":0}}`
let x = E::X(0, 0);          // Represented as `{"X":[0,0]}`
let y = E::Y(0);             // Represented as `{"Y":0}`
let z = E::Z;                // Represented as `"Z"`

#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]  // <-- this is a container attribute
struct S {
    #[serde(default)]  // <-- this is a field attribute
    f: i32,
}

#[derive(Serialize, Deserialize)]
#[serde(rename = "e")]  // <-- this is also a container attribute
enum E {
    #[serde(rename = "a")]  // <-- this is a variant attribute
    A(String),
}

fn test_serde_rename() {
    use serde::{Deserialize, Serialize};
    use serde_json;

    // rename_all 将 enum 的各 variant 字段名称按照指定风格重写，但是 struct variant 的各 field 字段名称不变。
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(rename_all = "UPPERCASE")]
    enum Message {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
        Other(u8),
    }
    println!(
        "enum Message rename_all: struct {}, simple: {}, tuple: {}",
        serde_json::to_string(&Message::Request {
            id: "abc".into(),
            method: "get".into()
        }).unwrap(),
        serde_json::to_string(&Message::Unknown).unwrap(),
        serde_json::to_string(&Message::Other(8)).unwrap()
    );
    // enum Message rename: struct {"REQUEST":{"id":"abc","method":"get"}}, simple: "UNKNOWN", tuple: {"OTHER":8}

    // rename_all_fields 只适用于 enum，而且只是对 struct variant 的各 field key 重命名。
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(rename_all_fields = "UPPERCASE"]
    enum MessageV2 {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
        Other(u8),
    }
    println!(
        "enum MessageV2 rename_all_fields: struct {}, simple: {}, tuple: {}",
        serde_json::to_string(&MessageV2::Request {
            id: "abc".into(),
            method: "get".into()
        }).unwrap(),
        serde_json::to_string(&MessageV2::Unknown).unwrap(),
        serde_json::to_string(&MessageV2::Other(8)).unwrap()
    );
    // enum MessageV2 rename_all_fields: struct {"Request":{"ID":"abc","METHOD":"get"}}, simple: "Unknown", tuple: {"Other":8}

    // 同时使用 rename_all_fields 和 rename_all, 这样各字段都是重命名
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(rename_all_fields = "UPPERCASE", rename_all = "UPPERCASE")]
    enum MessageV3 {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
        Other(u8),
    }
    println!(
        "enum MessageV3 rename_all_fields and rename_all: struct {}, simple: {}, tuple: {}",
        serde_json::to_string(&MessageV3::Request {
            id: "abc".into(),
            method: "get".into()
        })
        .unwrap(),
        serde_json::to_string(&MessageV3::Unknown).unwrap(),
        serde_json::to_string(&MessageV3::Other(8)).unwrap()
    );
    // enum MessageV3 rename_all_fields and rename_all: struct
    // {"REQUEST":{"ID":"abc","METHOD":"get"}}, simple: "UNKNOWN", tuple: {"OTHER":8}

    // rename_all 也适用于 struct，对它的各字段有效。
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(rename_all = "UPPERCASE")]
    struct Student {
        name: String,
        age: u8,
    }
    let s = Student {
        name: "zhang".into(),
        age: 28,
    };
    println!(
        "serde rename_all: struct: {}",
        serde_json::to_string(&s).unwrap()
    );
    // serde rename_all: struct: {"NAME":"zhang","AGE":28}
}

fn test_serde_tag() {
    use serde::{Deserialize, Serialize};
    use serde_json;

    // enum: 不加 tag 时，对于 struct variant 和 tuple variant，Serialize 为 JSON Map，key 为 variant 字段名称。
    // 对于普通的 variant，显示为字段名称字符串。
    //
    #[derive(Serialize, Deserialize, Debug)]
    enum Message {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
        Other(u8),
    }
    println!(
        "enum Message: struct {}, simple: {}, tuple: {}",
        serde_json::to_string(&Message::Request {
            id: "abc".into(),
            method: "get".into()
        })
        .unwrap(),
        serde_json::to_string(&Message::Unknown).unwrap(),
        serde_json::to_string(&Message::Other(8)).unwrap()
    );
    // enum Message: struct {"Request":{"id":"abc","method":"get"}}, simple:
    // "Unknown", tuple: {"Other":8}

    // 如果加了 tag, 则不会引入最外层的 variant 字段名称 key，而是将该字段名称作为 tag 的 value 并打
    // 平到结果中。tag 不支持 tuple variant。
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(tag = "t")]
    enum MessageV2 {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
        // called `Result::unwrap()` on an `Err` value: Error("cannot
        // serialize tagged newtype variant MessageV2::Other containing an
        // integer", line: 0, column: 0)
        //
        // Other(u8),
    }
    println!(
        "enum MessageV2: struct: {}, simple: {}, tuple: {}",
        serde_json::to_string(&MessageV2::Request {
            id: "abc".into(),
            method: "get".into()
        })
        .unwrap(),
        serde_json::to_string(&MessageV2::Unknown).unwrap(),
        "unsupported tuple variant with tag",
        // serde_json::to_string(&MessageV2::Other(8u8)).unwrap(),
    );
    // enum MessageV2: struct: {"t":"Request","id":"abc","method":"get"},
    // simple: {"t":"Unknown"}, tuple: unsupported tuple variant with tag

    // 还可以加 content，这时 struct variant 的各字段将位于 content 的 key 之下。
    // content 只能用于 enum，不能用于 struct。
    #[derive(Serialize, Deserialize, Debug)]
    #[serde(tag = "t", content = "c")]
    enum MessageV3 {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
    }
    println!(
        "enum MessageV3: struct: {}, simple: {}, tuple: {}",
        serde_json::to_string(&MessageV3::Request {
            id: "abc".into(),
            method: "get".into()
        })
        .unwrap(),
        serde_json::to_string(&MessageV3::Unknown).unwrap(),
        "unsupported tuple variant with tag",
        // serde_json::to_string(&MessageV3::Other(8u8)).unwrap(),
    );
    // enum MessageV3: struct: {"t":"Request","c":{"id":"abc","method":"get"}},
    // simple: {"t":"Unknown"}, tuple: unsupported tuple variant with tag

    #[derive(Serialize, Deserialize, Debug)]
    // 对于 struct，默认是 untagged，如果指定 tag，则用于添加一个字段，值为 struct 类型名称。
    //
    // error: #[serde(content = "...")] can only be used on enums
    // #[serde(tag = "t", content = "c")]
    #[serde(tag = "t")]
    struct Student {
        name: String,
        age: u8,
    }
    let s = Student {
        name: "zhang".into(),
        age: 28,
    };
    println!("serde tag: struct: {}", serde_json::to_string(&s).unwrap());
    // serde tag: struct: {"t":"Student","name":"zhang","age":28}
}

#[derive(Serialize, Deserialize)]
#[serde(bound = "D: SerializeWith + DeserializeWith")]
struct WithTraits1<D, E> {
    #[serde(
        serialize_with = "SerializeWith::serialize_with",
        deserialize_with = "DeserializeWith::deserialize_with"
    )]
    d: D,
    #[serde(
        serialize_with = "SerializeWith::serialize_with",
        deserialize_with = "DeserializeWith::deserialize_with",
        bound = "E: SerializeWith + DeserializeWith"
    )]
    e: E,
}

pub fn test_serde_deserialize() {
    #[derive(Serialize, Deserialize, Debug)]
    enum Message {
        Request { id: String, method: String },
        Response { id: String },
        Unknown,
        Other(u8),
    }

    // 在 Deserialize 时，如果 filed name 大小写不一致，相当于 field 缺失，则报错。
    //
    // let m: Message =
    //     serde_json::from_str(r#"{"request": {"id": "abcd"}}"#).unwrap();
    // println!("serde deserialize: {:?}", m);
    //
    // called `Result::unwrap()` on an `Err` value: Error("unknown variant
    // `request`, expected one of `Request`, `Response`, `Unknown`, `Other`",
    // line: 1, column: 10)

    // 在 Deserialize 时，如果 filed 缺失，则报错。
    //
    // let m: Message =
    //     serde_json::from_str(r#"{"Request": {"id": "abcd"}}"#).unwrap();
    // println!("serde deserialize: {:?}", m);
    //
    // called `Result::unwrap()` on an `Err` value: Error("missing field
    // `method`", line: 1, column: 26)

    // 使用 serde(default) 允许 Deserialize 时 field 缺失的情况。这时用 field 类型的 Default 来补充。
    // serde(default) 只适用于 struct 类型，而且该 struct 整体必须实现 Default trait
    #[derive(Serialize, Deserialize, Debug, Default)]
    #[serde(default)]
    struct MessageV2 {
        request: String,
        response: String,
        unknown: u8,
    }

    // 字符串多了一个 field，默认被忽略。但添加 #[serde(deny_unknown_fields)] 后，在遇到未知 field 时报错。
    let m: MessageV2 = serde_json::from_str(
        r#"{"Request": {"id": "abcd"}, "request": "abcd"}"#,
    )
        .unwrap();
    println!("serde default: {:?}", m);
}

// 另一个例子： https://riptutorial.com/rust/example/8980/default-value-for-field
#[derive(Deserialize, Debug)]
struct Request {
    // 使用 default_resource() 函数返回缺省值
    #[serde(default="default_resource")]
    resource: String,

    // 使用 Timeout 类型的 Default trait 实现来补齐缺省值
    #[serde(default)]
    timeout: Timeout,

    // 使用 Priority 类型的关联方法 lowest() 返回缺省值
    #[serde(default="Priority::lowest")]
    priority: Priority,
}

fn default_resource() -> String {
    "/".to_string()
}

#[derive(Deserialize, Debug)]
struct Timeout(u32);
impl Default for Timeout {
    fn default() -> Self {
        Timeout(30)
    }
}

#[derive(Deserialize, Debug)]
enum Priority { ExtraHigh, High, Normal, Low, ExtraLow }
impl Priority {
    fn lowest() -> Self { Priority::ExtraLow }
}

fn main() {
    let json = r#"
        [
          {
            "resource": "/users"
          },
          {
            "timeout": 5,
            "priority": "High"
          }
        ]
    "#;

    let requests: Vec<Request> = serde_json::from_str(json).unwrap();

    // The first request has resource="/users", timeout=30, priority=ExtraLow
    println!("{:?}", requests[0]);

    // The second request has resource="/", timeout=5, priority=High
    println!("{:?}", requests[1]);
}

// https://serde.rs/remote-derive.html

// Pretend that this is somebody else's crate, not a module.
mod other_crate {
    // Neither Serde nor the other crate provides Serialize and Deserialize
    // impls for this struct.
    pub struct Duration {
        pub secs: i64,
        pub nanos: i32,
    }
}

////////////////////////////////////////////////////////////////////////////////

use other_crate::Duration;
use serde::{Serialize, Deserialize};

// Serde calls this the definition of the remote type. It is just a copy of the
// remote data structure. The `remote` attribute gives the path to the actual
// type we intend to derive code for.
#[derive(Serialize, Deserialize)]
#[serde(remote = "Duration")]
struct DurationDef {
    secs: i64,
    nanos: i32,
}

// Provide a conversion to construct the remote type.
impl From<DurationDef> for Duration {
    fn from(def: DurationDef) -> Duration {
        Duration::new(def.secs, def.nanos)
    }
}

// Now the remote type can be used almost like it had its own Serialize and
// Deserialize impls all along. The `with` attribute gives the path to the
// definition for the remote type. Note that the real type of the field is the
// remote type, not the definition type.
#[derive(Serialize, Deserialize)]
struct Process {
    command_line: String,

    #[serde(with = "DurationDef")] // with 类型可以使用 From 转换为 Duration 类型
    wall_time: Duration,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(transparent)]
struct MessageV3 {
    f: u8,
};
let m = serde_json::to_string(&MessageV3 { f: 8u8 }).unwrap();
println!("serde transparet: {}", m);
// 不加 #[serde(transparent)]： serde transparet: {"f":8}
//
// 加 #[serde(transparent)]：serde transparet: 8

extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;

use serde::{Deserialize, Deserializer};

#[derive(Debug, Deserialize)]
struct WrappedI32(#[serde(deserialize_with = "callback")] i32);

// callback, as provided by the external library
fn callback<'de, D>(deserializer: D) -> Result<i32, D::Error> where D: Deserializer<'de>,
{
    Ok(i32::deserialize(deserializer)? * 2)
}

// Our final output struct, that we want to get after parsing the JSON
#[derive(Debug, Deserialize)]
struct S {
    #[serde(deserialize_with = "callback_opt")]
    s: Option<i32>,
    #[serde(deserialize_with = "callback_opt")]
    s2: Option<i32>
}

pub fn callback_opt<'de, D>(deserializer: D) -> Result<Option<i32>, D::Error> where D: Deserializer<'de>,
{
    Option::<WrappedI32>::deserialize(deserializer)
        .map(|opt_wrapped: Option<WrappedI32>| {
            opt_wrapped.map(|wrapped: WrappedI32| wrapped.0)
        })
}

fn main() {
    println!("{:?}", serde_json::from_str::<S>(r#"{"s": 42, "s2": null}"#));
}

// 另一个例子
#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate serde_json;
extern crate chrono;

use chrono::NaiveDate;

// 该 module 下需要定义 serialize() 和 deserialize() 两个函数
mod date_serde {
    use chrono::NaiveDate;
    use serde::{self, Deserialize, Serializer, Deserializer};

    // date 为要序列化的 variant 类型
    pub fn serialize<S>(date: &Option<NaiveDate>, s: S) -> Result<S::Ok, S::Error>
        where S: Serializer {
        if let Some(ref d) = *date {
            return s.serialize_str(&d.format("%Y-%m-%d").to_string())
        }
        s.serialize_none()
    }

    // Result 中的 Option<NaiveDate> 为反序列化生成的 variant 类型
    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<NaiveDate>, D::Error>
        where D: Deserializer<'de> {
            let s: Option<String> = Option::deserialize(deserializer)?;
            if let Some(s) = s {
                return Ok(Some(NaiveDate::parse_from_str(&s, "%Y-%m-%d").map_err(serde::de::Error::custom)?))
            }

            Ok(None)
        }
}

#[derive(Debug, Serialize, Deserialize)]
struct Test {
    pub i: u64,
    #[serde(with = "date_serde")] // data_serde module
    pub date: Option<NaiveDate>,
}

fn main() {
    let mut test: Test = serde_json::from_str(r#"{"i": 3, "date": "2015-02-03"}"#).unwrap();
    assert_eq!(test.i, 3);
    assert_eq!(test.date, Some(NaiveDate::from_ymd(2015, 02, 03)));
    test = serde_json::from_str(r#"{"i": 5}"#).unwrap();
    assert_eq!(test.i, 5);
    assert_eq!(test.date, None);
}

// https://riptutorial.com/rust/example/18224/handwritten-generic-type-bounds
extern crate serde;
extern crate serde_json;
#[macro_use] extern crate serde_derive;

use serde::de::{self, Deserialize, Deserializer};

use std::fmt::Display;
use std::str::FromStr;

#[derive(Deserialize, Debug)]
struct Outer<'a, S, T: 'a + ?Sized> {
    // When deriving the Deserialize impl, Serde would want to generate a bound `S: Deserialize`
    // on the type of this field. But we are going to use the type's `FromStr` impl instead of its
    // `Deserialize` impl by going through `deserialize_from_str`, so we override the
    // automatically generated bound by the one required for `deserialize_from_str`.

    // deserialize_from_str() 是泛型反序列化函数，其中一个泛型类型是 S，
    // 这里指定 S 的限界。
    #[serde(deserialize_with = "deserialize_from_str")]
    #[serde(bound(deserialize = "S: FromStr, S::Err: Display"))]
    // 对 S 类型按照 bound 的参数进行限界。
    //（如果未指定 bound，S 默认限界为 Deserialize）
    s: S,

    // Here Serde would want to generate a bound `T: Deserialize`. That is a stricter condition
    // than is necessary. In fact, the `main` function below uses T=str which does not implement
    // Deserialize. We override the automatically generated bound by a looser one.
    #[serde(bound(deserialize = "Ptr<'a, T>: Deserialize"))]
    // 对 Ptr<'a, T> 类型进行限界，该类型需要实现 Deserialize
    ptr: Ptr<'a, T>,
}

/// Deserialize a type `S` by deserializing a string, then using the `FromStr` impl of `S` to
/// create the result. The generic type `S` is not required to implement `Deserialize`.
fn deserialize_from_str<S, D>(deserializer: D) -> Result<S, D::Error>
    where S: FromStr,
          S::Err: Display,
          D: Deserializer
{
    let s: String = try!(Deserialize::deserialize(deserializer));
    S::from_str(&s).map_err(|e| de::Error::custom(e.to_string()))
}

/// A pointer to `T` which may or may not own the data. When deserializing
/// we always want to produce owned data.
#[derive(Debug)]
enum Ptr<'a, T: 'a + ?Sized> {
    Ref(&'a T),
    Owned(Box<T>),
}

impl<'a, T: 'a + ?Sized> Deserialize for Ptr<'a, T>
    where Box<T>: Deserialize
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where D: Deserializer
    {
        let box_t = try!(Deserialize::deserialize(deserializer));
        Ok(Ptr::Owned(box_t))
    }
}

fn main() {
    let j = r#"
        {
          "s": "1234567890",
          "ptr": "owned"
        }
    "#;

    let result: Outer<u64, str> = serde_json::from_str(j).unwrap();

    // result = Outer { s: 1234567890, ptr: Owned("owned") }
    println!("result = {:?}", result);
}

// https://serde.rs/lifetimes.html#borrowing-data-in-a-derived-impl

use serde::Deserialize;
use std::borrow::Cow;

#[derive(Deserialize)]
struct Inner<'a, 'b> {
    // &str and &[u8] are implicitly borrowed.
    username: &'a str,

    // Other types must be borrowed explicitly.
    #[serde(borrow)]
    comment: Cow<'b, str>,
}

#[derive(Deserialize)]
struct Outer<'a, 'b, 'c> {
    owned: String,

    #[serde(borrow)]
    inner: Inner<'a, 'b>,

    // This field is never borrowed.
    not_borrowed: Cow<'c, str>,
}

// The lifetimes 'a and 'b are borrowed while 'c is not.
impl<'de: 'a + 'b, 'a, 'b, 'c> Deserialize<'de> for Outer<'a, 'b, 'c> {
    /* ... */
}

use std::marker::PhantomData;

// This struct borrows the first two lifetimes but not the third.
#[derive(Deserialize)]
struct Three<'a, 'b, 'c> {
    a: &'a str,
    b: &'b str,
    c: PhantomData<&'c str>,
}

#[derive(Deserialize)]
struct Example<'a, 'b, 'c> {
    // Borrow 'a and 'b only, not 'c.
    #[serde(borrow = "'a + 'b")]
    three: Three<'a, 'b, 'c>,
}

extern crate serde;
extern crate serde_json;
#[macro_use] extern crate serde_derive;

#[derive(Serialize)]
struct Person {
    #[serde(rename="firstName")]
    first_name: String,
    #[serde(rename="lastName")]
    last_name: String,
}

fn main() {
    let person = Person {
        first_name: "Joel".to_string(),
        last_name: "Spolsky".to_string(),
    };

    let json = serde_json::to_string_pretty(&person).unwrap();

    // Prints:
    //
    //    {
    //      "firstName": "Joel",
    //      "lastName": "Spolsky"
    //    }
    println!("{}", json);
}

// https://serde.rs/attr-flatten.html
#[derive(Serialize, Deserialize)]
struct Pagination {
    limit: u64,
    offset: u64,
    total: u64,
}

#[derive(Serialize, Deserialize)]
struct Users {
    users: Vec<User>,

    #[serde(flatten)]
    pagination: Pagination,
}

// {
//   "limit": 100,
//   "offset": 200,
//   "total": 1053,
//   "users": [
//     {"id": "49824073-979f-4814-be10-5ea416ee1c2f", "username": "john_doe"},
//     ...
//   ]
// }


use std::collections::HashMap;
use serde::{Serialize, Deserialize};
use serde_json::Value;

#[derive(Serialize, Deserialize)]
struct User {
    id: String,
    username: String,

    #[serde(flatten)]
    extra: HashMap<String, Value>,
}

// {
//   "id": "49824073-979f-4814-be10-5ea416ee1c2f",
//   "username": "john_doe",
//   "mascot": "Ferris"
// }

extern crate serde;
extern crate serde_json;
#[macro_use] extern crate serde_derive;

use std::collections::BTreeMap as Map;

#[derive(Serialize)]
struct Resource {
    // Always serialized.
    name: String,

    // Never serialized.
    #[serde(skip_serializing)]
    hash: String,

    // Use a method to decide whether the field should be skipped.
    #[serde(skip_serializing_if="Map::is_empty")]
    metadata: Map<String, String>,
}

fn main() {
    let resources = vec![
        Resource {
            name: "Stack Overflow".to_string(),
            hash: "b6469c3f31653d281bbbfa6f94d60fea130abe38".to_string(),
            metadata: Map::new(),
        },
        Resource {
            name: "GitHub".to_string(),
            hash: "5cb7a0c47e53854cd00e1a968de5abce1c124601".to_string(),
            metadata: {
                let mut metadata = Map::new();
                metadata.insert("headquarters".to_string(),
                                "San Francisco".to_string());
                metadata
            },
        },
    ];

    let json = serde_json::to_string_pretty(&resources).unwrap();

    // Prints:
    //
    //    [
    //      {
    //        "name": "Stack Overflow"
    //      },
    //      {
    //        "name": "GitHub",
    //        "metadata": {
    //          "headquarters": "San Francisco"
    //        }
    //      }
    //    ]
    println!("{}", json);
}

// https://serde.rs/remote-derive.html

// Pretend that this is somebody else's crate, not a module.
mod other_crate {
    // Neither Serde nor the other crate provides Serialize and Deserialize
    // impls for this struct. Oh, and the fields are private.
    pub struct Duration {
        secs: i64,
        nanos: i32,
    }

    impl Duration {
        pub fn new(secs: i64, nanos: i32) -> Self {
            Duration { secs: secs, nanos: nanos }
        }

        pub fn seconds(&self) -> i64 {
            self.secs
        }

        pub fn subsec_nanos(&self) -> i32 {
            self.nanos
        }
    }
}

////////////////////////////////////////////////////////////////////////////////

use other_crate::Duration;
use serde::{Serialize, Deserialize};

// Provide getters for every private field of the remote struct. The getter must
// return either `T` or `&T` where `T` is the type of the field.
#[derive(Serialize, Deserialize)]
#[serde(remote = "Duration")]
struct DurationDef {
    #[serde(getter = "Duration::seconds")]
    secs: i64,
    #[serde(getter = "Duration::subsec_nanos")]
    nanos: i32,
}

// Provide a conversion to construct the remote type.
impl From<DurationDef> for Duration {
    fn from(def: DurationDef) -> Duration {
        Duration::new(def.secs, def.nanos)
    }
}

#[derive(Serialize, Deserialize)]
struct Process {
    command_line: String,

    #[serde(with = "DurationDef")]
    wall_time: Duration,
}

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

// 示例
use serde::{Serialize, Deserialize};

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

fn main() {
    let point = Point { x: 1, y: 2 };

    // 调用 point 实现的 serialize() 方法，传入 serde_json 提供的
    //  Serializer trait 实现类型。
    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

impl Serialize for i32 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: Serializer,
    {
        // 根据 Self 类型，调用 serialize_XX 方法。
        serializer.serialize_i32(*self)
    }
}

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

// 先为 i32 定义一个实现 Visitor trait 的对象, 该对象的关联类型 Value
// 与最终要解码生成的对象类型一致（这里是 i32）；
use std::fmt;
use serde::de::{self, Visitor};

struct I32Visitor;

// 关联类型 Value 为 deserilize 的类型，必须要实现的方法是 expecting()
impl<'de> Visitor<'de> for I32Visitor {
    type Value = i32; // 要 deserilize 的类型

    // 异常时显示的字符串。
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("an integer between -2^31 and 2^31")
    }

    fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E> where E: de::Error,
    {
        Ok(i32::from(value))
    }

    fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E> where E: de::Error,
    {
        Ok(value)
    }

    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> where E: de::Error,
    {
        use std::i32;
        if value >= i64::from(i32::MIN) && value <= i64::from(i32::MAX) {
            Ok(value as i32)
        } else {
            Err(E::custom(format!("i32 out of range: {}", value)))
        }
    }

    // Similar for other methods:
    //   - visit_i16
    //   - visit_u8
    //   - visit_u16
    //   - visit_u32
    //   - visit_u64
}


// 为 i32 类型定义 Deserialize 实现, Deserializer 是 serde_json/yaml 等提供的类型：
impl<'de> Deserialize<'de> for i32 {
    fn deserialize<D>(deserializer: D) -> Result<i32, D::Error>
      where D: Deserializer<'de>,
    {
        deserializer.deserialize_i32(I32Visitor) // 传入为 i32 定义的 Visitor
    }
}