Struct adler::Adler32

pub struct Adler32 { /* fields omitted */ }

Adler-32 checksum calculator.

An instance of this type is equivalent to an Adler-32 checksum: It can be created in the default state via new (or the provided Default impl), or from a precalculated checksum via from_checksum, and the currently stored checksum can be fetched via checksum.

This type also implements Hasher, which makes it easy to calculate Adler-32 checksums of any type that implements or derives Hash. This also allows using Adler-32 in a HashMap, although that is not recommended (while every checksum is a hash, they are not necessarily good at being one).

Implementations

impl Adler32

pub fn new() -> Self

Creates a new Adler-32 instance with default state.

pub fn from_checksum(sum: u32) -> Self

Creates an Adler32 instance from a precomputed Adler-32 checksum.

This allows resuming checksum calculation without having to keep the Adler32 instance around.

Example

let parts = [
    "rust",
    "acean",
];
let whole = adler::adler32_slice(b"rustacean");

let mut sum = Adler32::new();
sum.write_slice(parts[0].as_bytes());
let partial = sum.checksum();

// ...later

let mut sum = Adler32::from_checksum(partial);
sum.write_slice(parts[1].as_bytes());
assert_eq!(sum.checksum(), whole);

pub fn checksum(&self) -> u32

Returns the calculated checksum at this point in time.

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

Adds bytes to the checksum calculation.

If efficiency matters, this should be called with Byte slices that contain at least a few thousand Bytes.

Trait Implementations

impl Clone for Adler32

fn clone(&self) -> Adler32

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Adler32

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

Formats the value using the given formatter.

impl Default for Adler32

fn default() -> Self

Returns the “default value” for a type.

impl Hasher for Adler32

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.

pub fn write_u8(&mut self, i: u8)

Writes a single u8 into this hasher.

pub fn write_u16(&mut self, i: u16)

Writes a single u16 into this hasher.

pub fn write_u32(&mut self, i: u32)

Writes a single u32 into this hasher.

pub fn write_u64(&mut self, i: u64)

Writes a single u64 into this hasher.

pub fn write_u128(&mut self, i: u128)

Writes a single u128 into this hasher.

pub fn write_usize(&mut self, i: usize)

Writes a single usize into this hasher.

pub fn write_i8(&mut self, i: i8)

Writes a single i8 into this hasher.

pub fn write_i16(&mut self, i: i16)

Writes a single i16 into this hasher.

pub fn write_i32(&mut self, i: i32)

Writes a single i32 into this hasher.

pub fn write_i64(&mut self, i: i64)

Writes a single i64 into this hasher.

pub fn write_i128(&mut self, i: i128)

Writes a single i128 into this hasher.

pub fn write_isize(&mut self, i: isize)

Writes a single isize into this hasher.

impl Copy for Adler32