Struct serde_with::hex::Hex

pub struct Hex<FORMAT: Format = Lowercase>(_);

Serialize bytes as a hex string

The type serializes a sequence of bytes as a hexadecimal string. It works on any type implementing AsRef<[u8]> for serialization and From<Vec<u8>> for deserialization.

The format type parameter specifies if the hex string should use lower- or uppercase characters. Valid options are the types Lowercase and Uppercase. Deserialization always supports lower- and uppercase characters, even mixed in one string.

Example

#[serde_as]
#[derive(Deserialize, Serialize)]
struct BytesLowercase(
    // Equivalent to serde_with::hex::Hex<serde_with::formats::Lowercase>
    #[serde_as(as = "serde_with::hex::Hex")]
    Vec<u8>
);

#[serde_as]
#[derive(Deserialize, Serialize)]
struct BytesUppercase(
    #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Uppercase>")]
    Vec<u8>
);

let b = b"Hello World!";

// Hex with lowercase letters
assert_eq!(json!("48656c6c6f20576f726c6421"), serde_json::to_value(BytesLowercase(b.to_vec())).unwrap());
// Hex with uppercase letters
assert_eq!(json!("48656C6C6F20576F726C6421"), serde_json::to_value(BytesUppercase(b.to_vec())).unwrap());

// Serialization always work from lower- and uppercase characters, even mixed case.
assert_eq!(BytesLowercase(vec![0x00, 0xaa, 0xbc, 0x99, 0xff]), serde_json::from_value(json!("00aAbc99FF")).unwrap());
assert_eq!(BytesUppercase(vec![0x00, 0xaa, 0xbc, 0x99, 0xff]), serde_json::from_value(json!("00aAbc99FF")).unwrap());

Trait Implementations

impl<FORMAT: Clone + Format> Clone for Hex<FORMAT>

fn clone(&self) -> Hex<FORMAT>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<FORMAT: Copy + Format> Copy for Hex<FORMAT>

impl<FORMAT: Debug + Format> Debug for Hex<FORMAT>

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

Formats the value using the given formatter.

impl<FORMAT: Default + Format> Default for Hex<FORMAT>

fn default() -> Hex<FORMAT>

Returns the "default value" for a type.

impl<'de, T, FORMAT> DeserializeAs<'de, T> for Hex<FORMAT> where
    T: From<Vec<u8>>,
    FORMAT: Format, 

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 Hex<Lowercase> where
    T: AsRef<[u8]>, 

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

Serialize this value into the given Serde serializer.

impl<T> SerializeAs<T> for Hex<Uppercase> where
    T: AsRef<[u8]>, 

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

Serialize this value into the given Serde serializer.