主页 / coding / 问题 / 79162958
Accepted
Mindxxxd
Asked: 2024-11-06 22:09:05 +0800 CST

反序列化带有或不带有字段的枚举变量

  • 772

我有一个像下面这样的枚举

#[serde(rename_all="snake_case")]
pub enum Flag {
    One,
    Two,
    Three { value: Option<Decimal>}
}

我想匹配以下 JSON 表示形式

{"flag":"one"} // Working fine
{"flag":"two"} // Working fine
{"flag":{"three":{"value":###}} // Working fine -> Three { value: Some(###) }
{"flag":"three"} // not working, desired result -> Three { value: None }

我怎样才能得到这样的行为？

我已经尝试过了：

  • #[serde(default)]在变体上，但这只会匹配{"flag":{"three":{}}}
  • #[serde(untagged)]在变体上，但这适用于完整枚举
  • ThreeNone具有#[serde(rename="Three")]属性的另一种变体

请帮忙

json

1 个回答

  1. Best Answer

    假设您想要原样Flag，而不对enum及其变体进行任何更改。那么由于 JSON 的结构，这会变得有点棘手。

    当我遇到这些简单与复杂形式的 JSON 数据时，我通常会将其实现为多种类型。总体而言serde(untagged) enum。

    注意：变体的顺序很重要serde(untagged)，因为 serde 将按顺序尝试变体，并在成功反序列化时停止。

    为了保持原样Flag，您可以使用serde(from = ...)或通过其他类型serde(try_from ...)进行反序列化。其他类型也可以保持私密。

    为了演示目的，我已将您的 改为Decimal。u32但只要Decimal实现Deserialize，那么它们就可以互换。

    它看起来像这样：

    use serde::Deserialize;

#[derive(Deserialize, Debug)]
#[serde(from = "ComplexFlag")]
pub enum Flag {
    One,
    Two,
    Three { value: Option<u32> },
}

#[derive(Deserialize, Debug)]
#[serde(untagged)]
enum ComplexFlag {
    Three(ThreeFlag),
    Simple(SimpleFlag),
}

#[derive(Deserialize, Debug)]
#[serde(rename_all = "snake_case")]
enum SimpleFlag {
    One,
    Two,
    Three,
}

#[derive(Deserialize, Debug)]
struct ThreeFlag {
    three: ThreeData,
}

#[derive(Deserialize, Debug)]
struct ThreeData {
    value: Option<u32>,
}

    那么我们需要的是From<ComplexFlag> for Flag：

    impl From<ComplexFlag> for Flag {
    fn from(flag: ComplexFlag) -> Self {
        match flag {
            ComplexFlag::Simple(flag) => match flag {
                SimpleFlag::One => Self::One,
                SimpleFlag::Two => Self::Two,
                SimpleFlag::Three => Self::Three { value: None },
            },
            ComplexFlag::Three(flag) => Self::Three {
                value: flag.three.value,
            },
        }
    }
}

    使用下列方法测试它：

    #[derive(Deserialize, Debug)]
struct Data {
    flag: Flag,
}

let json = [
    r#"{"flag":"one"}"#,
    r#"{"flag":"two"}"#,
    r#"{"flag":"three"}"#,
    r#"{"flag":{"three":{"value":123}}}"#,
];

for json in json {
    let data = serde_json::from_str::<Data>(json);
    println!("{:?}", data);
}

    然后正确得出：

    Ok(Data { flag: One })
Ok(Data { flag: Two })
Ok(Data { flag: Three { value: None } })     
Ok(Data { flag: Three { value: Some(123) } })

    或者，您也可以手动Deserialize实现Flag：

    impl<'de> Deserialize<'de> for Flag {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let value = Value::deserialize(deserializer)?;

        Ok(match value.as_str() {
            Some(flag) => match flag {
                "one" => Self::One,
                "two" => Self::One,
                "three" => Self::Three { value: None },
                flag => {
                    return Err(D::Error::custom(format!("unexpected flag {flag:?}")));
                }
            },
            None => {
                let three = ThreeFlag::deserialize(value).map_err(D::Error::custom)?;
                Self::Three {
                    value: three.three.value,
                }
            }
        })
    }
}

    但这可能看起来更像黑客，更难维护。与中的重复代码SimpleFlag和手动From<ComplexFlag> for Flag实现相比。

    • 1

相关问题