Struct SerializingHasher 

pub struct SerializingHasher<Inner> { /* private fields */ }

Converts a hasher which can hash bytes, u32’s or u64’s into a hasher which can hash field elements.

Supports two types of hashing.

• Hashing a sequence of field elements.
• Hashing a sequence of arrays of N field elements as if we are hashing N sequences of field elements in parallel. This is useful when the inner hash is able to use vectorized instructions to compute multiple hashes at once.

Implementations

impl<Inner> SerializingHasher<Inner>

pub const fn new(inner: Inner) -> Self

Trait Implementations

impl<Inner: Clone> Clone for SerializingHasher<Inner>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Inner: Copy> Copy for SerializingHasher<Inner>

impl<F, Inner, const N: usize> CryptographicHasher<F, [u8; N]> for SerializingHasher<Inner>

where F: Field, Inner: CryptographicHasher<u8, [u8; N]>,

const LANES: usize

Forwarded from the inner byte hasher, the one digest shape here that batches.

The [u32; N] and [u64; N] shapes wrap word sponges that hash a single message per call. The packed [[uX; M]; N] shapes already drive a vector permutation, one lane per packed slot.

Both keep the trait default of one lane, which routes a Merkle tree through its packed arm.

fn hash_iter<I>(&self, input: I) -> [u8; N]

where I: IntoIterator<Item = F>,

Hash an iterator of input items.

fn hash_many(&self, input: &[F], out: &mut [[u8; N]])

Hash a batch of equal-length messages, one digest per message.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

impl<F, Inner, const N: usize> CryptographicHasher<F, [u32; N]> for SerializingHasher<Inner>

where F: Field, Inner: CryptographicHasher<u32, [u32; N]>,

fn hash_iter<I>(&self, input: I) -> [u32; N]

where I: IntoIterator<Item = F>,

Hash an iterator of input items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl<F, Inner, const N: usize> CryptographicHasher<F, [u64; N]> for SerializingHasher<Inner>

where F: Field, Inner: CryptographicHasher<u64, [u64; N]>,

fn hash_iter<I>(&self, input: I) -> [u64; N]

where I: IntoIterator<Item = F>,

Hash an iterator of input items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl<F, Inner, const N: usize, const M: usize> CryptographicHasher<[F; M], [[u8; M]; N]> for SerializingHasher<Inner>

where F: Field, Inner: CryptographicHasher<[u8; M], [[u8; M]; N]>,

fn hash_iter<I>(&self, input: I) -> [[u8; M]; N]

where I: IntoIterator<Item = [F; M]>,

Hash an iterator of input items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl<F, Inner, const N: usize, const M: usize> CryptographicHasher<[F; M], [[u32; M]; N]> for SerializingHasher<Inner>

where F: Field, Inner: CryptographicHasher<[u32; M], [[u32; M]; N]>,

fn hash_iter<I>(&self, input: I) -> [[u32; M]; N]

where I: IntoIterator<Item = [F; M]>,

Hash an iterator of input items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

const PREFER_CONTIGUOUS_INPUT: bool = false

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl<F, Inner, const N: usize, const M: usize> CryptographicHasher<[F; M], [[u64; M]; N]> for SerializingHasher<Inner>

where F: Field, Inner: CryptographicHasher<[u64; M], [[u64; M]; N]>,

const PREFER_CONTIGUOUS_INPUT: bool

Whether materializing a compound input iterator can improve hashing throughput.

fn hash_iter<I>(&self, input: I) -> [[u64; M]; N]

where I: IntoIterator<Item = [F; M]>,

Hash an iterator of input items.

const LANES: usize = 1

Number of equal-length messages this implementation hashes most efficiently in one call.

fn hash_iter_slices<'a, I>(&self, input: I) -> Out

where I: IntoIterator<Item = &'a [Item]>, Item: 'a,

Hash an iterator of slices, by flattening it into a single stream of items.

fn hash_slice(&self, input: &[Item]) -> Out

Hash a single slice of items.

fn hash_item(&self, input: Item) -> Out

Hash a single item.

fn hash_many(&self, input: &[Item], out: &mut [Out])

Hash a batch of equal-length messages, one digest per message.

impl<Inner: Debug> Debug for SerializingHasher<Inner>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.