[−][src]Trait merkletree::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 merkletree_derive;
extern crate merkletree;

use merkletree::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 merkletree;

use merkletree::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.

Loading content...

Provided methods

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

Feeds a slice of this type into the given Hasher.

Loading content...

Implementations on Foreign Types

`impl<H: Hasher> Hashable<H> for u8`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for u16`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for u32`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for u64`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for usize`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for i8`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for i16`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for i32`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for i64`[src]

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for isize`[src]

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

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

`fn hash(&self, state: &mut H)`[src]

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

`impl<H: Hasher> Hashable<H> for Vec<u8>`[src]

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher> Hashable<H> for bool`[src]

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher> Hashable<H> for char`[src]

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher> Hashable<H> for str`[src]

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher> Hashable<H> for String`[src]

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher> Hashable<H> for ()`[src]

`fn hash(&self, _: &mut H)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut Z)`[src]

`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> for (A, B, C, D, E, F, G, H) where H: Hashable<Z> + ?Sized,` [src]

`fn hash(&self, state: &mut Z)`[src]

`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> for (A, B, C, D, E, F, G, H, I) where I: Hashable<Z> + ?Sized,` [src]

`fn hash(&self, state: &mut Z)`[src]

`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> for (A, B, C, D, E, F, G, H, I, J) where J: Hashable<Z> + ?Sized,` [src]

`fn hash(&self, state: &mut Z)`[src]

`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> for (A, B, C, D, E, F, G, H, I, J, K) where K: Hashable<Z> + ?Sized,` [src]

`fn hash(&self, state: &mut Z)`[src]

`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> for (A, B, C, D, E, F, G, H, I, J, K, L) where L: Hashable<Z> + ?Sized,` [src]

`fn hash(&self, state: &mut Z)`[src]

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

`fn hash(&self, state: &mut H)`[src]

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

`fn hash(&self, state: &mut H)`[src]

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

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher, T: ?Sized> Hashable<H> for *const T`[src]

`fn hash(&self, state: &mut H)`[src]

`impl<H: Hasher, T: ?Sized> Hashable<H> for *mut T`[src]

`fn hash(&self, state: &mut H)`[src]

Loading content...

Implementors

Loading content...