Struct serde_with::TryFromInto

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

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 = "TryFromInto<T>")]
    value: O,
}

For serialization O needs to be O: TryInto<T> + Clone. For deserialization the opposite T: TryInto<O> is required. The Clone bound is required since serialize operates on a reference but TryInto implementations on references are uncommon. In both cases the TryInto::Error type must implement Display.

Note: FromInto is the more specialized version of this adapter which uses the infallible Into trait instead. TryFromInto is strictly more general and can also be used where FromInto is applicable. The example shows a use case, when only the deserialization behavior is fallible, but not serializing.

Example

#[derive(Clone, Debug, PartialEq)]
enum Boollike {
    True,
    False,
}

impl From<Boollike> for u8 { ... }
impl TryFrom<u8> for Boollike {
    type Error = String;
    fn try_from(v: u8) -> Result<Self, Self::Error> {
        match v {
            0 => Ok(Boollike::False),
            1 => Ok(Boollike::True),
            _ => Err(format!("Boolikes can only be constructed from 0 or 1 but found {}", v))
        }
    }
}

#[serde_as]
#[derive(Deserialize, Serialize)]
struct Data {
    #[serde_as(as = "TryFromInto<u8>")]
    b: Boollike,
}
let data = Data {
    b: Boollike::True,
};

// Define our expected JSON form
let j = json!({
    "b": 1,
});
// Ensure serialization and deserialization produce the expected results
assert_eq!(j, serde_json::to_value(&data).unwrap());
assert_eq!(data, serde_json::from_value(j).unwrap());

// Numbers besides 0 or 1 should be an error
let j = json!({
    "b": 2,
});
assert_eq!("Boolikes can only be constructed from 0 or 1 but found 2", serde_json::from_value::<Data>(j).unwrap_err().to_string());

Trait Implementations

impl<'de, T, U> DeserializeAs<'de, T> for TryFromInto<U>

where U: TryInto<T> + Deserialize<'de>, <U as TryInto<T>>::Error: Display,

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: JsonSchema> JsonSchemaAs<T> for TryFromInto<U>

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 TryFromInto<U>

where T: TryInto<U> + Clone, <T as TryInto<U>>::Error: Display, 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.