1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
use core::errors::*;
use hex::FromHex;
use hex_slice::HexSlice;
use serde::{de, ser};
use std::fmt;
use std::ops::{Index, Range};
use std::result;
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct Checksum {
bytes: Vec<u8>,
}
impl Checksum {
pub fn new(bytes: Vec<u8>) -> Checksum {
Checksum { bytes: bytes }
}
pub fn from_str(input: &str) -> Result<Checksum> {
let bytes: Vec<u8> = FromHex::from_hex(input)?;
if bytes.len() != 32usize {
return Err("expected 32 bytes".into());
}
Ok(Checksum { bytes: bytes })
}
}
impl fmt::Debug for Checksum {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Checksum")
.field("bytes", &HexSlice::new(&self.bytes[..]))
.finish()
}
}
impl AsRef<[u8]> for Checksum {
fn as_ref(&self) -> &[u8] {
&self.bytes
}
}
impl Index<Range<usize>> for Checksum {
type Output = [u8];
#[inline]
fn index(&self, index: Range<usize>) -> &[u8] {
Index::index(&self.bytes[..], index)
}
}
impl fmt::Display for Checksum {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", HexSlice::new(&self.bytes[..]))
}
}
impl ser::Serialize for Checksum {
fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serializer.serialize_str(&format!("{}", HexSlice::new(&self.bytes[..])))
}
}
struct ChecksumVisitor;
impl<'de> de::Visitor<'de> for ChecksumVisitor {
type Value = Checksum;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
write!(formatter, "a hex encoded string of bytes")
}
fn visit_str<E>(self, value: &str) -> result::Result<Self::Value, E>
where
E: de::Error,
{
Checksum::from_str(value)
.map_err(|e| e.display())
.map_err(de::Error::custom)
}
fn visit_string<E>(self, value: String) -> result::Result<Self::Value, E>
where
E: de::Error,
{
self.visit_str(value.as_str())
}
}
impl<'de> de::Deserialize<'de> for Checksum {
fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
where
D: de::Deserializer<'de>,
{
deserializer.deserialize_str(ChecksumVisitor)
}
}