src/serde_hex.rs

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 // See Notices.txt for copyright information
   3
   4 use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
   5
   6 pub(crate) trait SerdeHex {
   7     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
   8     fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
   9     where
  10         Self: Sized;
  11 }
  12
  13 #[derive(Deserialize, Serialize)]
  14 struct SerdeHexWrapper<T: SerdeHex>(#[serde(with = "SerdeHex")] T);
  15
  16 fn serialize_ref_helper<T: SerdeHex, S: Serializer>(
  17     v: &&T,
  18     serializer: S,
  19 ) -> Result<S::Ok, S::Error> {
  20     v.serialize(serializer)
  21 }
  22
  23 #[derive(Serialize)]
  24 struct SerdeHexRefWrapper<'a, T: SerdeHex>(#[serde(serialize_with = "serialize_ref_helper")] &'a T);
  25
  26 impl<T: SerdeHex> SerdeHex for Option<T> {
  27     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
  28         self.as_ref().map(SerdeHexRefWrapper).serialize(serializer)
  29     }
  30     fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
  31     where
  32         Self: Sized,
  33     {
  34         Ok(Option::<SerdeHexWrapper<T>>::deserialize(deserializer)?.map(|v| v.0))
  35     }
  36 }
  37
  38 macro_rules! impl_hex_for_uint {
  39     ($ty:ty) => {
  40         impl SerdeHex for $ty {
  41             fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
  42                 serializer.serialize_str(&format!("{:#X}", self))
  43             }
  44             fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
  45                 let text: &str = Deserialize::deserialize(deserializer)?;
  46                 const PREFIX: &str = "0x";
  47                 if text.starts_with(PREFIX) {
  48                     let hex_digits = &text[PREFIX.len()..];
  49                     Self::from_str_radix(hex_digits, 16).map_err(de::Error::custom)
  50                 } else {
  51                     Err(de::Error::custom("hexadecimal field must start with 0x"))
  52                 }
  53             }
  54         }
  55     };
  56 }
  57
  58 impl_hex_for_uint!(u8);
  59 impl_hex_for_uint!(u16);
  60 impl_hex_for_uint!(u32);
  61 impl_hex_for_uint!(u64);
  62 impl_hex_for_uint!(u128);