Struct serde_with::FromInto

pub struct FromInto<T>(_);

Serialize value by converting to/from a proxy type with serde support.

This adapter serializes a type O by converting it into a second type T and serializing T. Deserializing works analogue, by deserializing a T and then converting into O.

struct S {
    #[serde_as(as = "FromInto<T>")]
    value: O,
}

For serialization O needs to be O: Into<T> + Clone. For deserialization the opposite T: Into<O> is required. The Clone bound is required since serialize operates on a reference but Into implementations on references are uncommon.

Note: TryFromInto is the more generalized version of this adapter which uses the TryInto trait instead.

Example

#[derive(Clone, Debug, PartialEq)]
struct Rgb {
    red: u8,
    green: u8,
    blue: u8,
}

impl From<(u8, u8, u8)> for Rgb { ... }
impl From<Rgb> for (u8, u8, u8) { ... }

#[serde_as]
#[derive(Deserialize, Serialize)]
struct Color {
    #[serde_as(as = "FromInto<(u8, u8, u8)>")]
    rgb: Rgb,
}
let color = Color {
    rgb: Rgb {
        red: 128,
        green: 64,
        blue: 32,
    },
};

// Define our expected JSON form
let j = json!({
    "rgb": [128, 64, 32],
});
// Ensure serialization and deserialization produce the expected results
assert_eq!(j, serde_json::to_value(&color).unwrap());
assert_eq!(color, serde_json::from_value(j).unwrap());

Trait Implementations

impl<'de, T, U> DeserializeAs<'de, T> for FromInto<U>where
    U: Into<T> + Deserialize<'de>,

fn deserialize_as<D>(deserializer: D) -> Result<T, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, U> SerializeAs<T> for FromInto<U>where
    T: Into<U> + Clone,
    U: Serialize,

fn serialize_as<S>(source: &T, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.