Struct rs_sha512_224::Sha512_224Hasher

pub struct Sha512_224Hasher(_);

Sha512_224Hasher is a type that provides the SHA-512/224 hashing algorithm in RustyShield.

A “Hasher” in the context of cryptographic hashing refers to the object that manages the process of converting input data into a fixed-size sequence of bytes. The Hasher is responsible for maintaining the internal state of the hashing process and providing methods to add more data and retrieve the resulting hash.

The Sha512_224Hasher struct adheres to Rust’s Hasher trait, enabling you to use it interchangeably with other hashers in Rust. It can be used anywhere a type implementing Hasher is required.

Examples

The following examples demonstrate using Sha512_224Hasher with both Hash and Hasher, and how the results can differ:

 let data = b"hello";

 // Using Hash
 let mut sha512_224hasher = Sha512_224Hasher::default();
 data.hash(&mut sha512_224hasher);
 let result_via_hash = sha512_224hasher.finish();

 // Using Hasher
 let mut sha512_224hasher = Sha512_224Hasher::default();
 sha512_224hasher.write(data);
 let result_via_hasher = sha512_224hasher.finish();

 // Simulating the Hash inners
 let mut sha512_224hasher = Sha512_224Hasher::default();
 sha512_224hasher.write_usize(data.len());
 sha512_224hasher.write(data);
 let simulated_hash_result = sha512_224hasher.finish();

 assert_ne!(result_via_hash, result_via_hasher);
 assert_eq!(result_via_hash, simulated_hash_result);

Trait Implementations

impl Clone for Sha512_224Hasher

fn clone(&self) -> Sha512_224Hasher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Sha512_224Hasher

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

Formats the value using the given formatter.

impl Default for Sha512_224Hasher

fn default() -> Sha512_224Hasher

Returns the “default value” for a type.

impl From<Sha512_224Hasher> for Sha512_224State

fn from(value: Sha512_224Hasher) -> Self

Converts to this type from the input type.

impl From<Sha512_224State> for Sha512_224Hasher

fn from(value: Sha512_224State) -> Self

Converts to this type from the input type.

impl Hash for Sha512_224Hasher

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 Hasher for Sha512_224Hasher

fn finish(&self) -> u64

Returns the hash value for the values written so far.

fn write(&mut self, bytes: &[u8])

Writes some data into this Hasher.

fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

fn write_length_prefix(&mut self, len: usize)

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

Writes a length prefix into this hasher, as part of being prefix-free.

fn write_str(&mut self, s: &str)

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

Writes a single str into this hasher.

impl HasherContext<BYTES_LEN> for Sha512_224Hasher

type Output = ByteArrayWrapper<BYTES_LEN>

fn finish(&mut self) -> Self::Output

impl PartialEq<Sha512_224Hasher> for Sha512_224Hasher

fn eq(&self, other: &Sha512_224Hasher) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Sha512_224Hasher

impl StructuralEq for Sha512_224Hasher

impl StructuralPartialEq for Sha512_224Hasher