Struct adler::Adler32

pub struct Adler32 { /* private fields */ }

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 function, they are not necessarily a good one).

Examples

Basic, piecewise checksum calculation:

use adler::Adler32;

let mut adler = Adler32::new();

adler.write_slice(&[0, 1, 2]);
adler.write_slice(&[3, 4, 5]);

assert_eq!(adler.checksum(), 0x00290010);

Using Hash to process structures:

use std::hash::Hash;
use adler::Adler32;

#[derive(Hash)]
struct Data {
    byte: u8,
    word: u16,
    big: u64,
}

let mut adler = Adler32::new();

let data = Data { byte: 0x1F, word: 0xABCD, big: !0 };
data.hash(&mut adler);

// hash value depends on architecture endianness
if cfg!(target_endian = "little") {
    assert_eq!(adler.checksum(), 0x33410990);
}
if cfg!(target_endian = "big") {
    assert_eq!(adler.checksum(), 0x331F0990);
}

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.

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.

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 Copy for Adler32