Trait RawDataSerializable 

pub trait RawDataSerializable: Sized {
    const NUM_BYTES: usize;

    // Required method
    fn into_bytes(self) -> impl IntoIterator<Item = u8>;

    // Provided methods
    fn into_byte_stream(
        input: impl IntoIterator<Item = Self>,
    ) -> impl IntoIterator<Item = u8> { ... }
    fn into_u32_stream(
        input: impl IntoIterator<Item = Self>,
    ) -> impl IntoIterator<Item = u32> { ... }
    fn into_u64_stream(
        input: impl IntoIterator<Item = Self>,
    ) -> impl IntoIterator<Item = u64> { ... }
    fn into_parallel_byte_streams<const N: usize>(
        input: impl IntoIterator<Item = [Self; N]>,
    ) -> impl IntoIterator<Item = [u8; N]> { ... }
    fn into_parallel_u32_streams<const N: usize>(
        input: impl IntoIterator<Item = [Self; N]>,
    ) -> impl IntoIterator<Item = [u32; N]> { ... }
    fn into_parallel_u64_streams<const N: usize>(
        input: impl IntoIterator<Item = [Self; N]>,
    ) -> impl IntoIterator<Item = [u64; N]> { ... }
}

A collection of methods designed to help hash field elements.

Most fields will want to reimplement many/all of these methods as the default implementations are slow and involve converting to/from byte representations.

Required Associated Constants

const NUM_BYTES: usize

The number of bytes which this field element occupies in memory. Must be equal to the length of self.into_bytes().

Required Methods

fn into_bytes(self) -> impl IntoIterator<Item = u8>

Convert a field element into a collection of bytes.

Provided Methods

fn into_byte_stream( input: impl IntoIterator<Item = Self>, ) -> impl IntoIterator<Item = u8>

Convert an iterator of field elements into an iterator of bytes.

fn into_u32_stream( input: impl IntoIterator<Item = Self>, ) -> impl IntoIterator<Item = u32>

Convert an iterator of field elements into an iterator of u32s.

If NUM_BYTES does not divide 4, multiple Fs may be packed together to make a single u32. Furthermore, if NUM_BYTES * input.len() does not divide 4, the final u32 will involve padding bytes which are set to 0.

fn into_u64_stream( input: impl IntoIterator<Item = Self>, ) -> impl IntoIterator<Item = u64>

Convert an iterator of field elements into an iterator of u64s.

If NUM_BYTES does not divide 8, multiple Fs may be packed together to make a single u64. Furthermore, if NUM_BYTES * input.len() does not divide 8, the final u64 will involve padding bytes which are set to 0.

fn into_parallel_byte_streams<const N: usize>( input: impl IntoIterator<Item = [Self; N]>, ) -> impl IntoIterator<Item = [u8; N]>

Convert an iterator of field element arrays into an iterator of byte arrays.

Converts an element [F; N] into the byte array [[u8; N]; NUM_BYTES]. This is intended for use with vectorized hash functions which use vector operations to compute several hashes in parallel.

fn into_parallel_u32_streams<const N: usize>( input: impl IntoIterator<Item = [Self; N]>, ) -> impl IntoIterator<Item = [u32; N]>

Convert an iterator of field element arrays into an iterator of u32 arrays.

Converts an element [F; N] into the u32 array [[u32; N]; NUM_BYTES/4]. This is intended for use with vectorized hash functions which use vector operations to compute several hashes in parallel.

This function is guaranteed to be equivalent to starting with Iterator<[F; N]> performing a transpose operation to get [Iterator<F>; N], calling into_u32_stream on each element to get [Iterator<u32>; N] and then performing another transpose operation to get Iterator<[u32; N]>.

If NUM_BYTES does not divide 4, multiple [F; N]s may be packed together to make a single [u32; N]. Furthermore, if NUM_BYTES * input.len() does not divide 4, the final [u32; N] will involve padding bytes which are set to 0.

fn into_parallel_u64_streams<const N: usize>( input: impl IntoIterator<Item = [Self; N]>, ) -> impl IntoIterator<Item = [u64; N]>

Convert an iterator of field element arrays into an iterator of u64 arrays.

Converts an element [F; N] into the u64 array [[u64; N]; NUM_BYTES/8]. This is intended for use with vectorized hash functions which use vector operations to compute several hashes in parallel.

This function is guaranteed to be equivalent to starting with Iterator<[F; N]> performing a transpose operation to get [Iterator<F>; N], calling into_u64_stream on each element to get [Iterator<u64>; N] and then performing another transpose operation to get Iterator<[u64; N]>.

If NUM_BYTES does not divide 8, multiple [F; N]s may be packed together to make a single [u64; N]. Furthermore, if NUM_BYTES * input.len() does not divide 8, the final [u64; N] will involve padding bytes which are set to 0.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<F: BinomiallyExtendable<D>, const D: usize> RawDataSerializable for BinomialExtensionField<F, D>

const NUM_BYTES: usize

impl<F: QuinticTrinomialExtendable> RawDataSerializable for QuinticTrinomialExtensionField<F>

const NUM_BYTES: usize