标签: serde

我有一个特质DataSet，我是Serialize这样实现的：

impl Serialize for dyn DataSet {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut seq = serializer.serialize_map(Some(2))?;
        seq.serialize_entry("fields", "Hello")?;
        seq.serialize_entry("measures", "There")?;
        seq.end()
    }
}

现在，在程序/应用程序中，我共享指向特征对象的指针：

let x: Arc<Mutex<dyn DataSet>> = Arc::new(Mutex::new(data));

哪里data有实现 DataSet 的对象。

现在，我想把这个对象转换成json（即序列化它）：

serde_json::to_string(&x)

它适用于Box而不是Arc<Mutex<>>. 但Arc<Mutex<>>编译器抱怨：

the size for values of type `dyn base_engine::DataSet` cannot be known at compilation time
the trait `Sized` is not implemented for `dyn base_engine::DataSet`
the …

在 Serde 序列化器中，如何添加附加字段：

#[derive(Serialize)]
struct X {
  a: u32,
  b: u32,
  c: u32,
}

我想添加到 JSON 序列化字段dvalue "qwe"。X如何不从头开始完全编写序列化器？

我有以下结构

#[derive(Serialize)]
pub struct MyStruct {
    pub id: String,
    pub score: f32,
    pub json: String,
}

该json字段始终包含已字符串化的有效 JSON 对象。

给定一个实例，我想使用 JSON 内容对其进行序列化。就像是：

let a = MyStruct {
    id: "my-id".to_owned(),
    score: 20.3,
    json: r#"{
       "ffo": 4
    }"#,
};
let r = to_string(&a).unwrap();
assert_eq!(r, r#"{
        "id": "my-id",
        "score": 20.3,
        "json": {
            "ffo": 4
        }
    }"#);

注意：我不需要支持不同的序列化格式，只需要支持 JSON。NB2：我确信该json字段始终包含有效的 JSON 对象。NB3：我通常使用 serde，但我愿意使用不同的库。

我怎样才能做到这一点？

编辑：如果可能的话，我想避免在序列化过程中反序列化字符串。

我知道serde是Rust世界中首选的序列化工具.但是,它似乎使用了稳定通道中不存在的功能.这是否意味着我在使用Rust稳定版时不能使用serde？我错过了什么吗？例如:

#![feature(proc_macro)]

#[macro_use]
extern crate serde_derive;

extern crate serde_json;

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

我想让Test::team_size属性从Test对象本身的数据中反序列化：

#[derive(Debug, Serialize, Deserialize)]
struct TeamSize {
    pub min: i64,
    pub max: i64,
}

#[derive(Debug, Serialize, Deserialize)]
struct Test {
    pub i: i64,
    pub team_size: TeamSize,
}

fn main() {
    let t: Test = serde_json::from_str(r#"{"i": -2, "min": 2, "max": 5}"#).unwrap();
    assert_eq!(t.i, -2);
    assert_eq!(t.team_size.min, 2);
    assert_eq!(t.team_size.max, 5);
}

这段代码无法编译，我不知道如何让 Serde 做我想做的事。team_size在这个例子中，有没有办法从作为子字段的原始结构的 JSON反序列化？

似乎我想要类似的东西， #[serde(untagged)]但是对于一个结构和一个字段而不是整个结构。

我正在使用serde和bincode映射二进制结构.

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

#[derive(Serialize, Deserialize)]
struct Superblock {
    magic: [u8; 16],
    //reserved: [u8; 492],
    crc: u32,
}

事情按预期工作,但我无法映射保留字段.显然,固定大小的数组仅定义为最大32个字节的大小.

如何注册我的自定义大小的数组,以便填充反序列化？

serde + bincode是正确的方法吗？我需要控制字节顺序(bincode提供),我喜欢声明式样式.

我正在开发 API 包装器，但在反序列化空 JSON 对象时遇到了一些麻烦。

API 返回此 JSON 对象。请注意以下位置的空对象entities：

{
  "object": "page",
  "entry": [
    {
      "id": "1158266974317788",
      "messaging": [
        {
          "sender": {
            "id": "some_id"
          },
          "recipient": {
            "id": "some_id"
          },
          "message": {
            "mid": "mid.$cAARHhbMo8SBllWARvlfZBrJc3wnP",
            "seq": 5728,
            "text": "test",
            "nlp": {
              "entities": {} // <-- here
            }
          }
        }
      ]
    }
  ]
}

这是我对message属性的等效结构（已编辑）：

 #[derive(Serialize, Deserialize, Clone, Debug)]
pub struct TextMessage {
    pub mid: String,
    pub seq: u64,
    pub text: String,
    pub nlp: NLP,
} …

我有这样的JSON:

{
    "fieldNames": ["MyInt", "MyFloat", "MyString"],
    "fieldValues": [5, 10.0, "hello"],
}

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

#[derive(Deserialize)]
struct MyStruct {
    my_int: u64,
    my_float: f64,
    my_string: String,
}

有没有办法用serde做到这一点？理想情况下,我想要的是:

#[serde(keys="fieldNames", values="fieldValues")]

我正在编写一个Rust应用程序,它使用公共接口处理来自TypeScript客户端的JSON消息.我已经编写了一些代码serde_derive并且运行良好,但我无法弄清楚如何实现字典; 例如:

{
  "foo" : { "data" : 42 },
  "bar" : { "data" : 1337 }
}

这里的键是字符串"foo","bar"字典的值遵循以下模式:

use serde_derive;
use serde_json::Number;

#[derive(Serialize, Deserialize)]
struct DictionaryValue {
    data: Number,
}

我希望以这种方式访问​​JSON数据:

#[derive(Serialize, Deserialize)]
struct Dictionary {
    key: String,
    value: DictionaryValue,
}

我如何(de)Dictionary使用Serde 将我的JSON数据序列化为/从？

我有一组以JSON形式出现的不同消息,可以基于单个字段进行区分,但每个变体都有不同的辅助字段集合:

#[derive(Debug, Serialize, Deserialize)]
struct MessageOne {
    ///op will always be "one"
    op: String,
    x: f64,
    y: f64,
}

#[derive(Debug, Serialize, Deserialize)]
struct MessageTwo {
    ///op will always be "two"
    op: String,
    a: f64,
    b: i64,
}

不同消息类型路由到不同的处理功能(例如process_message_one,process_message_two等).是否有一种优雅或惯用的方式来自动选择正确的消息子类型？目前我已经定义了一条通用消息:

#[derive(Debug, Serialize, Deserialize)]
struct MessageGeneric {
    op: String,
}

然后将传入的JSON解析为MessageGeneric,读取op字段然后再次反序列化,匹配op以选择正确的消息类型.完整示例:

#![allow(unused)]

extern crate serde; // 1.0.78
extern crate serde_json; // 1.0.27

#[macro_use]
extern crate serde_derive;

use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize)]
struct MessageGeneric …