Rust implementation of CRC.

Add crc to Cargo.toml

[dependencies]
crc = "3.4.0"

Using a well-known algorithm:

const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
assert_eq!(X25.checksum(b"123456789"), 0x906e);

Using a custom algorithm:

const CUSTOM_ALG: crc::Algorithm<u16> = crc::Algorithm {
    width: 16,
    poly: 0x8005,
    init: 0xffff,
    refin: false,
    refout: false,
    xorout: 0x0000,
    check: 0xaee7,
    residue: 0x0000
};
let crc = crc::Crc::<u16>::new(&CUSTOM_ALG);
let mut digest = crc.digest();
digest.update(b"123456789");
assert_eq!(digest.finalize(), 0xaee7);

This crate's MSRV is 1.83.

At a minimum, the MSRV will be <= the oldest stable release in the last 12 months. MSRV may be bumped in minor version releases.

This crate has several pluggable implementations:

1. NoTable doesn't use a lookup table, and thus minimizes binary size and memory usage.
2. Table<1> uses a lookup table with 256 entries (e.g. for u32 thats 256 * 4 bytes).
3. Table<16> uses a lookup table with 16 * 256 entries (e.g. for u32 thats 16 * 256 * 4 bytes).

Table<1> is the default implementation, but this can be overridden by specifying I in Crc<W, I>. E.g.: Crc<u32, NoTable>, Crc<u64, Table<16>>, ...

NOTE: Lookup tables will increase binary size if they're generated at compile-time. Wrapping Crc initialization in a std::cell::OnceCell may be preferable if binary size is a concern.

cargo bench with AMD Ryzen 7 3800X (comparison).

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.