Struct serde_with::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 [Serialize] and [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 DisplayFromStrwhere
    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 DisplayFromStrwhere
    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.