Adler32

https://docs.rs/adler32/1.2.0/
Admin
Adler32 is a minimal Rust implementation of the Adler32 hash algorithm, providing both a simple...
Tokens:6,499
Snippets:73
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### RollingAdler32

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

A rolling version of the Adler32 hash, which can 'forget' past bytes. Calling remove() will update the hash to the value it would have if that past byte had never been fed to the algorithm. This allows you to get the hash of a rolling window very efficiently.

```APIDOC
## struct RollingAdler32

### Description
A rolling version of the Adler32 hash, which can 'forget' past bytes. Calling remove() will update the hash to the value it would have if that past byte had never been fed to the algorithm. This allows you to get the hash of a rolling window very efficiently.

### Methods

*   **`new()`**: Creates an empty Adler32 context (with hash 1).
*   **`from_value(adler32: u32)`**: Creates an Adler32 context with the given initial value.
*   **`from_buffer(buffer: &[u8])`**: Convenience function initializing a context from the hash of a buffer.
*   **`hash()`**: Returns the current hash.
*   **`remove(size: usize, byte: u8)`**: Removes the given `byte` that was fed to the algorithm `size` bytes ago.
*   **`update(byte: u8)`**: Feeds a new `byte` to the algorithm to update the hash.
*   **`update_buffer(buffer: &[u8])`**: Feeds a vector of bytes to the algorithm to update the hash.
```

--------------------------------

### Get Current RollingAdler32 Hash

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Returns the current Adler32 hash value of the data processed so far.

```rust
pub fn hash(&self) -> u32
```

--------------------------------

### Get Type ID

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Gets the `TypeId` of the `RollingAdler32` instance. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### RollingAdler32::new

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Initializes a new RollingAdler32 checksum.

```APIDOC
## RollingAdler32::new

### Description
Initializes a new `RollingAdler32` checksum with default values.

### Method
`RollingAdler32::new()`

### Returns
A new `RollingAdler32` instance.
```

--------------------------------

### RollingAdler32 Initialization

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Provides methods to create a new RollingAdler32 context, either with a default hash value of 1 or from an existing Adler32 hash. It also offers a convenience function to initialize from a buffer.

```rust
impl Default for RollingAdler32 {
    fn default() -> RollingAdler32 {
        RollingAdler32::new()
    }
}
```

```rust
pub fn new() -> RollingAdler32 {
    Self::from_value(1)
}
```

```rust
pub fn from_value(adler32: u32) -> RollingAdler32 {
    let a = adler32 & 0xFFFF;
    let b = adler32 >> 16;
    RollingAdler32 { a, b }
}
```

```rust
pub fn from_buffer(buffer: &[u8]) -> RollingAdler32 {
    let mut hash = RollingAdler32::new();
    hash.update_buffer(buffer);
    hash
}
```

--------------------------------

### Clone to Uninit (Nightly)

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Nightly-only experimental API to perform copy-assignment from `self` to an uninitialized memory location.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Create RollingAdler32 from Buffer

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Convenience function to initialize a RollingAdler32 context from the hash of an existing byte buffer.

```rust
pub fn from_buffer(buffer: &[u8]) -> RollingAdler32
```

--------------------------------

### RollingAdler32 Methods

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

This section details the methods available for the RollingAdler32 struct, including creation, updating, and retrieving the hash value.

```APIDOC
## RollingAdler32

### Description
A rolling version of the Adler32 hash, which can ‘forget’ past bytes. Calling `remove()` will update the hash to the value it would have if that past byte had never been fed to the algorithm. This allows you to get the hash of a rolling window very efficiently.

### Methods

#### `fn new() -> RollingAdler32`
Creates an empty Adler32 context (with hash 1).

#### `fn from_value(adler32: u32) -> RollingAdler32`
Creates an Adler32 context with the given initial value.

#### `fn from_buffer(buffer: &[u8]) -> RollingAdler32`
Convenience function initializing a context from the hash of a buffer.

#### `fn hash(&self) -> u32`
Returns the current hash.

#### `fn remove(&mut self, size: usize, byte: u8)`
Removes the given `byte` that was fed to the algorithm `size` bytes ago.

#### `fn update(&mut self, byte: u8)`
Feeds a new `byte` to the algorithm to update the hash.

#### `fn update_buffer(&mut self, buffer: &[u8])`
Feeds a vector of bytes to the algorithm to update the hash.
```

--------------------------------

### Compare Optimized and Slow Adler32 Implementations

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Compares the results of the optimized `adler32` function against the `adler32_slow` function using randomly generated data of various sizes. Panics if any discrepancy is found.

```rust
let mut rng = rand::thread_rng();
        let mut data = vec![0u8; 5589];
        for size in [
            0, 1, 3, 4, 5, 31, 32, 33, 67, 5550, 5552, 5553, 5568, 5584, 5589,
        ] {
            rng.fill(&mut data[..size]);
            let r1 = io::Cursor::new(&data[..size]);
            let r2 = r1.clone();
            if adler32_slow(r1).unwrap() != adler32(r2).unwrap() {
                panic!("Comparison failed, size={}", size);
            }
        }
```

--------------------------------

### Initialize RollingAdler32 from a Value

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Creates a `RollingAdler32` instance initialized with a specific hash value. Useful for resuming calculations or testing.

```rust
assert_eq!(RollingAdler32::from_value(0x01020304).hash(), 0x01020304);
```

--------------------------------

### Create New RollingAdler32 Context

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Initializes an empty Adler32 context with a hash value of 1.

```rust
pub fn new() -> RollingAdler32
```

--------------------------------

### Create RollingAdler32 from Initial Value

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Creates an Adler32 context with a specified initial hash value.

```rust
pub fn from_value(adler32: u32) -> RollingAdler32
```

--------------------------------

### Clone RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Returns a duplicate of the RollingAdler32 context, allowing for independent hash calculations from the same state.

```rust
fn clone(&self) -> RollingAdler32
```

--------------------------------

### Clone From RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Performs copy-assignment from a source RollingAdler32 context to the current one.

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

--------------------------------

### Test RollingAdler32 with Byte Removal

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Tests the RollingAdler32 functionality by simulating a large window and removing bytes from the beginning. Asserts the hash value at specific intervals and at the end.

```rust
    #[test]
    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
    fn long_window_remove() {
        let mut hash = RollingAdler32::new();
        let w = 65536;
        assert!(w as u32 > BASE);

        let mut bytes = vec![0; w * 3];
        for (i, b) in bytes.iter_mut().enumerate() {
            *b = i as u8;
        }

        for (i, b) in bytes.iter().enumerate() {
            if i >= w {
                hash.remove(w, bytes[i - w]);
            }
            hash.update(*b);
            if i > 0 && i % w == 0 {
                assert_eq!(hash.hash(), 0x433a8772);
            }
        }
        assert_eq!(hash.hash(), 0xbbba8772);
    }
}
```

--------------------------------

### From RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Converts a value into `RollingAdler32`. This is part of the `From` trait implementation.

```rust
fn from(t: T) -> T
```

--------------------------------

### Default RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Returns the default value for RollingAdler32, which is an empty context with hash 1.

```rust
fn default() -> RollingAdler32
```

--------------------------------

### adler32

Source: https://docs.rs/adler32/1.2.0/adler32/fn.adler32.html

Consumes a Read object and returns the Adler32 hash.

```APIDOC
## adler32

### Description
Consume a Read object and returns the Adler32 hash.

### Signature
```rust
pub fn adler32<R: Read>(reader: R) -> Result<u32>
```

### Parameters
#### Path Parameters
- **reader** (R: Read) - The input reader to compute the Adler32 hash from.

### Returns
- **Result<u32>** - A Result containing the u32 Adler32 hash on success, or an error if reading fails.
```

--------------------------------

### adler32() function

Source: https://docs.rs/adler32/1.2.0/adler32

Consumes a Read object and computes the Adler32 hash.

```APIDOC
## Function: adler32

### Description
Consume a Read object and returns the Adler32 hash.

### Signature
```rust
fn adler32<R: Read>(reader: R) -> u32
```

### Parameters
* `reader`: A type implementing the `Read` trait.
```

--------------------------------

### Try From RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Performs a fallible conversion from another type `U` into `RollingAdler32`. This is part of the `TryFrom` trait implementation.

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Update RollingAdler32 with a Buffer

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Efficiently updates the Adler32 hash with a buffer of bytes. Handles short lengths and unrolls loops for performance.

```rust
if len == 1 {
            self.update(buffer[0]);
            return;
        }

        // in case short lengths are provided, keep it somewhat fast
        if len < 16 {
            for byte in buffer.iter().take(len) {
                self.a += u32::from(*byte);
                self.b += self.a;
            }
            if self.a >= BASE {
                self.a -= BASE;
            }
            self.b %= BASE;
            return;
        }

        let mut pos = 0;

        // do length NMAX blocks -- requires just one modulo operation;
        while pos + NMAX <= len {
            let end = pos + NMAX;
            while pos < end {
                // 16 sums unrolled
                do16(&mut self.a, &mut self.b, &buffer[pos..pos + 16]);
                pos += 16;
            }
            self.a %= BASE;
            self.b %= BASE;
        }

        // do remaining bytes (less than NMAX, still just one modulo)
        if pos < len {
            // avoid modulos if none remaining
            while len - pos >= 16 {
                do16(&mut self.a, &mut self.b, &buffer[pos..pos + 16]);
                pos += 16;
            }
            while len - pos > 0 {
                self.a += u32::from(buffer[pos]);
                self.b += self.a;
                pos += 1;
            }
            self.a %= BASE;
            self.b %= BASE;
        }
```

--------------------------------

### Try Into RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Performs a fallible conversion from `RollingAdler32` into another type `U`. This is part of the `TryInto` trait implementation.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### adler32() function

Source: https://docs.rs/adler32/1.2.0/index.html

Computes the Adler32 hash by consuming a Read object.

```APIDOC
## adler32()

### Description
Consume a Read object and returns the Adler32 hash.

### Function Signature
`fn adler32<R: Read>(reader: R) -> u32`

### Parameters
* `reader` (R: Read) - The object to read from.
```

--------------------------------

### adler32() function

Source: https://docs.rs/adler32/1.2.0/adler32/index.html

Computes the Adler32 hash by consuming a Read object.

```APIDOC
## adler32()

### Description
Consume a Read object and returns the Adler32 hash.

### Function Signature
adler32(reader: impl std::io::Read) -> u32
```

--------------------------------

### adler32

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Computes the Adler-32 checksum for data from a `Read` object.

```APIDOC
## adler32

### Description
Consumes a `Read` object and returns its Adler-32 checksum. This function is available when the `std` feature is enabled.

### Method
`adler32<R: std::io::Read>(reader: R) -> std::io::Result<u32>`

### Parameters
#### Path Parameters
- **reader** (R: `std::io::Read`) - The object to read data from.

### Returns
A `std::io::Result` containing the `u32` Adler-32 checksum on success, or an `std::io::Error` on failure.
```

--------------------------------

### RollingAdler32::hash

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Returns the current Adler-32 checksum value.

```APIDOC
## RollingAdler32::hash

### Description
Returns the current Adler-32 checksum value.

### Method
`hash(&self) -> u32`

### Returns
The current Adler-32 checksum as a `u32`.
```

--------------------------------

### Into RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Calls `U::from(self)` to convert `RollingAdler32` into another type `U`. This is part of the `Into` trait implementation.

```rust
fn into(self) -> U
```

--------------------------------

### Update RollingAdler32 Hash with a Buffer

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Feeds a slice of bytes into the algorithm to update the current Adler32 hash.

```rust
pub fn update_buffer(&mut self, buffer: &[u8])
```

--------------------------------

### Slow Adler32 Calculation for Comparison

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

A straightforward, byte-by-byte implementation of Adler32 used for verifying the optimized version. It iterates through each byte and applies the modulo operations.

```rust
fn adler32_slow<R: io::Read>(reader: R) -> io::Result<u32> {
    let mut a: u32 = 1;
    let mut b: u32 = 0;

    for byte in reader.bytes() {
        let byte = byte? as u32;
        a = (a + byte) % BASE;
        b = (b + a) % BASE;
    }

    Ok((b << 16) | a)
```

--------------------------------

### RollingAdler32 struct

Source: https://docs.rs/adler32/1.2.0/index.html

A rolling version of the Adler32 hash that allows for byte-by-byte computation and forgetting past bytes.

```APIDOC
## RollingAdler32

### Description
A rolling version of the Adler32 hash, which can ‘forget’ past bytes.

### Methods
* `new()`: Creates a new RollingAdler32 instance.
* `update(byte: u8)`: Updates the hash with a single byte.
* `checksum()`: Returns the current Adler32 checksum.
* `reset()`: Resets the hash to its initial state.
* `forget_bytes(count: usize)`: Forgets a specified number of past bytes.
```

--------------------------------

### Update RollingAdler32 Hash with a Byte

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Feeds a single new byte into the algorithm to update the current Adler32 hash.

```rust
pub fn update(&mut self, byte: u8)
```

--------------------------------

### Adler32 Test Vectors

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Verifies the Adler32 implementation against known test vectors for various input byte slices. Includes tests for empty strings, single characters, and longer sequences.

```rust
fn do_test(v: u32, bytes: &[u8]) {
            let mut hash = RollingAdler32::new();
            hash.update_buffer(&bytes);
            assert_eq!(hash.hash(), v);

            let r = io::Cursor::new(bytes);
            assert_eq!(adler32(r).unwrap(), v);
        }
        do_test(0x00000001, b"");
        do_test(0x00620062, b"a");
        do_test(0x024d0127, b"abc");
        do_test(0x29750586, b"message digest");
        do_test(0x90860b20, b"abcdefghijklmnopqrstuvwxyz");
        do_test(
            0x8adb150c,
            b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
                              abcdefghijklmnopqrstuvwxyz\
                              0123456789",
        );
        do_test(
            0x97b61069,
            b"1234567890123456789012345678901234567890\
                              1234567890123456789012345678901234567890",
        );
        do_test(0xD6251498, &[255; 64000]);
```

--------------------------------

### Borrow RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Immutably borrows the `RollingAdler32` instance. This is part of the `Borrow` trait implementation.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Adler32 Hashing Functions

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

These inline functions efficiently compute Adler32 by processing bytes in chunks of 1, 2, 4, 8, and 16. They are optimized for speed by using `#[inline(always)]`.

```rust
#[inline(always)]
fn do1(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
    *adler += u32::from(buf[0]);
    *sum2 += *adler;
}
```

```rust
#[inline(always)]
fn do2(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
    do1(adler, sum2, &buf[0..1]);
    do1(adler, sum2, &buf[1..2]);
}
```

```rust
#[inline(always)]
fn do4(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
    do2(adler, sum2, &buf[0..2]);
    do2(adler, sum2, &buf[2..4]);
}
```

```rust
#[inline(always)]
fn do8(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
    do4(adler, sum2, &buf[0..4]);
    do4(adler, sum2, &buf[4..8]);
}
```

```rust
#[inline(always)]
fn do16(adler: &mut u32, sum2: &mut u32, buf: &[u8]) {
    do8(adler, sum2, &buf[0..8]);
    do8(adler, sum2, &buf[8..16]);
}
```

--------------------------------

### RollingAdler32 Update Byte

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Feeds a single byte into the Adler32 algorithm, updating the rolling hash. This is the fundamental operation for building the hash incrementally.

```rust
pub fn update(&mut self, byte: u8) {
    let byte = u32::from(byte);
    self.a = (self.a + byte) % BASE;
    self.b = (self.b + self.a) % BASE;
}
```

--------------------------------

### RollingAdler32 Update Buffer

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Feeds a slice of bytes into the Adler32 algorithm to update the rolling hash. This method iterates through the buffer and applies the `update` logic for each byte.

```rust
pub fn update_buffer(&mut self, buffer: &[u8]) {
    let len = buffer.len();

```

--------------------------------

### RollingAdler32 struct

Source: https://docs.rs/adler32/1.2.0/adler32/index.html

A rolling version of the Adler32 hash that allows for forgetting past bytes.

```APIDOC
## RollingAdler32

### Description
A rolling version of the Adler32 hash, which can ‘forget’ past bytes.

### Methods
- `new()`: Creates a new `RollingAdler32` instance.
- `update(byte: u8)`: Updates the hash with a single byte.
- `checksum()`: Returns the current Adler32 checksum.
- `reset()`: Resets the hash to its initial state.
- `roll(old_byte: u8, new_byte: u8)`: Rolls the hash by removing `old_byte` and adding `new_byte`.
```

--------------------------------

### Rolling Adler32 Update and Remove Operations

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Demonstrates the rolling hash functionality by updating and removing bytes from a `RollingAdler32` instance. It calculates the hash of concatenated byte slices by first initializing with the second slice and then iteratively removing from the first and adding to the end.

```rust
fn do_test(a: &[u8], b: &[u8]) {
            let mut total = Vec::with_capacity(a.len() + b.len());
            total.extend(a);
            total.extend(b);
            let mut h = RollingAdler32::from_buffer(&total[..(b.len())]);
            for i in 0..(a.len()) {
                h.remove(b.len(), a[i]);
                h.update(total[b.len() + i]);
            }
        }
```

--------------------------------

### RollingAdler32::update

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Updates the rolling checksum with a single byte.

```APIDOC
## RollingAdler32::update

### Description
Updates the Adler-32 checksum with a single byte.

### Method
`update(&mut self, byte: u8)`

### Parameters
#### Path Parameters
- **byte** (u8) - The byte to incorporate into the checksum.
```

--------------------------------

### RollingAdler32::update_buffer

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Updates the rolling checksum with a buffer of bytes.

```APIDOC
## RollingAdler32::update_buffer

### Description
Updates the Adler-32 checksum with a slice of bytes.

### Method
`update_buffer(&mut self, buffer: &[u8])`

### Parameters
#### Path Parameters
- **buffer** (&[u8]) - The slice of bytes to incorporate into the checksum.
```

--------------------------------

### RollingAdler32 struct

Source: https://docs.rs/adler32/1.2.0/adler32

A rolling version of the Adler32 hash, which can ‘forget’ past bytes.

```APIDOC
## Struct: RollingAdler32

### Description
A rolling version of the Adler32 hash, which can ‘forget’ past bytes.

### Methods
* `new()`: Creates a new `RollingAdler32` instance.
* `update(byte: u8)`: Updates the hash with a single byte.
* `checksum()`: Returns the current Adler32 checksum.
```

--------------------------------

### Calculate Adler32 Hash from a Reader

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Consumes a `std::io::Read` object and returns its Adler32 hash. Reads data in chunks up to `NMAX` size.

```rust
pub fn adler32<R: std::io::Read>(mut reader: R) -> std::io::Result<u32> {
    let mut hash = RollingAdler32::new();
    let mut buffer = [0u8; NMAX];
    let mut read = reader.read(&mut buffer)?;
    while read > 0 {
        hash.update_buffer(&buffer[..read]);
        read = reader.read(&mut buffer)?;
    }
    Ok(hash.hash())
```

--------------------------------

### Borrow Mut RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Mutably borrows the `RollingAdler32` instance. This is part of the `BorrowMut` trait implementation.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### To Owned RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Creates owned data from borrowed data, usually by cloning. This is part of the `ToOwned` trait implementation.

```rust
fn to_owned(&self) -> T
```

--------------------------------

### RollingAdler32 Hash Retrieval

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Retrieves the current Adler32 hash value from the RollingAdler32 context. The hash is represented as a single u32 value.

```rust
pub fn hash(&self) -> u32 {
    (self.b << 16) | self.a
}
```

--------------------------------

### RollingAdler32 Struct Definition

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Defines the RollingAdler32 struct, which is a rolling version of the Adler32 hash that can 'forget' past bytes.

```rust
pub struct RollingAdler32 { /* private fields */ }
```

--------------------------------

### Remove Byte from RollingAdler32 Hash

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Updates the hash by removing a byte that was fed to the algorithm `size` bytes ago. This is key for rolling window calculations.

```rust
pub fn remove(&mut self, size: usize, byte: u8)
```

--------------------------------

### Clone Into RollingAdler32

Source: https://docs.rs/adler32/1.2.0/adler32/struct.RollingAdler32.html

Uses borrowed data to replace owned data, usually by cloning. This is part of the `ToOwned` trait implementation.

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### RollingAdler32 Remove Byte

Source: https://docs.rs/adler32/1.2.0/src/adler32/lib.rs.html

Updates the Adler32 hash by removing a byte that was previously added. This is crucial for maintaining the hash of a sliding window. The `size` parameter indicates how many bytes ago the `byte` was added.

```rust
pub fn remove(&mut self, size: usize, byte: u8) {
    let byte = u32::from(byte);
    self.a = (self.a + BASE - byte) % BASE;
    self.b = ((self.b + BASE - 1)
        .wrapping_add(BASE.wrapping_sub(size as u32).wrapping_mul(byte)))
        % BASE;
}
```
Tokens:
Raw