Struct fletcher_simd::Fletcher

pub struct Fletcher<T: FletcherChecksum> { /* private fields */ }

A Fletcher checksum object that allows for continuous updates to the checksum.

Examples

use fletcher_simd::Fletcher;

const DATA: &str = "abcdefgh";
let mut fletcher = Fletcher::<u16>::new();
fletcher.update_with_slice(DATA.as_bytes());

assert_eq!(fletcher.value(), 0xF824);

The update_with_iter method is also available for use with the Iterator interface.

use byteorder::{ByteOrder, LittleEndian};
use fletcher_simd::Fletcher128;

const DATA: &str = "abcdefgh";
let mut fletcher = Fletcher128::new();

fletcher.update_with_iter(
    DATA.as_bytes()
        .chunks(8)
        .map(|chunk| LittleEndian::read_u64(chunk)),
);

assert_eq!(fletcher.value(), 0x68676665646362616867666564636261);

Implementations

impl Fletcher<u16>

pub fn new() -> Self

Constructs a new Fletcher<T> with the default values.

pub fn with_initial_values(a: u8, b: u8) -> Self

Constructs a new Fletcher<T> with specific values.

a will represent the lesser significant bits. b will represent the more significant bits.

pub fn update_with_slice(&mut self, data: &[u8])

Updates the checksum with a slice of data of type T::BlockType.

pub fn update_with_iter<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u8>,

Updates the checksum with an iterator over elements of type T::BlockType.

pub fn update_with_iter_scalar<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u8>,

Updates the checksum with an iterator over elements of type T::BlockType using a scalar-only implementation.

pub fn value(&self) -> u16

Returns the checksum value.

impl Fletcher<u32>

pub fn new() -> Self

Constructs a new Fletcher<T> with the default values.

pub fn with_initial_values(a: u16, b: u16) -> Self

Constructs a new Fletcher<T> with specific values.

a will represent the lesser significant bits. b will represent the more significant bits.

pub fn update_with_slice(&mut self, data: &[u16])

Updates the checksum with a slice of data of type T::BlockType.

pub fn update_with_iter<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u16>,

Updates the checksum with an iterator over elements of type T::BlockType.

pub fn update_with_iter_scalar<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u16>,

Updates the checksum with an iterator over elements of type T::BlockType using a scalar-only implementation.

pub fn value(&self) -> u32

Returns the checksum value.

impl Fletcher<u64>

pub fn new() -> Self

Constructs a new Fletcher<T> with the default values.

pub fn with_initial_values(a: u32, b: u32) -> Self

Constructs a new Fletcher<T> with specific values.

a will represent the lesser significant bits. b will represent the more significant bits.

pub fn update_with_slice(&mut self, data: &[u32])

Updates the checksum with a slice of data of type T::BlockType.

pub fn update_with_iter<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u32>,

Updates the checksum with an iterator over elements of type T::BlockType.

pub fn update_with_iter_scalar<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u32>,

Updates the checksum with an iterator over elements of type T::BlockType using a scalar-only implementation.

pub fn value(&self) -> u64

Returns the checksum value.

impl Fletcher<u128>

pub fn new() -> Self

Constructs a new Fletcher<T> with the default values.

pub fn with_initial_values(a: u64, b: u64) -> Self

Constructs a new Fletcher<T> with specific values.

a will represent the lesser significant bits. b will represent the more significant bits.

pub fn update_with_slice(&mut self, data: &[u64])

Updates the checksum with a slice of data of type T::BlockType.

pub fn update_with_iter<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u64>,

Updates the checksum with an iterator over elements of type T::BlockType.

pub fn update_with_iter_scalar<Iter>(&mut self, elems: Iter)where
    Iter: Iterator<Item = u64>,

Updates the checksum with an iterator over elements of type T::BlockType using a scalar-only implementation.

pub fn value(&self) -> u128

Returns the checksum value.

Trait Implementations

impl<T: Clone + FletcherChecksum> Clone for Fletcher<T>where
    T::BlockType: Clone,
    T::BlockType: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + FletcherChecksum> Debug for Fletcher<T>where
    T::BlockType: Debug,
    T::BlockType: Debug,

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

Formats the value using the given formatter.

impl<T: Default + FletcherChecksum> Default for Fletcher<T>where
    T::BlockType: Default,
    T::BlockType: Default,

fn default() -> Fletcher<T>

Returns the “default value” for a type.

impl From<Fletcher<u128>> for u128

fn from(f: Fletcher<u128>) -> Self

Converts to this type from the input type.

impl From<Fletcher<u16>> for u16

fn from(f: Fletcher<u16>) -> Self

Converts to this type from the input type.

impl From<Fletcher<u32>> for u32

fn from(f: Fletcher<u32>) -> Self

Converts to this type from the input type.

impl From<Fletcher<u64>> for u64

fn from(f: Fletcher<u64>) -> Self

Converts to this type from the input type.

impl<T: PartialEq + FletcherChecksum> PartialEq<Fletcher<T>> for Fletcher<T>where
    T::BlockType: PartialEq,
    T::BlockType: PartialEq,

fn eq(&self, other: &Fletcher<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Copy + FletcherChecksum> Copy for Fletcher<T>where
    T::BlockType: Copy,
    T::BlockType: Copy,

impl<T: FletcherChecksum> StructuralPartialEq for Fletcher<T>