Struct DefaultOnNull 

pub struct DefaultOnNull<T = Same>(/* private fields */);

Deserialize Default from null values

Instead of erroring on null values, it simply deserializes the Default variant of the type. During serialization this wrapper does nothing. The serialization behavior of the underlying type is preserved. The type must implement Default for this conversion to work.

Examples

#[serde_as]
#[derive(Deserialize, Debug)]
struct A {
    #[serde_as(deserialize_as = "DefaultOnNull")]
    value: u32,
}

let a: A = serde_json::from_str(r#"{"value": 123}"#).unwrap();
assert_eq!(123, a.value);

// null values are deserialized into the default, here 0
let a: A = serde_json::from_str(r#"{"value": null}"#).unwrap();
assert_eq!(0, a.value);

DefaultOnNull can be combined with other conversion methods. In this example, we deserialize a Vec, each element is deserialized from a string. If we encounter null, then we get the default value of 0.

#[serde_as]
#[derive(Serialize, Deserialize)]
struct C {
    #[serde_as(as = "Vec<DefaultOnNull<DisplayFromStr>>")]
    value: Vec<u32>,
}

let c: C = serde_json::from_value(json!({
    "value": ["1", "2", null, null, "5"]
})).unwrap();
assert_eq!(vec![1, 2, 0, 0, 5], c.value);

Trait Implementations

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

where U: DeserializeAs<'de, T>, T: Default,

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> SerializeAs<T> for DefaultOnNull<U>

where U: SerializeAs<T>,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 0 bytes