Struct Hash 

pub struct Hash(/* private fields */);

The blake3 digest type, re-exported so callers of blake3_file can name the return type without taking their own blake3 dependency. An output of the default size, 32 bytes, which provides constant-time equality checking.

Hash implements From and Into for [u8; 32], and it provides from_bytes and as_bytes for explicit conversions between itself and [u8; 32]. However, byte arrays and slices don’t provide constant-time equality checking, which is often a security requirement in software that handles private data. Hash doesn’t implement Deref or AsRef, to avoid situations where a type conversion happens implicitly and the constant-time property is accidentally lost.

Hash provides the to_hex and from_hex methods for converting to and from hexadecimal. It also implements Display and FromStr.

Implementations

impl Hash

pub const fn as_bytes(&self) -> &[u8; 32]

The raw bytes of the Hash. Note that byte arrays don’t provide constant-time equality checking, so if you need to compare hashes, prefer the Hash type.

pub const fn from_bytes(bytes: [u8; 32]) -> Hash

Create a Hash from its raw bytes representation.

pub const fn as_slice(&self) -> &[u8]

The raw bytes of the Hash, as a slice. Useful for serialization. Note that byte arrays don’t provide constant-time equality checking, so if you need to compare hashes, prefer the Hash type.

pub fn from_slice(bytes: &[u8]) -> Result<Hash, TryFromSliceError>

Create a Hash from its raw bytes representation as a slice.

Returns an error if the slice is not exactly 32 bytes long.

pub fn to_hex(&self) -> ArrayString<blake3::::{impl#0}::to_hex::{constant#0}>

Encode a Hash in lowercase hexadecimal.

The returned ArrayString is a fixed size and doesn’t allocate memory on the heap. Note that ArrayString doesn’t provide constant-time equality checking, so if you need to compare hashes, prefer the Hash type.

pub fn from_hex(hex: impl AsRef<[u8]>) -> Result<Hash, HexError>

Decode a Hash from hexadecimal. Both uppercase and lowercase ASCII bytes are supported.

Any byte outside the ranges '0'...'9', 'a'...'f', and 'A'...'F' results in an error. An input length other than 64 also results in an error.

Note that Hash also implements FromStr, so Hash::from_hex("...") is equivalent to "...".parse().

Trait Implementations

impl Clone for Hash

fn clone(&self) -> Hash

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Hash

impl Debug for Hash

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

Formats the value using the given formatter.

impl Display for Hash

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

Formats the value using the given formatter.

impl Eq for Hash

impl From<[u8; 32]> for Hash

fn from(bytes: [u8; 32]) -> Hash

Converts to this type from the input type.

impl FromStr for Hash

type Err = HexError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Hash, <Hash as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Hash

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Hash

This implementation is constant-time.

fn eq(&self, other: &Hash) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<[u8; 32]> for Hash

This implementation is constant-time.

fn eq(&self, other: &[u8; 32]) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialEq<[u8]> for Hash

This implementation is constant-time if the target is 32 bytes long.

fn eq(&self, other: &[u8]) -> bool

Equality operator ==.

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

Inequality operator !=.