Crate musli_serde

Transparent shim to use serde types in Müsli.

This conveniently and transparently allows Müsli to use fields which are serde types by marking them with #[musli(with = musli_serde)]. This can be useful because there is a wide ecosystem of types which implements serde traits.

Note that the exact method that fields are serialized and deserialized will not match what Müsli does, since serde requires the use of a fundamentally different model and Müsli metadata such as #[musli(name = ..)] is not available in serde.

Examples

use serde::{Serialize, Deserialize};
use musli::{Encode, Decode};
use url::Url;

#[derive(Serialize, Deserialize)]
struct Address {
    street: String,
    city: String,
    zip: u32,
}

#[derive(Encode, Decode)]
#[musli(name_all = "name")]
struct Person {
    name: String,
    #[musli(with = musli_serde)]
    address: Address,
    #[musli(with = musli_serde)]
    url: Url,
}

A compatible Müsli structure would look like this:

use musli::{Encode, Decode};
use url::Url;

#[derive(Encode, Decode)]
#[musli(name_all = "name")]
struct MusliAddress {
    street: String,
    city: String,
    zip: u32,
}

#[derive(Encode, Decode)]
#[musli(name_all = "name")]
struct MusliPerson {
    name: String,
    address: MusliAddress,
    url: String,
}

let json = musli_json::to_string(&Person {
    name: "John Doe".to_string(),
    address: Address {
        street: "Main St.".to_string(),
        city: "Springfield".to_string(),
        zip: 12345,
    },
    url: Url::parse("https://example.com")?,
})?;

let musli = musli_json::from_str::<MusliPerson>(&json)?;

assert_eq!(musli.name, "John Doe");
assert_eq!(musli.address.street, "Main St.");
assert_eq!(musli.address.city, "Springfield");
assert_eq!(musli.address.zip, 12345);
assert_eq!(musli.url, "https://example.com/");

Functions

• decode
  Decode the given serde value T from the given Decoder using the serde compatibility layer.
• encode
  Encode the given serde value T to the given Encoder using the serde compatibility layer.