Struct serde_with::DefaultOnNull

pub struct DefaultOnNull<T = Same>(_);

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.

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

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<T: Clone> Clone for DefaultOnNull<T>

pub fn clone(&self) -> DefaultOnNull<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for DefaultOnNull<T>

impl<T: Debug> Debug for DefaultOnNull<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for DefaultOnNull<T>

pub fn default() -> DefaultOnNull<T>

Returns the "default value" for a type.

impl<'de, T, U> DeserializeAs<'de, T> for DefaultOnNull<U> where
    U: DeserializeAs<'de, T>,
    T: Default, 

pub 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>, 

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

Serialize this value into the given Serde serializer.