Struct block_buffer::BlockBuffer

pub struct BlockBuffer<BlockSize, Kind>where
    BlockSize: ArrayLength<u8> + IsLess<U256>,
    Le<BlockSize, U256>: NonZero,
    Kind: BufferKind,{ /* private fields */ }

Buffer for block processing of data.

Implementations

impl<BlockSize, Kind> BlockBuffer<BlockSize, Kind>where
    BlockSize: ArrayLength<u8> + IsLess<U256>,
    Le<BlockSize, U256>: NonZero,
    Kind: BufferKind,

pub fn new(buf: &[u8]) -> Self

Create new buffer from slice.

Panics

If slice length is not valid for used buffer kind.

pub fn try_new(buf: &[u8]) -> Result<Self, Error>

Create new buffer from slice.

Returns an error if slice length is not valid for used buffer kind.

pub fn digest_blocks(
    &mut self,
    input: &[u8],
    compress: impl FnMut(&[Block<BlockSize>])
)

Digest data in input in blocks of size BlockSize using the compress function, which accepts slice of blocks.

pub fn reset(&mut self)

Reset buffer by setting cursor position to zero.

pub fn pad_with_zeros(&mut self) -> &mut Block<BlockSize>

Pad remaining data with zeros and return resulting block.

pub fn get_pos(&self) -> usize

Return current cursor position.

pub fn get_data(&self) -> &[u8]

Return slice of data stored inside the buffer.

pub fn set(&mut self, buf: Block<BlockSize>, pos: usize)

Set buffer content and cursor position.

Panics

If pos is bigger or equal to block size.

pub fn size(&self) -> usize

Return size of the internall buffer in bytes.

pub fn remaining(&self) -> usize

Return number of remaining bytes in the internall buffer.

impl<BlockSize> BlockBuffer<BlockSize, Eager>where
    BlockSize: ArrayLength<u8> + IsLess<U256>,
    Le<BlockSize, U256>: NonZero,

pub fn set_data(
    &mut self,
    data: &mut [u8],
    process_blocks: impl FnMut(&mut [Block<BlockSize>])
)

Set data to generated blocks.

pub fn digest_pad(
    &mut self,
    delim: u8,
    suffix: &[u8],
    compress: impl FnMut(&Block<BlockSize>)
)

Compress remaining data after padding it with delim, zeros and the suffix bytes. If there is not enough unused space, compress will be called twice.

Panics

If suffix length is bigger than block size.

pub fn len64_padding_be(
    &mut self,
    data_len: u64,
    compress: impl FnMut(&Block<BlockSize>)
)

Pad message with 0x80, zeros and 64-bit message length using big-endian byte order.

pub fn len64_padding_le(
    &mut self,
    data_len: u64,
    compress: impl FnMut(&Block<BlockSize>)
)

Pad message with 0x80, zeros and 64-bit message length using little-endian byte order.

pub fn len128_padding_be(
    &mut self,
    data_len: u128,
    compress: impl FnMut(&Block<BlockSize>)
)

Pad message with 0x80, zeros and 128-bit message length using big-endian byte order.

Trait Implementations

impl<BlockSize, Kind> Clone for BlockBuffer<BlockSize, Kind>where
    BlockSize: ArrayLength<u8> + IsLess<U256>,
    Le<BlockSize, U256>: NonZero,
    Kind: BufferKind,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<BlockSize, Kind> Debug for BlockBuffer<BlockSize, Kind>where
    BlockSize: ArrayLength<u8> + IsLess<U256> + Debug,
    Le<BlockSize, U256>: NonZero,
    Kind: BufferKind + Debug,

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

Formats the value using the given formatter.

impl<BlockSize, Kind> Default for BlockBuffer<BlockSize, Kind>where
    BlockSize: ArrayLength<u8> + IsLess<U256>,
    Le<BlockSize, U256>: NonZero,
    Kind: BufferKind,

fn default() -> Self

Returns the “default value” for a type.