Struct serde_with::NoneAsEmptyString

pub struct NoneAsEmptyString;

De/Serialize a Option<String> type while transforming the empty string to None

Convert an Option<T> from/to string using FromStr and AsRef<str> implementations. An empty string is deserialized as None and a None vice versa.

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

Examples

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "NoneAsEmptyString")]
    tags: Option<String>,
}

let v: A = serde_json::from_value(json!({ "tags": "" })).unwrap();
assert_eq!(None, v.tags);

let v: A = serde_json::from_value(json!({ "tags": "Hi" })).unwrap();
assert_eq!(Some("Hi".to_string()), v.tags);

let x = A {
    tags: Some("This is text".to_string()),
};
assert_eq!(json!({ "tags": "This is text" }), serde_json::to_value(&x).unwrap());

let x = A {
    tags: None,
};
assert_eq!(json!({ "tags": "" }), serde_json::to_value(&x).unwrap());

Trait Implementations

impl Clone for NoneAsEmptyString

fn clone(&self) -> NoneAsEmptyString

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for NoneAsEmptyString

impl Debug for NoneAsEmptyString

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

Formats the value using the given formatter.

impl Default for NoneAsEmptyString

fn default() -> NoneAsEmptyString

Returns the "default value" for a type.

impl<'de, Str> DeserializeAs<'de, Option<Str>> for NoneAsEmptyString where
    Str: for<'a> From<&'a str>, 

fn deserialize_as<D>(deserializer: D) -> Result<Option<Str>, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<AsRefStr> SerializeAs<Option<AsRefStr>> for NoneAsEmptyString where
    AsRefStr: AsRef<str>, 

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

Serialize this value into the given Serde serializer.