pub struct Adler32 { /* private fields */ }
Expand description

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

Creates a new Adler-32 instance with default state.

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);

Returns the calculated checksum at this point in time.

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

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Returns the hash value for the values written so far. Read more

Writes some data into this Hasher. Read more

Writes a single u8 into this hasher.

Writes a single u16 into this hasher.

Writes a single u32 into this hasher.

Writes a single u64 into this hasher.

Writes a single u128 into this hasher.

Writes a single usize into this hasher.

Writes a single i8 into this hasher.

Writes a single i16 into this hasher.

Writes a single i32 into this hasher.

Writes a single i64 into this hasher.

Writes a single i128 into this hasher.

Writes a single isize into this hasher.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.