Struct Hash256 

#[repr(transparent)]
pub struct Hash256(pub [u8; 32]);

Tuple Fields

0: [u8; 32]

Implementations

impl<'a> Hash256

pub fn new(bytes: &[u8; 32]) -> Self

pub fn bytes(&'a self) -> Array<'a, u8, 32>

pub fn set_bytes(&mut self, items: &[u8; 32])

impl Hash256

pub fn digest<T: AsRef<[u8]>>(bytes: &T) -> Self

Creates a new hash from a byte representation of some data.

let data = "This is some data that can be hashed !";
let hash = Hash256::digest(&data);

pub fn digest_w_x00<T: AsRef<[u8]>>(bytes: &T) -> Self

Creates a new hash from a byte representation of some data.

A special byte \x00 is fed into the hasher, before the data is added. Can be used for merkle hash trees that conform to RFC6962.

pub fn digest_w_x01<T: AsRef<[u8]>>(bytes: &T) -> Self

Creates a new hash from a byte representation of some data.

A special byte \x01 is fed into the hasher, before the data is added. Can be used for merkle hash trees that conform to RFC6962.

pub fn zero() -> Self

Creates a Hash256, where all bits are set to 0.

This is mostly used for testing, where we want to create hashes without some data.

pub fn empty() -> Self

Creates a new hash without any data.

This returns the initial state of the hasher, without updating it with data. The following variants all create the same output hash:

let hash = Hash256::empty();
let h2 = Hash256::digest(b"");
let mut hasher = Hasher::new();
let h3 = hasher.finalize();

assert_eq!(hash, h2);
assert_eq!(hash, h3);

pub fn sum(h1: &Hash256, h2: &Hash256) -> Hash256

Constructs a new hash from two other hashes.

Note: The sum of two hashes is not commutative, so the order of the hashes matter:

let h1 = Hash256::empty();
let h2 = Hash256::zero();

assert_ne!(Hash256::sum(&h1, &h2), Hash256::sum(&h2, &h1));

Alternatively you can use the + operator directly, since the Hash256 implements Add:

let h1 = Hash256::empty();
let h2 = Hash256::zero();
let sum = Hash256::sum(&h1, &h2);

assert_eq!(h1 + h2, sum);

pub fn to_u64(&self) -> u64

Converts the hash to an u64 value.

The Hash256 can also be used to generate random values (which are equally distributed, due to the cryptographic properties of the underlying hash-function).

pub fn into_vec(self) -> Vec<u8>

Consumes the hash and returns the underlying byte-slice as a vector

pub fn into_slice(self) -> [u8; 32]

Consumes the hash and returns the underlying byte-slice

Trait Implementations

impl Add for Hash256

type Output = Hash256

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AsRef<[u8; 32]> for Hash256

fn as_ref(&self) -> &[u8; 32]

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<[u8]> for Hash256

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Hash256

fn clone(&self) -> Hash256

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Hash256

impl Debug for Hash256

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

Formats the value using the given formatter.

impl Default for Hash256

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Hash256

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Hash256

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

Formats the value using the given formatter.

impl Eq for Hash256

impl<'a> Follow<'a> for Hash256

type Inner = &'a Hash256

unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner

Safety

impl<'a> Follow<'a> for &'a Hash256

type Inner = &'a Hash256

unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner

Safety

impl From<&[u8; 32]> for Hash256

fn from(slice: &[u8; 32]) -> Self

Converts to this type from the input type.

impl From<GenericArray<u8, <CoreWrapper<Sha3_256Core> as OutputSizeUser>::OutputSize>> for Hash256

fn from(hash: Output<Sha3_256>) -> Self

Converts to this type from the input type.

impl From<Hash256> for u64

fn from(hash: Hash256) -> Self

Converts to this type from the input type.

impl From<Hash256> for [u8; 32]

fn from(h: Hash256) -> Self

Converts to this type from the input type.

impl From<Hash256> for Vec<u8>

fn from(h: Hash256) -> Self

Converts to this type from the input type.

impl From<Hash256> for String

fn from(h: Hash256) -> Self

Converts to this type from the input type.

impl From<[u8; 32]> for Hash256

fn from(slice: [u8; 32]) -> Self

Converts to this type from the input type.

impl Hash for Hash256

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

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 Hashed for Hash256

fn hash(&self) -> &Hash256

Returns a reference to the pre-calculated hash of the datatype.

impl Ord for Hash256

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Hash256

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Hash256

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'b> Push for Hash256

type Output = Hash256

unsafe fn push(&self, dst: &mut [u8], _written_len: usize)

Safety

fn size() -> usize

fn alignment() -> PushAlignment

impl Serialize for Hash256

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SimpleToVerifyInSlice for Hash256

impl StructuralPartialEq for Hash256

impl TryFrom<&Vec<u8>> for Hash256

type Error = InvalidSliceLength

The type returned in the event of a conversion error.

fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&[u8]> for Hash256

type Error = InvalidSliceLength

The type returned in the event of a conversion error.

fn try_from(value: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Vec<u8>> for Hash256

type Error = InvalidSliceLength

The type returned in the event of a conversion error.

fn try_from(value: Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Verifiable for Hash256

fn run_verifier( v: &mut Verifier<'_, '_>, pos: usize, ) -> Result<(), InvalidFlatbuffer>

Runs the verifier for this type, assuming its at position pos in the verifier’s buffer. Should not need to be called directly.