72 lines
1.6 KiB
Rust
72 lines
1.6 KiB
Rust
use std::str::FromStr;
|
|
use rustc_serialize::hex::{FromHex, ToHex};
|
|
use serde::{Serialize, Serializer, Deserialize, Deserializer, Error as SerdeError};
|
|
use serde::de::Visitor;
|
|
use super::Error;
|
|
|
|
macro_rules! impl_hash {
|
|
($name: ident, $size: expr) => {
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct $name([u8; $size]);
|
|
|
|
impl Serialize for $name {
|
|
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
|
|
where S: Serializer {
|
|
serializer.serialize_str(&self.0.to_hex())
|
|
}
|
|
}
|
|
|
|
impl Deserialize for $name {
|
|
fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
|
|
where D: Deserializer {
|
|
struct HashVisitor;
|
|
|
|
impl Visitor for HashVisitor {
|
|
type Value = $name;
|
|
|
|
fn visit_str<E>(&mut self, value: &str) -> Result<Self::Value, E> where E: SerdeError {
|
|
FromStr::from_str(value).map_err(SerdeError::custom)
|
|
}
|
|
|
|
fn visit_string<E>(&mut self, value: String) -> Result<Self::Value, E> where E: SerdeError {
|
|
self.visit_str(value.as_ref())
|
|
}
|
|
}
|
|
|
|
deserializer.deserialize(HashVisitor)
|
|
}
|
|
}
|
|
|
|
impl FromStr for $name {
|
|
type Err = Error;
|
|
|
|
fn from_str(value: &str) -> Result<Self, Self::Err> {
|
|
match value.from_hex() {
|
|
Ok(ref hex) if hex.len() == $size => {
|
|
let mut hash = [0u8; $size];
|
|
hash.clone_from_slice(hex);
|
|
Ok($name(hash))
|
|
}
|
|
_ => Err(Error::InvalidH256),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<[u8; $size]> for $name {
|
|
fn from(bytes: [u8; $size]) -> Self {
|
|
$name(bytes)
|
|
}
|
|
}
|
|
|
|
impl Into<[u8; $size]> for $name {
|
|
fn into(self) -> [u8; $size] {
|
|
self.0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl_hash!(H128, 16);
|
|
impl_hash!(H160, 20);
|
|
impl_hash!(H256, 32);
|