Struct DisplayFromStr

pub struct DisplayFromStr;

De/Serialize using Display and FromStr implementation

This allows deserializing a string as a number. It can be very useful for serialization formats like JSON, which do not support integer numbers and have to resort to strings to represent them.

Another use case is types with Display and FromStr implementations, but without serde support, which can be found in some crates.

If you control the type you want to de/serialize, you can instead use the two derive macros, SerializeDisplay and DeserializeFromStr. They properly implement the traits serde::Serialize and serde::Deserialize such that user of the type no longer have to use the serde_as system.

Examples

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "DisplayFromStr")]
    mime: mime::Mime,
    #[serde_as(as = "DisplayFromStr")]
    number: u32,
}

let v: A = serde_json::from_value(json!({
    "mime": "text/plain",
    "number": "159",
})).unwrap();
assert_eq!(mime::TEXT_PLAIN, v.mime);
assert_eq!(159, v.number);

let x = A {
    mime: mime::STAR_STAR,
    number: 777,
};
assert_eq!(json!({ "mime": "*/*", "number": "777" }), serde_json::to_value(&x).unwrap());

Trait Implementations

impl<'de, T> DeserializeAs<'de, T> for DisplayFromStr

where T: FromStr, T::Err: 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> SerializeAs<T> for DisplayFromStr

where T: Display,

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

where S: Serializer,

Serialize this value into the given Serde serializer.