Struct diem_sdk::crypto::hash::HashValue

pub struct HashValue { /* private fields */ }

Expand description

Output value of our hash function. Intentionally opaque for safety and modularity.

Implementations§

§

impl HashValue

pub const LENGTH: usize = 32usize

The length of the hash in bytes.

pub const LENGTH_IN_BITS: usize = 256usize

The length of the hash in bits.

pub fn new(hash: [u8; 32]) -> HashValue

Create a new HashValue from a byte array.

pub fn from_slice<T>(bytes: T) -> Result<HashValue, HashValueParseError>where T: AsRef<[u8]>,

Create from a slice (e.g. retrieved from storage).

pub fn to_vec(&self) -> Vec<u8, Global> ⓘ

Dumps into a vector.

pub const fn zero() -> HashValue

Creates a zero-initialized instance.

pub fn random() -> HashValue

Create a cryptographically random instance.

pub fn random_with_rng<R>(rng: &mut R) -> HashValuewhere R: Rng,

Creates a random instance with given rng. Useful in unit tests.

pub fn sha3_256_of(buffer: &[u8]) -> HashValue

Convenience function that computes a HashValue internally equal to the sha3_256 of a byte buffer. It will handle hasher creation, data feeding and finalization.

Note this will not result in the <T as CryptoHash>::hash() for any reasonable struct T, as this computes a sha3 without any ornaments.

pub fn bit(&self, index: usize) -> bool

Returns the index-th bit in the bytes.

pub fn nibble(&self, index: usize) -> u8

Returns the index-th nibble in the bytes.

pub fn iter_bits(&self) -> HashValueBitIterator<'_> ⓘ

Returns a HashValueBitIterator over all the bits that represent this HashValue.

pub fn from_bit_iter( iter: impl ExactSizeIterator<Item = bool> ) -> Result<HashValue, HashValueParseError>

Constructs a HashValue from an iterator of bits.

pub fn common_prefix_bits_len(&self, other: HashValue) -> usize

Returns the length of common prefix of self and other in bits.

pub fn to_hex(&self) -> String

Full hex representation of a given hash value.

pub fn from_hex<T>(hex: T) -> Result<HashValue, HashValueParseError>where T: AsRef<[u8]>,

Parse a given hex string to a hash value.

pub fn from_u64(v: u64) -> HashValue

Create a hash value whose contents are just the given integer. Useful for generating basic mock hash values.

Ex: HashValue::from_u64(0x1234) => HashValue([0, .., 0, 0x12, 0x34])

Methods from Deref<Target = [u8; 32]>§

1.57.0 · source

pub fn as_slice(&self) -> &[T] ⓘ

Returns a slice containing the entire array. Equivalent to &s[..].

source

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

#![feature(array_methods)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

source

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

source

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

Trait Implementations§

§

impl Arbitrary for HashValue

§

type Parameters = <[u8; 32] as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

§

type Strategy = Map<<[u8; 32] as Arbitrary>::Strategy, fn(_: [u8; 32]) -> HashValue>

The type of Strategy used to generate values of type Self.

§

fn arbitrary_with( _top: <HashValue as Arbitrary>::Parameters ) -> <HashValue as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args. Read more

§