Struct LtHash32 

pub struct LtHash32<H> { /* private fields */ }

A LtHash checksum with 32 bits per chunk and 1024 chunks.

Implementations

impl<H> LtHash32<H>

where H: ExtendableOutput + Default,

pub fn new() -> Self

Trait Implementations

impl<'a, H> BitOr for &'a LtHash32<H>

where H: ExtendableOutput + Default,

type Output = LtHash32<H>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<H> BitOr for LtHash32<H>

where H: ExtendableOutput + Default,

type Output = LtHash32<H>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<H: Clone> Clone for LtHash32<H>

fn clone(&self) -> LtHash32<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H> Debug for LtHash32<H>

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

Formats the value using the given formatter.

impl<H> Default for LtHash32<H>

where H: ExtendableOutput + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<A, H> Extend<A> for LtHash32<H>

where A: AsRef<[u8]>, H: ExtendableOutput + Default,

fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A, H> FromIterator<A> for LtHash32<H>

where A: AsRef<[u8]>, H: ExtendableOutput + Default,

fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self

Creates a value from an iterator.

impl<H> LtHash for LtHash32<H>

where H: ExtendableOutput + Default,

fn insert(&mut self, element: impl AsRef<[u8]>)

Inserts an element to LtHash, actually it generates the hash (of size 4096 bytes) of the object and sums it to the checksum.

fn remove(&mut self, element: impl AsRef<[u8]>)

Removes an element to LtHash, actually it generates the hash (of size 4096 bytes) of the object and removes it from the checksum.

fn to_hex_string(&self) -> String

Provides the hex value as String of the checksum.

fn union(&self, rhs: &Self) -> Self

Takes the union of self and rhs

Equivalent to cloning self, then adding all the objects in rhs.

Equivalent to self | other

Examples

let mut left = LtHash32::<Shake256>::new();
left.insert("hello");

let mut right = LtHash32::<Shake256>::new();
right.insert("world");

assert_eq!(left.union(&right), LtHash32::<Shake256>::from_iter(&["hello", "world"]));

fn difference(&self, rhs: &Self) -> Self

Takes the difference of self and rhs.

Equivalent to cloning self, then removing all the objects in rhs.

Equivalent to self - other

Examples

let mut left = LtHash32::<Shake256>::new();
left.extend(&["hello", "world"]);

let mut right = LtHash32::<Shake256>::new();
right.insert("hello");

assert_eq!(left.difference(&right), LtHash32::from_iter(&["world"]));

fn reset(&mut self)

Clears the internal checksum

fn into_bytes(self) -> Vec<u8>

Converts self into the inner list of bytes

impl<H> PartialEq for LtHash32<H>

fn eq(&self, other: &Self) -> 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<'a, H> Sub for &'a LtHash32<H>

where H: ExtendableOutput + Default,

type Output = LtHash32<H>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<H> Sub for LtHash32<H>

where H: ExtendableOutput + Default,

type Output = LtHash32<H>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<H> TryFrom<&[u8]> for LtHash32<H>

type Error = String

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<H: Copy> Copy for LtHash32<H>