json - 反序列化为具有枚举成员的结构

Question

我正在尝试获取一些如下所示的 json:

{
    "foo": "bar",
    "name": "some name"
}

并使用serde将其反序列化为这样的数据结构:

#[derive(Clone, PartialEq, Debug)]
pub struct Quux {
    foo: Foo,
    name: String,

}

pub enum Foo {
    Bar,
    Baz,
}

我have some code ，但老实说，它几乎是直接来自 serde 的“不使用宏进行反序列化”指南，我不确定我需要做什么才能反序列化 foo字段为 Foo .

我已经实现了Deserialize对于 Foo枚举，我认为这对于 visitor.visit_value() 已经足够了调用我impl serde::de::Vistor for QuuxVisitor调用该版本的 deserialize ，但似乎并非如此。

当我尝试反序列化为 Quux 时遇到的错误是called 'Result::unwrap()' on an 'Err' value: SyntaxError("expected value", 2, 20) , 但如果我改变 Quux使用 String对于 foo而不是 Foo ，反序列化很好。

Answer 1

有一个 Rust 1.18/serde 1.0.0 的完整示例:

impl<'de> Deserialize<'de> for EventKind {
    fn deserialize<D>(deserializer: D) -> result::Result<EventKind, D::Error>
        where D: Deserializer<'de>
    {
        struct FieldVisitor {
            min: usize,
        };

        impl<'de> Visitor<'de> for FieldVisitor {
            type Value = EventKind;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                write!(formatter, "a string containing at least {} bytes", self.min)
            }

            fn visit_str<E>(self, value: &str) -> result::Result<EventKind, E>
                where E: serde::de::Error
            {
                let kind = match value {
                    "request" => EventKind::Request,
                    "ready" => EventKind::Ready,
                    "next" => EventKind::Next,
                    "reject" => EventKind::Reject,
                    "fail" => EventKind::Fail,
                    "done" => EventKind::Done,
                    "cancel" => EventKind::Cancel,
                    "suspended" => EventKind::Suspended,
                    s => {
                        return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(s),
                                                                   &self));
                    }
                };
                Ok(kind)
            }
        }
        deserializer.deserialize_str(FieldVisitor { min: 4 })
    }
}

enum EventKind {
    Request,
    Ready,
    Next,
    Reject,
    Fail,
    Done,
    Cancel,
    Suspended,
}

impl Serialize for EventKind {
    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
        where S: Serializer
    {
        let kind = match *self {
            EventKind::Request => "request",
            EventKind::Ready => "ready",
            EventKind::Next => "next",
            EventKind::Reject => "reject",
            EventKind::Fail => "fail",
            EventKind::Done => "done",
            EventKind::Cancel => "cancel",
            EventKind::Suspended => "suspended",
        };
        serializer.serialize_str(kind)
    }
}

可以看到类似的例子here .