Struct Fletcher 

pub struct Fletcher<Sum: Modnum> { /* private fields */ }

Implementations

impl<Sum: Modnum> Fletcher<Sum>

pub fn with_options() -> FletcherBuilder<Sum>

Creates a FletcherBuilder, see FletcherBuilder documentation for more details.

Trait Implementations

impl<Sum: Clone + Modnum> Clone for Fletcher<Sum>

where Sum::Double: Clone,

fn clone(&self) -> Fletcher<Sum>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Sum: Debug + Modnum> Debug for Fletcher<Sum>

where Sum::Double: Debug,

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

Formats the value using the given formatter.

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

type Sum = <S as Modnum>::Double

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 Fletcher<Sum>

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

Formats the value using the given formatter.

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

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

Construct a new fletcher sum algorithm from a string. Note that all parameters except width are in hexadecimal.

Example:

Fletcher::<u32>::from_str("width=32 init=1 modulus=0xfff1 name=\"adler-32\"").is_ok();

type Err = CheckBuilderErr

The associated error which can be returned from parsing.

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

type Shift = S

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, shift: Self::Shift) -> Self::Shift

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

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

Applies a shift to a sum (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 shift_n(&self, n: usize) -> Self::Shift

Acts as if applying dig_word(s, 0) n times to to s (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<Sum: PartialEq + Modnum> PartialEq for Fletcher<Sum>

where Sum::Double: PartialEq,

fn eq(&self, other: &Fletcher<Sum>) -> 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<Sum: Eq + Modnum> Eq for Fletcher<Sum>

where Sum::Double: Eq,

impl<Sum: Modnum> StructuralPartialEq for Fletcher<Sum>