Struct Fingerprint

pub struct Fingerprint { /* private fields */ }

See https://github.com/rust-lang/rust/blob/master/compiler/rustc_hir/src/stable_hash_impls.rs#L22 The fingerprint conflicts should be very rare and should be handled by the compiler.

That being said, given a high quality hash function, the collision probabilities in question are very small. For example, for a big crate like rustc_middle (with ~50000 LocalDefIds as of the time of writing) there is a probability of roughly 1 in 14,750,000,000 of a crate-internal collision occurring. For a big crate graph with 1000 crates in it, there is a probability of 1 in 36,890,000,000,000 of a StableCrateId collision.

This stores the 16-bytes data in a pair of u64 instead of single u128 to avoid heavily affecting align of the embedding structs.

Implementations

impl Fingerprint

pub fn from_pair(lo: u64, hi: u64) -> Fingerprint

Creates a new fingerprint from the given pair of 64-bit integers.

pub const fn from_u128(hash: u128) -> Fingerprint

Creates a new fingerprint from the given 128-bit integer.

pub fn to_u128(self) -> u128

Gets the fingerprint as a 128-bit integer.

pub fn lower32(self) -> u32

Cuts the fingerprint into a 32-bit integer.

It could be used as a hash value if the fingerprint is calculated from a stable hash function, otherwise, the result has pool quality.

pub fn try_from_str(s: &str) -> Result<Fingerprint, Error>

Creates a new Fingerprint from a svg id that doesn’t have prefix.

pub fn as_svg_id(self, prefix: &'static str) -> String

Creates a XML id from the given prefix and the fingerprint of this reference. Note that the entire html document shares namespace for ids.

Trait Implementations

impl Archive for Fingerprint

where u64: Archive,

type Archived = ArchivedFingerprint

The archived representation of this type.

type Resolver = FingerprintResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: <Fingerprint as Archive>::Resolver, out: *mut <Fingerprint as Archive>::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Fingerprint

fn clone(&self) -> Fingerprint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Fingerprint

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Fingerprint

fn deserialize<D>( deserializer: D, ) -> Result<Fingerprint, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<Fingerprint, __D> for <Fingerprint as Archive>::Archived

where __D: Fallible + ?Sized, u64: Archive, <u64 as Archive>::Archived: Deserialize<u64, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Fingerprint, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Hash for Fingerprint

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Fingerprint

fn cmp(&self, other: &Fingerprint) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Fingerprint

fn eq(&self, other: &Fingerprint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Fingerprint

fn partial_cmp(&self, other: &Fingerprint) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<__S> Serialize<__S> for Fingerprint

where __S: Fallible + ?Sized, u64: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Fingerprint as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for Fingerprint

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Fingerprint

impl Eq for Fingerprint

impl StructuralPartialEq for Fingerprint