Как я могу использовать Serde для сериализации HashMap со структурами в качестве ключей к JSON?

Question

Как я могу использовать Serde для сериализации HashMap со структурами в качестве ключей к JSON?

Я хочу сериализовать HashMap со структурами в качестве ключей:

extern crate serde_json; // 1.0.22
#[macro_use]
extern crate serde_derive; // 1.0.68

use std::collections::HashMap;

fn main() {
    #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash)]
    struct Foo {
        x: u64,
    }

    #[derive(Serialize, Deserialize, Debug)]
    struct Bar {
        x: HashMap<Foo, f64>,
    }

    let mut p = Bar { x: HashMap::new() };
    p.x.insert(Foo { x: 0 }, 0.0);
    let serialized = serde_json::to_string(&p).unwrap();
}

Этот код компилируется, но когда я запускаю его, я получаю сообщение об ошибке:

Error("key must be a string", line: 0, column: 0)'

Я изменил код:

#[derive(Serialize, Deserialize, Debug)]
struct Bar {
    x: HashMap<u64, f64>,
}

let mut p = Bar { x: HashMap::new() };
p.x.insert(0, 0.0);
let serialized = serde_json::to_string(&p).unwrap();

Ключ в HashMap сейчас u64 вместо строки. Почему первый код выдает ошибку?

41

rust serde serde-json

Источник

user5705424 11 июл '18 в 03:40

4 ответа

Решение

Вы можете использовать serde_as из serde_withящик для кодирования HashMap как последовательность пар ключ-значение:

use serde_with::serde_as; // 1.5.1

#[serde_as]
#[derive(Serialize, Deserialize, Debug)]
struct Bar {
    #[serde_as(as = "Vec<(_, _)>"]
    x: HashMap<Foo, f64>,
}

Что будет сериализовано (и десериализовано) это:

{
  "x":[
    [{"x": 0}, 0.0],
    [{"x": 1}, 0.0],
    [{"x": 2}, 0.0]
  ]
}

Вероятно, есть некоторые накладные расходы на преобразование HashMap к Vec, но это может быть очень удобно.

21

Источник

user493729 22 ноя '20 в 02:20

Я нашел пуленепробиваемое решение 😃

Дополнительные зависимости не требуются
Совместим с HashMap, BTreeMap и другие итерируемые типы
Работает с flexbuffers

Следующий код преобразует поле (карту) в промежуточное Vec представление:

      pub mod vectorize {
    use serde::{Deserialize, Deserializer, Serialize, Serializer};
    use std::iter::FromIterator;

    pub fn serialize<'a, T, K, V, S>(target: T, ser: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
        T: IntoIterator<Item = (&'a K, &'a V)>,
        K: Serialize + 'a,
        V: Serialize + 'a,
    {
        let container: Vec<_> = target.into_iter().collect();
        serde::Serialize::serialize(&container, ser)
    }

    pub fn deserialize<'de, T, K, V, D>(des: D) -> Result<T, D::Error>
    where
        D: Deserializer<'de>,
        T: FromIterator<(K, V)>,
        K: Deserialize<'de>,
        V: Deserialize<'de>,
    {
        let container: Vec<_> = serde::Deserialize::deserialize(des)?;
        Ok(T::from_iter(container.into_iter()))
    }
}

Чтобы использовать его, просто добавьте имя модуля в качестве атрибута:

      #[derive(Debug, Serialize, Deserialize)]
struct MyComplexType {
    #[serde(with = "vectorize")]
    map: HashMap<MyKey, String>,
}

Оставшаяся часть, если вы хотите проверить это локально:

      use anyhow::Error;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
struct MyKey {
    one: String,
    two: u16,
    more: Vec<u8>,
}

#[derive(Debug, Serialize, Deserialize)]
struct MyComplexType {
    #[serde(with = "vectorize")]
    map: HashMap<MyKey, String>,
}

fn main() -> Result<(), Error> {
    let key = MyKey {
        one: "1".into(),
        two: 2,
        more: vec![1, 2, 3],
    };
    let mut map = HashMap::new();
    map.insert(key.clone(), "value".into());
    let instance = MyComplexType { map };
    let serialized = serde_json::to_string(&instance)?;
    println!("JSON: {}", serialized);
    let deserialized: MyComplexType = serde_json::from_str(&serialized)?;
    let expected_value = "value".to_string();
    assert_eq!(deserialized.map.get(&key), Some(&expected_value));
    Ok(())
}

А на площадке Rust: https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=bf1773b6e501a0ea255ccdf8ce37e74d

5

Источник

user311655 12 мар '21 в 16:07

Хотя все предоставленные ответы будут выполнять цель сериализации вашего в json, они являются специальными или сложными в обслуживании.

Один из правильных способов разрешить сериализацию определенной структуры данных с ключами на карте — это тот же способ обработки целочисленных ключей в s (который работает): они сериализуют значение в String. Это имеет несколько преимуществ; а именно

Промежуточная структура данных опущена,
нет необходимости клонировать весь HashMap,
легче поддерживать, применяя концепции ООП, и
сериализация, используемая в более сложных структурах, таких как MultiMap.

Это можно сделать, вручную внедрив Serializeа также Deserializeдля вашего типа данных.

Я использую составные идентификаторы для карт.

      #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct Proj {
    pub value: u64,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct Doc {
    pub proj: Proj,
    pub value: u32,
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct Sec {
    pub doc: Doc,
    pub value: u32,
}

Так что теперь ручная реализация сериализации для них довольно хлопотна, поэтому вместо этого мы делегируем реализацию FromStrа также From<Self> for String( Into<String>одеяло) черты.

      impl From<Doc> for String {
    fn from(val: Doc) -> Self {
        format!("{}{:08X}", val.proj, val.value)
    }
}
impl FromStr for Doc {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match parse_doc(s) {
            Ok((_, p)) => Ok(p),
            Err(e) => Err(e.to_string()),
        }
    }
}

Для того, чтобы разобрать Docмы используемnom. Функциональность синтаксического анализа ниже объясняется в их примерах.

      fn is_hex_digit(c: char) -> bool {
    c.is_digit(16)
}

fn from_hex8(input: &str) -> Result<u32, std::num::ParseIntError> {
    u32::from_str_radix(input, 16)
}

fn parse_hex8(input: &str) -> IResult<&str, u32> {
    map_res(take_while_m_n(8, 8, is_hex_digit), from_hex8)(input)
}

fn parse_doc(input: &str) -> IResult<&str, Doc> {
    let (input, proj) = parse_proj(input)?;
    let (input, value) = parse_hex8(input)?;
    Ok((input, Doc { value, proj }))
}

Теперь нам нужно подключить self.to_string()а также str::parse(&str)к serdeмы можем сделать это с помощью простого макроса.

      macro_rules! serde_str {
    ($type:ty) => {
        impl Serialize for $type {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                let s: String = self.clone().into();
                serializer.serialize_str(&s)
            }
        }

        impl<'de> Deserialize<'de> for $type {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                paste! {deserializer.deserialize_string( [<$type Visitor>] {})}
            }
        }

        paste! {struct [<$type Visitor>] {}}

        impl<'de> Visitor<'de> for paste! {[<$type Visitor>]} {
            type Value = $type;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("\"")
            }

            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                match str::parse(v) {
                    Ok(id) => Ok(id),
                    Err(_) => Err(serde::de::Error::custom("invalid format")),
                }
            }
        }
    };
}

Здесь мы используемpasteинтерполировать имена. Имейте в виду, что теперь структура всегда будет сериализоваться, как определено выше. Никогда как структура, всегда как строка.

Важно реализовать fn visit_strвместо fn visit_stringпотому что visit_stringподчиняется visit_str.

Наконец, мы должны вызвать макрос для нашего пользовательского structс

      serde_str!(Sec);
serde_str!(Doc);
serde_str!(Proj);

Теперь указанные типы можно сериализовать в строку и из строки с помощью serde.

1

Источник

user6401643 19 фев '22 в 19:43

Другие вопросы по тегам rust serde serde-json

user4709888 11 июл '18 в 11:15 2018-07-11 11:15 · Accepted Answer · 2018-07-11 11:15

Чтобы сериализовать ваш пользовательский тип данных в JSON (или любой другой формат), вам необходимо реализовать Serialize черта характера. В противном случае Серде не знает, как сериализовать ваш тип.

Это должно пойти что-то вроде этого:

impl Display for Foo {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "{}", self.x)
    }
}

impl Serialize for Bar {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.x.len()))?;
        for (k, v) in &self.x {
            map.serialize_entry(&k.to_string(), &v)?;
        }
        map.end()
    }
}

( детская площадка)

Если ваша структура данных является перечислением, то вам нужно будет изменить Foo"s Display реализация.