Trait merkle_light::hash::Hashable

pub trait Hashable<H: Hasher> {
    fn hash(&self, state: &mut H);

    fn hash_slice(data: &[Self], state: &mut H)
    where
        Self: Sized,
    { ... }
}

A hashable type.

Types implementing Hashable are able to be [hash]ed with an instance of [Hasher].

Implementing Hashable

You can derive Hashable with #[derive(Hashable)] if all fields implement Hashable. The resulting hash will be the combination of the values from calling [hash] on each field.

#[macro_use]
extern crate merkle_light_derive;
extern crate merkle_light;

use merkle_light::hash::Hashable;

fn main() {
    #[derive(Hashable)]
    struct Foo {
        name: String,
        country: String,
    }
}

If you need more control over how a value is hashed, you can of course implement the Hashable trait yourself:

extern crate merkle_light;

use merkle_light::hash::Hashable;
use std::hash::Hasher;
use std::collections::hash_map::DefaultHasher;

fn main() {
   struct Person {
       id: u32,
       name: String,
       phone: u64,
   }

   impl<H: Hasher> Hashable<H> for Person {
       fn hash(&self, state: &mut H) {
           self.id.hash(state);
           self.name.hash(state);
           self.phone.hash(state);
       }
   }

   let foo = Person{
       id: 1,
       name: String::from("blah"),
       phone: 2,
   };

   let mut hr = DefaultHasher::new();
   foo.hash(&mut hr);
   assert_eq!(hr.finish(), 7101638158313343130)
}

Hashable and Eq

When implementing both Hashable and [Eq], it is important that the following property holds:

k1 == k2 -> hash(k1) == hash(k2)

In other words, if two keys are equal, their hashes must also be equal.

Required Methods

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

Feeds this value into the given Hasher.

Provided Methods

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

Feeds a slice of this type into the given Hasher.

Implementations on Foreign Types

impl<H: Hasher> Hashable<H> for u8

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

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

impl<H: Hasher> Hashable<H> for u16

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

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

impl<H: Hasher> Hashable<H> for u32

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

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

impl<H: Hasher> Hashable<H> for u64

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

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

impl<H: Hasher> Hashable<H> for usize

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

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

impl<H: Hasher> Hashable<H> for i8

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

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

impl<H: Hasher> Hashable<H> for i16

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

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

impl<H: Hasher> Hashable<H> for i32

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

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

impl<H: Hasher> Hashable<H> for i64

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

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

impl<H: Hasher> Hashable<H> for isize

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

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

impl<H: Hasher> Hashable<H> for [u8; 1]

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

fn hash_slice(data: &[[u8; 1]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 2]

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

fn hash_slice(data: &[[u8; 2]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 3]

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

fn hash_slice(data: &[[u8; 3]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 4]

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

fn hash_slice(data: &[[u8; 4]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 5]

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

fn hash_slice(data: &[[u8; 5]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 6]

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

fn hash_slice(data: &[[u8; 6]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 7]

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

fn hash_slice(data: &[[u8; 7]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 8]

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

fn hash_slice(data: &[[u8; 8]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 9]

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

fn hash_slice(data: &[[u8; 9]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 10]

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

fn hash_slice(data: &[[u8; 10]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 11]

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

fn hash_slice(data: &[[u8; 11]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 12]

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

fn hash_slice(data: &[[u8; 12]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 13]

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

fn hash_slice(data: &[[u8; 13]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 14]

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

fn hash_slice(data: &[[u8; 14]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 15]

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

fn hash_slice(data: &[[u8; 15]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 16]

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

fn hash_slice(data: &[[u8; 16]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 17]

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

fn hash_slice(data: &[[u8; 17]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 18]

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

fn hash_slice(data: &[[u8; 18]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 19]

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

fn hash_slice(data: &[[u8; 19]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 20]

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

fn hash_slice(data: &[[u8; 20]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 21]

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

fn hash_slice(data: &[[u8; 21]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 22]

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

fn hash_slice(data: &[[u8; 22]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 23]

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

fn hash_slice(data: &[[u8; 23]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 24]

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

fn hash_slice(data: &[[u8; 24]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 25]

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

fn hash_slice(data: &[[u8; 25]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 26]

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

fn hash_slice(data: &[[u8; 26]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 27]

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

fn hash_slice(data: &[[u8; 27]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 28]

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

fn hash_slice(data: &[[u8; 28]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 29]

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

fn hash_slice(data: &[[u8; 29]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 30]

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

fn hash_slice(data: &[[u8; 30]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 31]

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

fn hash_slice(data: &[[u8; 31]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 32]

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

fn hash_slice(data: &[[u8; 32]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 33]

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

fn hash_slice(data: &[[u8; 33]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 34]

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

fn hash_slice(data: &[[u8; 34]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 35]

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

fn hash_slice(data: &[[u8; 35]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 36]

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

fn hash_slice(data: &[[u8; 36]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 37]

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

fn hash_slice(data: &[[u8; 37]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 38]

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

fn hash_slice(data: &[[u8; 38]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 39]

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

fn hash_slice(data: &[[u8; 39]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 40]

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

fn hash_slice(data: &[[u8; 40]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 41]

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

fn hash_slice(data: &[[u8; 41]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 42]

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

fn hash_slice(data: &[[u8; 42]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 43]

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

fn hash_slice(data: &[[u8; 43]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 44]

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

fn hash_slice(data: &[[u8; 44]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 45]

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

fn hash_slice(data: &[[u8; 45]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 46]

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

fn hash_slice(data: &[[u8; 46]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 47]

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

fn hash_slice(data: &[[u8; 47]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 48]

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

fn hash_slice(data: &[[u8; 48]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 49]

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

fn hash_slice(data: &[[u8; 49]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 50]

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

fn hash_slice(data: &[[u8; 50]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 51]

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

fn hash_slice(data: &[[u8; 51]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 52]

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

fn hash_slice(data: &[[u8; 52]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 53]

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

fn hash_slice(data: &[[u8; 53]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 54]

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

fn hash_slice(data: &[[u8; 54]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 55]

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

fn hash_slice(data: &[[u8; 55]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 56]

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

fn hash_slice(data: &[[u8; 56]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 57]

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

fn hash_slice(data: &[[u8; 57]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 58]

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

fn hash_slice(data: &[[u8; 58]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 59]

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

fn hash_slice(data: &[[u8; 59]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 60]

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

fn hash_slice(data: &[[u8; 60]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 61]

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

fn hash_slice(data: &[[u8; 61]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 62]

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

fn hash_slice(data: &[[u8; 62]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 63]

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

fn hash_slice(data: &[[u8; 63]], state: &mut H)

impl<H: Hasher> Hashable<H> for [u8; 64]

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

fn hash_slice(data: &[[u8; 64]], state: &mut H)

impl<H: Hasher> Hashable<H> for Vec<u8>

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher> Hashable<H> for bool

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher> Hashable<H> for char

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher> Hashable<H> for str

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher> Hashable<H> for String

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher> Hashable<H> for ()

fn hash(&self, _: &mut H)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z> + ?Sized> Hashable<Z> for (A,) where
    A: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z> + ?Sized> Hashable<Z> for (A, B) where
    B: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C) where
    C: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D) where
    D: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E) where
    E: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F) where
    F: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z>, G: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F, G) where
    G: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z>, G: Hashable<Z>, H: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F, G, H) where
    H: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z>, G: Hashable<Z>, H: Hashable<Z>, I: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F, G, H, I) where
    I: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z>, G: Hashable<Z>, H: Hashable<Z>, I: Hashable<Z>, J: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F, G, H, I, J) where
    J: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z>, G: Hashable<Z>, H: Hashable<Z>, I: Hashable<Z>, J: Hashable<Z>, K: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F, G, H, I, J, K) where
    K: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<Z: Hasher, A: Hashable<Z>, B: Hashable<Z>, C: Hashable<Z>, D: Hashable<Z>, E: Hashable<Z>, F: Hashable<Z>, G: Hashable<Z>, H: Hashable<Z>, I: Hashable<Z>, J: Hashable<Z>, K: Hashable<Z>, L: Hashable<Z> + ?Sized> Hashable<Z> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    L: , 

fn hash(&self, state: &mut Z)

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher, T: Hashable<H>> Hashable<H> for [T]

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<'a, H: Hasher, T: ?Sized + Hashable<H>> Hashable<H> for &'a T

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<'a, H: Hasher, T: ?Sized + Hashable<H>> Hashable<H> for &'a mut T

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher, T: ?Sized> Hashable<H> for *const T

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

impl<H: Hasher, T: ?Sized> Hashable<H> for *mut T

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

fn hash_slice(data: &[Self], state: &mut H) where
    Self: Sized, 

Implementors