Trait MultiDigest

pub trait MultiDigest<const N: usize>: Clone {
    type Digest: Digest;

    // Required methods
    fn new() -> Self;
    fn update(&mut self, data: [&[u8]; N]);
    fn finalize_into(self, out: &mut [MaybeUninit<Output<Self::Digest>>; N]);
    fn finalize_into_reset(
        &mut self,
        out: &mut [MaybeUninit<Output<Self::Digest>>; N],
    );
    fn reset(&mut self);
    fn digest(
        data: [&[u8]; N],
        out: &mut [MaybeUninit<Output<Self::Digest>>; N],
    );

    // Provided methods
    fn new_with_prefix(data: impl AsRef<[u8]>) -> Self { ... }
    fn chain_update(self, data: [&[u8]; N]) -> Self { ... }
}

An object that efficiently computes N instances of a cryptographic hash function in parallel.

This trait is useful when there is a more efficient way of calculating multiple digests at once, e.g. using SIMD instructions. It is supposed that this trait is implemented directly for some digest and some fixed N and passed as an implementation of the ParallelDigest trait which hides the N value.

Required Associated Types

type Digest: Digest

The corresponding non-parallelized hash function.

Required Methods

fn new() -> Self

Create new hasher instance with empty state.

fn update(&mut self, data: [&[u8]; N])

Process data, updating the internal state. The number of rows in data must be equal to parallel_instances().

fn finalize_into(self, out: &mut [MaybeUninit<Output<Self::Digest>>; N])

Write result into provided array and consume the hasher instance.

fn finalize_into_reset( &mut self, out: &mut [MaybeUninit<Output<Self::Digest>>; N], )

Write result into provided array and reset the hasher instance.

fn reset(&mut self)

Reset hasher instance to its initial state.

fn digest(data: [&[u8]; N], out: &mut [MaybeUninit<Output<Self::Digest>>; N])

Compute hash of data. All slices in the data must have the same length.

Panics

Panics if data contains slices of different lengths.

Provided Methods

fn new_with_prefix(data: impl AsRef<[u8]>) -> Self

Create new hasher instance which has processed the provided data.

fn chain_update(self, data: [&[u8]; N]) -> Self

Process input data in a chained manner.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl MultiDigest<HASHES_PER_BYTE_SLICED_PERMUTATION> for VisionHasherDigestByteSliced

type Digest = VisionHasherDigest