Struct ModSum 

pub struct ModSum<S: Modnum> { /* private fields */ }

A Modsum checksum algorithm.

Implements LinearCheck so that finding checksummed locations in a file is efficiently possible.

Implementations

impl<S: Modnum> ModSum<S>

pub fn with_options() -> ModSumBuilder<S>

Creates a ModSumBuilder, for more information see its documentation.

Trait Implementations

impl<S: Debug + Modnum> Debug for ModSum<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Modnum> Digest for ModSum<S>

type Sum = S

A type that holds the checksum.

fn init(&self) -> Self::Sum

Gets an initial sum before the words are processed through the sum.

fn dig_word(&self, sum: Self::Sum, word: SignedInt<u64>) -> Self::Sum

Processes a single word from the text.

fn finalize(&self, sum: Self::Sum) -> Self::Sum

After all words are read, this function is called to do some finalization.

fn to_bytes(&self, s: Self::Sum) -> Vec<u8>

Takes the sum and turns it into an array of bytes (may depend on configured endian)

fn checksum_from_bytes(&self, bytes: &[u8]) -> Option<Self::Sum>

Takes a slice of bytes and turns it into a sum, if it fits (may depend on configured endian).

fn wordspec(&self) -> WordSpec

Iterate over the words of a file so that digest calculates the checksum

fn digest(&self, buf: &[u8]) -> Result<Self::Sum, Error>

Takes a reader and calculates the checksums of all words therein.

impl<Sum: Modnum> Display for ModSum<Sum>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Sum: Modnum> FromStr for ModSum<Sum>

fn from_str(s: &str) -> Result<ModSum<Sum>, CheckBuilderErr>

Construct a new modular sum from a string specification.

Example:

width=16 modulus=0xffff init=0

type Err = CheckBuilderErr

The associated error which can be returned from parsing.

impl<S: Modnum> LinearCheck for ModSum<S>

type Shift = ()

The Shift type (see trait documentation for more).

fn init_shift(&self) -> Self::Shift

The initial shift corresponding to the identity shift of 0 (see trait documentation for more).

fn inc_shift(&self, _: Self::Shift) -> Self::Shift

Increments the shift by one (see trait documentation for more).

fn shift(&self, sum: Self::Sum, _: &Self::Shift) -> Self::Sum

Applies a shift to a sum (see trait documentation for more).

fn shift_n(&self, _: usize) -> Self::Shift

Acts as if applying dig_word(s, 0) n times to to s (see trait documentation for more).

fn add(&self, sum_a: Self::Sum, sum_b: &Self::Sum) -> Self::Sum

Adds two sums together (see trait documentation for more).

fn negate(&self, sum: Self::Sum) -> Self::Sum

Gets inverse in the abelian group of add (see trait documentation for more).

fn find_segments<'a>( &self, bytes: &'a [Vec<u8>], sum: &'a [impl Fn(&'a [u8], usize) -> Option<Self::Sum> + Send + Sync], rel: Relativity, ) -> Vec<RangePair>

Given some bytes and a target sum, determines all segments in the bytes that have that particular checksum.

fn find_segments_range<'a>( &self, bytes: &'a [Vec<u8>], sum: &'a [impl Fn(&'a [u8], usize) -> Option<Self::Sum> + Send + Sync], start_range: SignedInclRange, end_range: SignedInclRange, ) -> Vec<RangePair>

impl<S: PartialEq + Modnum> PartialEq for ModSum<S>

fn eq(&self, other: &ModSum<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Eq + Modnum> Eq for ModSum<S>

impl<S: Modnum> StructuralPartialEq for ModSum<S>