Struct BytesOrString

pub struct BytesOrString;

Deserialize from bytes or string

Any Rust String can be converted into bytes, i.e., Vec<u8>. Accepting both as formats while deserializing can be helpful while interacting with language which have a looser definition of string than Rust.

Example

#[serde_as]
#[derive(Deserialize, Serialize)]
struct A {
    #[serde_as(as = "BytesOrString")]
    bytes_or_string: Vec<u8>,
}

// Here we deserialize from a byte array ...
let j = json!({
  "bytes_or_string": [
    0,
    1,
    2,
    3
  ]
});

let a: A = serde_json::from_value(j.clone()).unwrap();
assert_eq!(vec![0, 1, 2, 3], a.bytes_or_string);

// and serialization works too.
assert_eq!(j, serde_json::to_value(&a).unwrap());

// But we also support deserializing from a String
let j = json!({
  "bytes_or_string": "✨Works!"
});

let a: A = serde_json::from_value(j).unwrap();
assert_eq!("✨Works!".as_bytes(), &*a.bytes_or_string);

Trait Implementations

impl<'de> DeserializeAs<'de, Vec<u8>> for BytesOrString

fn deserialize_as<D>( deserializer: D, ) -> Result<Vec<u8>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl SerializeAs<Vec<u8>> for BytesOrString

fn serialize_as<S>( source: &Vec<u8>, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.