Struct serde_with::FromIntoRef

pub struct FromIntoRef<T>(/* private fields */);

Serialize a reference 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 = "FromIntoRef<T>")]
    value: O,
}

For serialization O needs to be for<'a> &'a O: Into<T>. For deserialization the opposite T: Into<O> is required.

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

Example

#[derive(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 = "FromIntoRef<(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 FromIntoRef<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<O, T: JsonSchema> JsonSchemaAs<O> for FromIntoRef<T>

Available on crate feature schemars_0_8 only.

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<T, U> SerializeAs<T> for FromIntoRef<U>

where for<'a> &'a T: Into<U>, 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.