use core::convert::Infallible;
pub trait TryDigest {
type Error: core::error::Error;
fn digest_size(&self) -> usize;
fn byte_length(&self) -> usize;
fn try_update(&mut self, input: &[u8]) -> Result<(), Self::Error>;
fn try_update_byte(&mut self, input: u8) -> Result<(), Self::Error> {
self.try_update(&[input])
}
fn try_do_final(&mut self, output: &mut [u8]) -> Result<usize, Self::Error>;
fn try_reset(&mut self) -> Result<(), Self::Error>;
}
pub trait Digest: TryDigest<Error = Infallible> {
fn update(&mut self, input: &[u8]);
fn update_byte(&mut self, input: u8);
fn do_final(&mut self, output: &mut [u8]) -> usize;
fn reset(&mut self);
}
impl<D> Digest for D
where
D: TryDigest<Error = Infallible> + ?Sized,
{
fn update(&mut self, input: &[u8]) {
match self.try_update(input) {
Ok(()) => (),
}
}
fn update_byte(&mut self, input: u8) {
match self.try_update_byte(input) {
Ok(()) => (),
}
}
fn do_final(&mut self, output: &mut [u8]) -> usize {
match self.try_do_final(output) {
Ok(written) => written,
}
}
fn reset(&mut self) {
match self.try_reset() {
Ok(()) => (),
}
}
}
#[cfg(test)]
mod tests {
use core::convert::Infallible;
use super::{Digest, TryDigest};
#[derive(Default)]
struct SumDigest {
sum: u8,
}
impl TryDigest for SumDigest {
type Error = Infallible;
fn digest_size(&self) -> usize {
1
}
fn byte_length(&self) -> usize {
1
}
fn try_update(&mut self, input: &[u8]) -> Result<(), Self::Error> {
for byte in input {
self.sum = self.sum.wrapping_add(*byte);
}
Ok(())
}
fn try_do_final(&mut self, output: &mut [u8]) -> Result<usize, Self::Error> {
output[0] = self.sum;
self.sum = 0;
Ok(1)
}
fn try_reset(&mut self) -> Result<(), Self::Error> {
self.sum = 0;
Ok(())
}
}
#[test]
fn infallible_implementation_receives_digest_api() {
let mut digest = SumDigest::default();
digest.update(&[1, 2, 3]);
digest.update_byte(4);
let mut output = [0_u8; 1];
assert_eq!(digest.do_final(&mut output), 1);
assert_eq!(output, [10]);
}
#[test]
fn digest_supports_dynamic_dispatch() {
let mut concrete = SumDigest::default();
let digest: &mut dyn Digest = &mut concrete;
digest.update(&[5, 6]);
let mut output = [0_u8; 1];
assert_eq!(digest.do_final(&mut output), 1);
assert_eq!(output, [11]);
}
}