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<T: Clone> Clone for FromInto<T>

fn clone(&self) -> FromInto<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for FromInto<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for FromInto<T>

fn default() -> FromInto<T>

Returns the “default value” for a type.

impl<'de, T, U> DeserializeAs<'de, T> for FromInto<U> where
    U: Into<T>,
    U: 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.

impl<T: Copy> Copy for FromInto<T>