Trait fvm_ipld_hamt::Hash

pub trait Hash {
    // Required method
    fn hash<H>(&self, state: &mut H)
       where H: Hasher;

    // Provided method
    fn hash_slice<H>(data: &[Self], state: &mut H)
       where H: Hasher,
             Self: Sized { ... }
}

Custom trait to avoid issues like https://github.com/rust-lang/rust/issues/27108.

Required Methods

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

where H: Hasher,

Provided Methods

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

where H: Hasher, Self: Sized,

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Hash for bool

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

where H: Hasher,

impl Hash for char

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

where H: Hasher,

impl Hash for i8

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i16

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i32

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i64

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

where H: Hasher,

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

where H: Hasher,

impl Hash for i128

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

where H: Hasher,

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

where H: Hasher,

impl Hash for isize

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

where H: Hasher,

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

where H: Hasher,

impl Hash for str

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

where H: Hasher,

impl Hash for u8

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u16

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u32

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u64

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

where H: Hasher,

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

where H: Hasher,

impl Hash for u128

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

where H: Hasher,

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

where H: Hasher,

impl Hash for ()

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

where H: Hasher,

impl Hash for usize

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

where H: Hasher,

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

where H: Hasher,

impl Hash for String

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

where H: Hasher,

impl<A> Hash for (A,)

where A: Hash + ?Sized,

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

where S: Hasher,

impl<A, B> Hash for (A, B)

where A: Hash, B: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C> Hash for (A, B, C)

where A: Hash, B: Hash, C: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D> Hash for (A, B, C, D)

where A: Hash, B: Hash, C: Hash, D: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E> Hash for (A, B, C, D, E)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F, G, H> Hash for (A, B, C, D, E, F, G, H)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F, G, H, I> Hash for (A, B, C, D, E, F, G, H, I)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F, G, H, I, J> Hash for (A, B, C, D, E, F, G, H, I, J)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F, G, H, I, J, K> Hash for (A, B, C, D, E, F, G, H, I, J, K)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash + ?Sized,

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

where S: Hasher,

impl<A, B, C, D, E, F, G, H, I, J, K, L> Hash for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Hash, B: Hash, C: Hash, D: Hash, E: Hash, F: Hash, G: Hash, H: Hash, I: Hash, J: Hash, K: Hash, L: Hash + ?Sized,

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

where S: Hasher,

impl<T> Hash for *const T

where T: ?Sized,

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

where H: Hasher,

impl<T> Hash for *mut T

where T: ?Sized,

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

where H: Hasher,

impl<T> Hash for &T

where T: Hash + ?Sized,

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

where H: Hasher,

impl<T> Hash for &mut T

where T: Hash + ?Sized,

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

where H: Hasher,

impl<T> Hash for [T]

where T: Hash,

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

where H: Hasher,

impl<T> Hash for Vec<T>

where T: Hash,

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

where H: Hasher,

Implementors

impl Hash for BytesKey