如何基于键名反序列化为枚举变量？

Question

我有两种形式的JSON：

"Example:" { "field": 42, "A": 76 }
"Example:" { "field": 42, "B": 110 }

我想反序列化为这样的结构：

struct Example {
    field: i32,
    an_enum: AnEnum,
}

哪里

enum AnEnum {
    A(i32),
    B(i32),
}

不为编写自定义反序列化器，我不知道该怎么做Example。

这有效：

"Example:" { "field": 42, "an_enum": {"A": 76} }

或者，在YAML中：

Example:
    field: 42
    an_enum:
        A: 76

这an_enum是多余的并且令人讨厌。如何将第一种形式反序列化为struct？或者，或者，如何声明可以成功反序列化所需语法的结构？

Answer 1

您正在寻找#[serde(flatten)]：

extern crate serde; // 1.0.75
extern crate serde_json; // 1.0.26
#[macro_use]
extern crate serde_derive; // 1.0.75

#[derive(Debug, Deserialize)]
struct Example {
    field: i32,
    #[serde(flatten)]
    an_enum: AnEnum,
}

#[derive(Debug, Deserialize)]
enum AnEnum {
    A(i32),
    B(i32),
}

fn main() {
    let a = r#"{ "field": 42, "A": 76 }"#;
    let b = r#"{ "field": 42, "B": 110 }"#;

    let a = serde_json::from_str::<Example>(a);
    let b = serde_json::from_str::<Example>(b);

    println!("{:?}", a);
    println!("{:?}", b);
}

extern crate serde; // 1.0.75
extern crate serde_json; // 1.0.26
#[macro_use]
extern crate serde_derive; // 1.0.75

#[derive(Debug, Deserialize)]
struct Example {
    field: i32,
    #[serde(flatten)]
    an_enum: AnEnum,
}

#[derive(Debug, Deserialize)]
enum AnEnum {
    A(i32),
    B(i32),
}

fn main() {
    let a = r#"{ "field": 42, "A": 76 }"#;
    let b = r#"{ "field": 42, "B": 110 }"#;

    let a = serde_json::from_str::<Example>(a);
    let b = serde_json::from_str::<Example>(b);

    println!("{:?}", a);
    println!("{:?}", b);
}

在此可用之前，我将使用自定义反序列化：

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

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

#[derive(Debug)]
struct Example {
    field: i32,
    an_enum: AnEnum,
}

#[derive(Debug)]
enum AnEnum {
    A(i32),
    B(i32),
}

impl<'de> Deserialize<'de> for Example {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Debug, Deserialize)]
        struct Mapping {
            field: i32,
            #[serde(rename = "A")]
            a: Option<i32>,
            #[serde(rename = "B")]
            b: Option<i32>,
        }

        let Mapping { field, a, b } = Mapping::deserialize(deserializer)?;

        match (a, b) {
            (Some(_), Some(_)) => 
                Err(D::Error::custom("multiple variants specified")),
            (Some(a), None) =>
                Ok(Example { field, an_enum: AnEnum::A(a) }),
            (None, Some(b)) => 
                Ok(Example { field, an_enum: AnEnum::B(b) }),
            (None, None) =>
                Err(D::Error::custom("no variants specified")),
        }
    }
}

fn main() {
    let a = r#"{ "field": 42, "A": 76 }"#;
    let b = r#"{ "field": 42, "B": 110 }"#;

    let a: Result<Example, _> = serde_json::from_str(a);
    let b: Result<Example, _> = serde_json::from_str(b);

    println!("{:?}", a);
    println!("{:?}", b);
}