Crate serde_mappable_seq

serde-mappable-seq

An unofficial third-party crate to deserialize sequences of keyed structs into HashMaps or BTreeMaps and vice versa.

Sometimes APIs will provide a list of instances of a resource in a sequence, such as a list of users. Imagine this JSON payload:

{
  "data": {
    "users": [
      {
        "id": 1,
        "name": "foo"
      }
    ]
  },
  "links": {}
}

If you want to get something by ID, you're going to either need to post-process it manually (slightly annoying) or loop through to find the user with the ID (slightly costly).

serde-mappable-seq makes turning a sequence of a resource into a keyed map easy.

Installation

This library requires at least Rust 1.31.0.

Add this to your Cargo.toml:

[dependencies]
serde-mappable-seq = "0.1"

Examples

Deserialize a struct containing a sequence of 2 users into a HashMap, keyed by their IDs:

use serde_derive::{Deserialize, Serialize};
use serde_mappable_seq::Key;
use std::collections::HashMap;

#[derive(Deserialize, Serialize)]
struct User {
    id: u64,
    name: String,
}

impl Key<'_, u64> for User {
    fn key(&self) -> u64 {
        self.id
    }
}

#[derive(Deserialize, Serialize)]
struct Response {
    #[serde(with = "serde_mappable_seq")]
    users: HashMap<u64, User>,
}

let input = r#"{
  "users": [
    {
      "id": 1,
      "name": "foo"
    }
  ]
}"#;

let response = serde_json::from_str::<Response>(input)?;
assert_eq!("foo", response.users.get(&1).unwrap().name);

// Now serialize it back and make sure it's the same as the original input.
assert_eq!(input, serde_json::to_string_pretty(&response)?);

Serializing the instance of the response struct in the above example will net back the original input.

License

ISC.

Re-exports

pub use self::hashmap::deserialize;

pub use self::hashmap::serialize;

Modules

btreemap	Functions for (de)serializing to and from BTreeMaps.
hashmap	Functions for (de)serializing to and from BTreeMaps.

Traits

Key	The key to a keyed resource.