Trait tc_transact::hash::Hash

pub trait Hash<D>: Sized
where
    D: Digest,
{
    // Required method
    fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>;
}

Trait to compute a SHA-2 hash using the digest type D

Required Methods

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

Compute the SHA-2 hash of this value

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, D> Hash<D> for &'a Value

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D> Hash<D> for &'a str

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D> Hash<D> for &'a String

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D> Hash<D> for &'a Id

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D> Hash<D> for &'a PathBuf

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D> Hash<D> for &'a Link

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, K, V> Hash<D> for &'a BTreeMap<K, V>

where D: Digest, &'a K: Hash<D>, &'a V: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0> Hash<D> for &'a (T0,)

where D: Digest, &'a T0: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1> Hash<D> for &'a (T0, T1)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2> Hash<D> for &'a (T0, T1, T2)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3> Hash<D> for &'a (T0, T1, T2, T3)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4> Hash<D> for &'a (T0, T1, T2, T3, T4)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5> Hash<D> for &'a (T0, T1, T2, T3, T4, T5)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>, &'a T10: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>, &'a T10: Hash<D>, &'a T11: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>, &'a T10: Hash<D>, &'a T11: Hash<D>, &'a T12: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>, &'a T10: Hash<D>, &'a T11: Hash<D>, &'a T12: Hash<D>, &'a T13: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>, &'a T10: Hash<D>, &'a T11: Hash<D>, &'a T12: Hash<D>, &'a T13: Hash<D>, &'a T14: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Hash<D> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where D: Digest, &'a T0: Hash<D>, &'a T1: Hash<D>, &'a T2: Hash<D>, &'a T3: Hash<D>, &'a T4: Hash<D>, &'a T5: Hash<D>, &'a T6: Hash<D>, &'a T7: Hash<D>, &'a T8: Hash<D>, &'a T9: Hash<D>, &'a T10: Hash<D>, &'a T11: Hash<D>, &'a T12: Hash<D>, &'a T13: Hash<D>, &'a T14: Hash<D>, &'a T15: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a BinaryHeap<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a BTreeSet<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a LinkedList<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a VecDeque<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a Vec<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a Map<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, D, T> Hash<D> for &'a Tuple<T>

where D: Digest, &'a T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<'a, const N: usize, D, T> Hash<D> for &'a SmallVec<[T; N]>

where D: Digest, [T; N]: Array, <&'a SmallVec<[T; N]> as IntoIterator>::Item: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Number

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Complex

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Float

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Int

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for UInt

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Value

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for bool

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for f32

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for f64

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for i8

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for i16

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for i32

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for i64

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for i128

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for isize

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for u8

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for u16

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for u32

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for u64

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for u128

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for ()

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for usize

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for String

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Id

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Boolean

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for PathBuf

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Link

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D> Hash<D> for Version

where D: Digest,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, K, V> Hash<D> for BTreeMap<K, V>

where D: Digest, K: Hash<D>, V: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0> Hash<D> for (T0,)

where D: Digest, T0: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1> Hash<D> for (T0, T1)

where D: Digest, T0: Hash<D>, T1: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2> Hash<D> for (T0, T1, T2)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3> Hash<D> for (T0, T1, T2, T3)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4> Hash<D> for (T0, T1, T2, T3, T4)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5> Hash<D> for (T0, T1, T2, T3, T4, T5)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6> Hash<D> for (T0, T1, T2, T3, T4, T5, T6)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>, T10: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>, T10: Hash<D>, T11: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>, T10: Hash<D>, T11: Hash<D>, T12: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>, T10: Hash<D>, T11: Hash<D>, T12: Hash<D>, T13: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>, T10: Hash<D>, T11: Hash<D>, T12: Hash<D>, T13: Hash<D>, T14: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Hash<D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where D: Digest, T0: Hash<D>, T1: Hash<D>, T2: Hash<D>, T3: Hash<D>, T4: Hash<D>, T5: Hash<D>, T6: Hash<D>, T7: Hash<D>, T8: Hash<D>, T9: Hash<D>, T10: Hash<D>, T11: Hash<D>, T12: Hash<D>, T13: Hash<D>, T14: Hash<D>, T15: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for Option<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 0]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 1]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 2]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 3]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 4]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 5]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 6]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 7]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 8]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 9]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 10]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 11]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 12]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 13]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 14]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 15]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 16]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 17]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 18]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 19]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 20]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 21]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 22]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 23]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 24]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 25]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 26]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 27]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 28]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 29]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 30]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 31]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for [T; 32]

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for BinaryHeap<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for BTreeSet<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for LinkedList<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for VecDeque<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for Vec<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for Map<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<D, T> Hash<D> for Tuple<T>

where D: Digest, T: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

impl<const N: usize, D, T> Hash<D> for SmallVec<[T; N]>

where D: Digest, [T; N]: Array, <SmallVec<[T; N]> as IntoIterator>::Item: Hash<D>,

fn hash(self) -> GenericArray<u8, <D as OutputSizeUser>::OutputSize>

Implementors

impl<'a, D: Digest> Hash<D> for &'a TxnId

impl<D: Digest> Hash<D> for TxnId