fnv_rs 0.4.4

Fowler–Noll–Vo hash function including 32, 64, 128, 256, 512, & 1024 bit variants.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::fmt;
use hex;

/// A specialized result type for FNV operations.
pub struct FnvHashResult(Box<[u8]>);

impl FnvHashResult {
    pub(crate) fn from_u32(i: u32) -> Self {
        FnvHashResult(Box::from(i.to_be_bytes()))
    }

    pub(crate) fn from_u64(i: u64) -> Self {
        FnvHashResult(Box::from(i.to_be_bytes()))
    }

    pub(crate) fn from_u128(i: u128) -> Self {
        FnvHashResult(Box::from(i.to_be_bytes()))
    }

    #[cfg(feature = "bigint")]
    pub(crate) fn from_bigint<T>(bigint: T) -> Self
    where
        T: crypto_bigint::prelude::Encoding,
    {
        FnvHashResult(Box::from(bigint.to_be_bytes().as_ref()))
    }

    /// Returns a byte slice of this `FnvHashResult`'s contents.
    ///
    /// # Example:
    ///
    /// ```
    /// let hash = Fnv64::hash(bytes);
    /// let hash_bytes = hash.as_bytes();
    /// ```
    pub fn as_bytes(&self) -> &[u8] {
        &self.0
    }

    /// Returns an all-caps hex `String` of this `FnvHashResult`'s contents.
    ///
    /// # Example:
    ///
    /// ```
    /// let hash = Fnv64::hash(bytes);
    /// let hash_hex = hash.as_hex();
    /// ```
    pub fn as_hex(&self) -> String {
        hex::encode(&self.0).to_uppercase()
    }

    /// Returns the length of this `FnvHashResult`'s underlying byte slice.
    ///
    /// # Example:
    ///
    /// ```
    /// let hash = Fnv64::hash(bytes);
    /// let hash_byte_count = hash.len();
    /// ```
    pub fn len(&self) -> usize {
        self.0.len()
    }
}

impl fmt::Display for FnvHashResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.as_hex())
    }
}

impl fmt::LowerHex for FnvHashResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", hex::encode(&self.0))
    }
}

impl fmt::UpperHex for FnvHashResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.as_hex())
    }
}

impl fmt::Debug for FnvHashResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_tuple("FnvHashResult")
            .field(&self.as_hex())
            .finish()
    }
}