Struct `Digest`

struct Digest<'a, W: Width, I: Implementation = Table<1>> { ... }

Implementations

`impl<'a, L: usize> Digest<'a, u128, Table<L>>`

fn update(self: &mut Self, bytes: &[u8])
const fn finalize(self: Self) -> u128

`impl<'a, L: usize> Digest<'a, u16, Table<L>>`

fn update(self: &mut Self, bytes: &[u8])
const fn finalize(self: Self) -> u16

`impl<'a, L: usize> Digest<'a, u32, Table<L>>`

fn update(self: &mut Self, bytes: &[u8])
const fn finalize(self: Self) -> u32

`impl<'a, L: usize> Digest<'a, u64, Table<L>>`

fn update(self: &mut Self, bytes: &[u8])
const fn finalize(self: Self) -> u64

`impl<'a, L: usize> Digest<'a, u8, Table<L>>`

fn update(self: &mut Self, bytes: &[u8])
const fn finalize(self: Self) -> u8

`impl<'a, W, I> Freeze for Digest<'a, W, I>`

`impl<'a, W, I> RefUnwindSafe for Digest<'a, W, I>`

`impl<'a, W, I> Send for Digest<'a, W, I>`

`impl<'a, W, I> Sync for Digest<'a, W, I>`

`impl<'a, W, I> Unpin for Digest<'a, W, I>`

`impl<'a, W, I> UnwindSafe for Digest<'a, W, I>`

`impl<'a, W: $crate::clone::Clone + Width, I: $crate::clone::Clone + Implementation> Clone for Digest<'a, W, I>`

fn clone(self: &Self) -> Digest<'a, W, I>

`impl<T> Any for Digest<'a, W, I>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Digest<'a, W, I>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Digest<'a, W, I>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Digest<'a, W, I>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Digest<'a, W, I>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for Digest<'a, W, I>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Digest<'a, W, I>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Digest<'a, W, I>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>