Struct SpongeCursor 

pub struct SpongeCursor<const RATE: usize> {
    pub(crate) pos: u8,
}

Cursor for implementing sponge-based absorption and squeezing.

This type wraps u8 and enforces that its value is always smaller than RATE.

RATE MUST be smaller than 256, trying to initialize cursor with an invalid rate will result in a compilation error.

Fields

pos: u8

Implementations

impl<const RATE: usize> SpongeCursor<RATE>

pub fn new(pos: u8) -> Option<Self>

Create new cursor with the provided position.

Returns None if pos is bigger or equal to RATE.

pub fn raw_pos(&self) -> u8

Get current cursor position as u8.

pub fn pos(&self) -> usize

Get current cursor position as usize.

pub(crate) fn set_pos(&mut self, new_pos: usize)

Set new cursor position.

Panics

If new_pos is greater or equal to RATE.

pub fn absorb_u64_le<const N: usize>( &mut self, state: &mut [u64; N], sponge: fn(&mut [u64; N]), data: &[u8], )

Absorb bytes from data into state using little-endian byte order.

Size of state in bytes MUST be greater or equal to RATE. Using an invalid N will result in a compilation error.

pub fn squeeze_read_u64_le<const N: usize>( &mut self, state: &mut [u64; N], sponge: fn(&mut [u64; N]), buf: &mut [u8], )

Squeeze data from state by reading it into buf using little-endian byte order.

Size of state in bytes MUST be greater or equal to RATE. Using an invalid N will result in a compilation error.

pub fn squeeze_xor_u64_le<const N: usize>( &mut self, state: &mut [u64; N], sponge: fn(&mut [u64; N]), buf: &mut [u8], )

Squeeze data from state by XOR-ing it with data in buf using little-endian byte order.

Size of state in bytes MUST be greater or equal to RATE. Using an invalid N will result in a compilation error.

pub(crate) fn squeeze_inner_u64_le<const N: usize>( &mut self, state: &mut [u64; N], sponge: fn(&mut [u64; N]), buf: &mut [u8], process_partial: fn(&[u64; N], usize, &mut [u8]), process_full: fn(&[u64; N], &mut [u8; RATE]), )

Squeeze data by calling custom functions using little-endian byte order.

Trait Implementations

impl<const RATE: usize> Clone for SpongeCursor<RATE>

fn clone(&self) -> SpongeCursor<RATE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const RATE: usize> Debug for SpongeCursor<RATE>

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

Formats the value using the given formatter.

impl<const RATE: usize> Default for SpongeCursor<RATE>

fn default() -> Self

Returns the “default value” for a type.

impl<const RATE: usize> Hash for SpongeCursor<RATE>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const RATE: usize> PartialEq for SpongeCursor<RATE>

fn eq(&self, other: &SpongeCursor<RATE>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const RATE: usize> Eq for SpongeCursor<RATE>

impl<const RATE: usize> StructuralPartialEq for SpongeCursor<RATE>