Struct serde_with::DisplayFromStr

pub struct DisplayFromStr;

De/Serialize using Display and FromStr implementation

This allows to deserialize 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.

The same functionality is also available as serde_with::rust::display_fromstr compatible with serde’s with-annotation.

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 Clone for DisplayFromStr

fn clone(&self) -> DisplayFromStr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for DisplayFromStr

impl Debug for DisplayFromStr

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

Formats the value using the given formatter.

impl Default for DisplayFromStr

fn default() -> DisplayFromStr

Returns the “default value” for a type.

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.