Crate checkpipe 

checkpipe

A rust library for computing things about bytes as they flow through pipelines.

The motivating use case is performing a checksum on all bytes passing through a reader or writer.

Example

use checkpipe::{Check, Checker};
use std::io::{Read, Write};
use std::fs::{File, remove_file};

const DATA: [u8; 13] = *b"Hello, world!";
const PATH: &'static str = "foo.txt";

pub fn write_checksummed() -> std::io::Result<()> {
    let outfile = File::create(PATH)?;
    let mut outpipe = Checker::new_default_hasher(outfile);

    outpipe.write_all(DATA.as_slice())?;
    let checksum = outpipe.output();
    outpipe.write(&mut checksum.to_le_bytes()[..])?;
    Ok(())
}

pub fn read_checksummed() -> std::io::Result<()> {
    let infile = File::open(PATH)?;
    let mut inpipe = Checker::new_default_hasher(infile);

    let mut buf = [0u8; DATA.len()];
    inpipe.read(&mut buf)?;
    let checksum = inpipe.output();

    let mut checksum_buf = [0u8; 8];
    inpipe.read(&mut checksum_buf)?;
    assert_eq!(checksum, u64::from_le_bytes(checksum_buf));
    Ok(())
}

pub fn main() -> std::io::Result<()> {
    write_checksummed()?;
    read_checksummed()?;
    remove_file(PATH)
}

Implementing your own checks

Implement the Check trait on a struct, which provides methods for taking a chunk of bytes, and eventually returning the result of its computation. Then wrap that struct, and some struct through which bytes pass, in a Checker.

Check is already implemented for all types implementing Hasher, and there are some convenience methods in place if you want to use rust’s default hasher. See also the Counter, a Checker which counts the bytes which pass through it. If the wrapped type in Checker is Read or Write, so too will be the Checker.

Structs

Checker

Struct wrapping over a Check type and some other type which handles bytes (usually a reader/writer).

InnerCounter

Type implementing Check used by Counter for counting bytes as they pass through.

Traits

Check

Trait representing a computation performed on some bytes.

Type Aliases

Counter

Type which counts the number of bytes passed through. Useful for wrapping readers/writers before (or after) they are wrapped in compressors.