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
use super::{Error, Reader, Writer};
use std::str::FromStr;
use serde::{de::Visitor, Deserialize, Serialize};
use sha2::{digest::DynDigest, Digest as _, Sha224, Sha256, Sha384, Sha512};
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum Algorithm {
Sha224,
Sha256,
Sha384,
Sha512,
}
impl AsRef<str> for Algorithm {
fn as_ref(&self) -> &str {
match self {
Self::Sha224 => "sha-224",
Self::Sha256 => "sha-256",
Self::Sha384 => "sha-384",
Self::Sha512 => "sha-512",
}
}
}
impl std::fmt::Display for Algorithm {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_ref())
}
}
impl FromStr for Algorithm {
type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match &*s.to_ascii_lowercase() {
"sha-224" => Ok(Self::Sha224),
"sha-256" => Ok(Self::Sha256),
"sha-384" => Ok(Self::Sha384),
"sha-512" => Ok(Self::Sha512),
_ => Err(Error::UnknownAlgorithm),
}
}
}
impl Serialize for Algorithm {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.as_ref().serialize(serializer)
}
}
impl<'de> Deserialize<'de> for Algorithm {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct StrVisitor;
impl Visitor<'_> for StrVisitor {
type Value = Algorithm;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("a Content-Digest algorithm name")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Self::Value, E> {
v.parse().map_err(|_| E::custom("unknown algorithm"))
}
fn visit_string<E: serde::de::Error>(self, v: String) -> Result<Self::Value, E> {
v.parse().map_err(|_| E::custom("unknown algorithm"))
}
}
deserializer.deserialize_str(StrVisitor)
}
}
impl Algorithm {
pub(crate) fn hasher(self) -> Box<dyn DynDigest> {
match self {
Self::Sha224 => Box::new(Sha224::new()),
Self::Sha256 => Box::new(Sha256::new()),
Self::Sha384 => Box::new(Sha384::new()),
Self::Sha512 => Box::new(Sha512::new()),
}
}
pub fn reader<T>(&self, reader: T) -> Reader<T> {
Reader::new(reader, [*self])
}
pub fn writer<T>(&self, writer: T) -> Writer<T> {
Writer::new(writer, [*self])
}
}