src/librustc/ich/fingerprint.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use rustc_data_structures::stable_hasher;
  12 use std::mem;
  13 use std::slice;
  14
  15 #[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Clone, Copy, RustcEncodable, RustcDecodable)]
  16 pub struct Fingerprint(u64, u64);
  17
  18 impl Fingerprint {
  19     #[inline]
  20     pub fn zero() -> Fingerprint {
  21         Fingerprint(0, 0)
  22     }
  23
  24     #[inline]
  25     pub fn from_smaller_hash(hash: u64) -> Fingerprint {
  26         Fingerprint(hash, hash)
  27     }
  28
  29     #[inline]
  30     pub fn to_smaller_hash(&self) -> u64 {
  31         self.0
  32     }
  33
  34     #[inline]
  35     pub fn combine(self, other: Fingerprint) -> Fingerprint {
  36         // See https://stackoverflow.com/a/27952689 on why this function is
  37         // implemented this way.
  38         Fingerprint(
  39             self.0.wrapping_mul(3).wrapping_add(other.0),
  40             self.1.wrapping_mul(3).wrapping_add(other.1)
  41         )
  42     }
  43
  44     pub fn to_hex(&self) -> String {
  45         format!("{:x}{:x}", self.0, self.1)
  46     }
  47
  48 }
  49
  50 impl ::std::fmt::Display for Fingerprint {
  51     fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
  52         write!(formatter, "{:x}-{:x}", self.0, self.1)
  53     }
  54 }
  55
  56 impl stable_hasher::StableHasherResult for Fingerprint {
  57     fn finish(mut hasher: stable_hasher::StableHasher<Self>) -> Self {
  58         let hash_bytes: &[u8] = hasher.finalize();
  59
  60         assert!(hash_bytes.len() >= mem::size_of::<u64>() * 2);
  61         let hash_bytes: &[u64] = unsafe {
  62             slice::from_raw_parts(hash_bytes.as_ptr() as *const u64, 2)
  63         };
  64
  65         // The bytes returned bytes the Blake2B hasher are always little-endian.
  66         Fingerprint(u64::from_le(hash_bytes[0]), u64::from_le(hash_bytes[1]))
  67     }
  68 }
  69
  70 impl<CTX> stable_hasher::HashStable<CTX> for Fingerprint {
  71     #[inline]
  72     fn hash_stable<W: stable_hasher::StableHasherResult>(&self,
  73                                           _: &mut CTX,
  74                                           hasher: &mut stable_hasher::StableHasher<W>) {
  75         ::std::hash::Hash::hash(self, hasher);
  76     }
  77 }