Struct digest_hash::Endian

pub struct Endian<D, Bo> { /* fields omitted */ }

An adapter to provide digest functions with endian-awareness.

Methods

impl<D, Bo> Endian<D, Bo> where     Bo: ByteOrder,

pub fn byte_order_str() -> &'static str

Returns a string describing the byte order used by this Endian type instance.

This is mainly used for debugging purposes. The user should not rely on any particular output.

impl<D, Bo> Endian<D, Bo> where     D: Input,     D: Default,     Bo: ByteOrder,

pub fn new() -> Self

Constructs an instance of an endian-aware hasher.

Examples

let hasher = digest_hash::BigEndian::<Sha256>::new();

impl<D, Bo> Endian<D, Bo>

pub fn into_inner(self) -> D

Consumes self and returns the underlying digest implementation.

Trait Implementations

impl<D: Clone, Bo: Clone> Clone for Endian<D, Bo>

fn clone(&self) -> Endian<D, Bo>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D, Bo> Debug for Endian<D, Bo> where     D: Debug,     Bo: ByteOrder,

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

Formats the value using the given formatter.

impl<D, Bo> EndianInput for Endian<D, Bo> where     D: Input,     Bo: ByteOrder,

type ByteOrder = Bo

The byte order this implementation provides.

fn input_u8(&mut self, n: u8)

Feeds an unsigned 8-bit value into the digest function.

fn input_i8(&mut self, n: i8)

Feeds a signed 8-bit value into the digest function.

fn chain_u8(self, n: u8) -> Self where     Self: Sized,

Digest an unsigned 8-bit value in a chained manner.

fn chain_i8(self, n: i8) -> Self where     Self: Sized,

Digest a signed 8-bit value in a chained manner.

fn input_u16(&mut self, n: u16)

fn chain_u16(self, n: u16) -> Self where     Self: Sized,

fn input_i16(&mut self, n: i16)

fn chain_i16(self, n: i16) -> Self where     Self: Sized,

fn input_u32(&mut self, n: u32)

fn chain_u32(self, n: u32) -> Self where     Self: Sized,

fn input_i32(&mut self, n: i32)

fn chain_i32(self, n: i32) -> Self where     Self: Sized,

fn input_u64(&mut self, n: u64)

fn chain_u64(self, n: u64) -> Self where     Self: Sized,

fn input_i64(&mut self, n: i64)

fn chain_i64(self, n: i64) -> Self where     Self: Sized,

fn input_f32(&mut self, n: f32)

fn chain_f32(self, n: f32) -> Self where     Self: Sized,

fn input_f64(&mut self, n: f64)

fn chain_f64(self, n: f64) -> Self where     Self: Sized,

impl<D, Bo> Input for Endian<D, Bo> where     D: Input,

fn input<B: AsRef<[u8]>>(&mut self, data: B)

Digest input data.

fn chain<B>(self, data: B) -> Self where     B: AsRef<[u8]>,

Digest input data in a chained manner.

impl<D, Bo> BlockInput for Endian<D, Bo> where     D: BlockInput,

type BlockSize = D::BlockSize

impl<D, Bo> FixedOutput for Endian<D, Bo> where     D: FixedOutput,

type OutputSize = D::OutputSize

fn fixed_result(self) -> GenericArray<u8, Self::OutputSize>

Retrieve result and consume hasher instance.

impl<D, Bo> Reset for Endian<D, Bo> where     D: Reset,

fn reset(&mut self)

Reset hasher instance to its initial state and return current state.

impl<D, Bo> Default for Endian<D, Bo> where     D: Input,     D: Default,     Bo: ByteOrder,

fn default() -> Self

Returns the "default value" for a type.

impl<D, Bo> From<D> for Endian<D, Bo> where     D: Input,     Bo: ByteOrder,

fn from(digest: D) -> Self

Performs the conversion.