|
| 1 | +//! A macro for defining a new type wrappers for the given hash types. |
| 2 | +
|
| 3 | +/// Defines a new type wrapper for the given hash types. |
| 4 | +/// |
| 5 | +/// # Examples |
| 6 | +/// |
| 7 | +/// ``` |
| 8 | +/// use cardano_blockchain_types::define_hashes; |
| 9 | +/// use cardano_blockchain_types::hashes::Blake2b128Hash; |
| 10 | +/// |
| 11 | +/// define_hashes!( |
| 12 | +/// /// You can document the declared types... |
| 13 | +/// (SomeHash, Blake2b128Hash), |
| 14 | +/// // ...or not. |
| 15 | +/// (AnotherHash, Blake2b128Hash), |
| 16 | +/// ); |
| 17 | +/// |
| 18 | +/// let hash = SomeHash::new(&[1, 2, 3]); |
| 19 | +/// println!("{hash:?}"); |
| 20 | +/// ``` |
| 21 | +#[macro_export] |
| 22 | +macro_rules! define_hashes { |
| 23 | + ($($(#[$docs:meta])* ($name:ident, $inner:ty)),+ $(,)?) => { |
| 24 | + $( |
| 25 | + $(#[$docs])* |
| 26 | + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| 27 | + pub struct $name($inner); |
| 28 | + |
| 29 | + impl $name { |
| 30 | + /// Creates a new instance from the given bytes by hashing them. |
| 31 | + #[must_use] |
| 32 | + pub fn new(input_bytes: &[u8]) -> Self { |
| 33 | + Self(<$inner>::new(input_bytes)) |
| 34 | + } |
| 35 | + } |
| 36 | + |
| 37 | + impl std::fmt::Display for $name { |
| 38 | + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| 39 | + f.write_str(&format!("0x{}", self.0)) |
| 40 | + } |
| 41 | + } |
| 42 | + |
| 43 | + impl From<$name> for Vec<u8> { |
| 44 | + fn from(value: $name) -> Self { |
| 45 | + value.0.into() |
| 46 | + } |
| 47 | + } |
| 48 | + |
| 49 | + impl From<$inner> for $name { |
| 50 | + fn from(value: $inner) -> Self { |
| 51 | + Self(value) |
| 52 | + } |
| 53 | + } |
| 54 | + |
| 55 | + impl TryFrom<&[u8]> for $name { |
| 56 | + type Error = $crate::hashes::Blake2bHashError; |
| 57 | + |
| 58 | + fn try_from(value: &[u8]) -> Result<Self, Self::Error> { |
| 59 | + Ok(Self(<$inner>::try_from(value)?)) |
| 60 | + } |
| 61 | + } |
| 62 | + |
| 63 | + impl TryFrom<Vec<u8>> for $name { |
| 64 | + type Error = $crate::hashes::Blake2bHashError; |
| 65 | + |
| 66 | + fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> { |
| 67 | + value.as_slice().try_into() |
| 68 | + } |
| 69 | + } |
| 70 | + |
| 71 | + impl std::str::FromStr for $name { |
| 72 | + type Err = $crate::hashes::Blake2bHashError; |
| 73 | + |
| 74 | + fn from_str(s: &str) -> Result<Self, Self::Err> { |
| 75 | + let hash: $inner = s.parse().map_err($crate::hashes::Blake2bHashError::from)?; |
| 76 | + Ok(Self(hash)) |
| 77 | + } |
| 78 | + } |
| 79 | + |
| 80 | + impl<C> minicbor::Encode<C> for $name { |
| 81 | + fn encode<W: minicbor::encode::Write>( |
| 82 | + &self, e: &mut minicbor::Encoder<W>, ctx: &mut C, |
| 83 | + ) -> Result<(), minicbor::encode::Error<W::Error>> { |
| 84 | + self.0.encode(e, ctx) |
| 85 | + } |
| 86 | + } |
| 87 | + |
| 88 | + impl<'a, C> minicbor::Decode<'a, C> for $name { |
| 89 | + fn decode( |
| 90 | + d: &mut minicbor::Decoder<'a>, ctx: &mut C, |
| 91 | + ) -> Result<Self, minicbor::decode::Error> { |
| 92 | + let hash = <$inner>::decode(d, ctx)?; |
| 93 | + Ok(Self(hash)) |
| 94 | + } |
| 95 | + } |
| 96 | + )+ |
| 97 | + }; |
| 98 | +} |
| 99 | + |
| 100 | +#[cfg(test)] |
| 101 | +mod tests { |
| 102 | + use crate::hashes::Blake2b128Hash; |
| 103 | + |
| 104 | + // Define one type without a trailing comma. |
| 105 | + define_hashes!((H1, Blake2b128Hash)); |
| 106 | + // Define one type with a trailing comma and a doc-comment. |
| 107 | + define_hashes!( |
| 108 | + /// Some documentation. |
| 109 | + (H2, Blake2b128Hash), |
| 110 | + ); |
| 111 | + // Define multiple types at once. |
| 112 | + define_hashes!( |
| 113 | + /// Documentation. |
| 114 | + (H3, Blake2b128Hash), |
| 115 | + // No documentation. |
| 116 | + (H4, Blake2b128Hash), |
| 117 | + /// More documentation. |
| 118 | + (H5, Blake2b128Hash), |
| 119 | + ); |
| 120 | + |
| 121 | + // There is little reason to check the conversion itself, it is mostly a demonstration |
| 122 | + // that the methods defined by the macro are working. |
| 123 | + #[test] |
| 124 | + fn hash_wrapper() { |
| 125 | + let hash = H1::new(&[1, 2, 3, 4, 5]); |
| 126 | + |
| 127 | + let v = Vec::from(hash); |
| 128 | + let from_slice = H1::try_from(v.as_slice()).unwrap(); |
| 129 | + assert_eq!(hash, from_slice); |
| 130 | + |
| 131 | + let from_vec = H1::try_from(v).unwrap(); |
| 132 | + assert_eq!(hash, from_vec); |
| 133 | + } |
| 134 | + |
| 135 | + // The display implementation is used to get user-friendly representation and must be |
| 136 | + // equal to `hex::encode(<underlying bytes>)`. |
| 137 | + #[test] |
| 138 | + fn display() { |
| 139 | + let hash = H1::new(&[1, 2, 3, 4, 5]); |
| 140 | + let display = format!("{hash}"); |
| 141 | + let expected = "0x2a6ad53c3c6986406e1d6c7cfd06b69a"; |
| 142 | + assert_eq!(expected, display); |
| 143 | + } |
| 144 | +} |
0 commit comments