Struct Hashed 

pub struct Hashed<V> {
    hash: u64,
    value: V,
}

A value whose hash is computed once, up front.

Hashing one of these writes the stored word instead of walking the value, and comparing two of them settles inequality on the word alone. That is worth doing where a value is large, shared, and hashed once per entity per frame — see VertexLayout.

Equality checks the hash before the value. That is sound because Hash requires equal values to hash alike: a hash mismatch therefore means the values differ, and a hash collision only costs the comparison that would have run anyway. The hasher is fixed rather than chosen per instance for the same reason — equal values have to keep hashing alike for the check to hold.

There is no DerefMut: editing the value through one would leave the stored word stale, and equal values with different words would compare unequal. A mutation goes through Hashed::update instead, which recomputes the word after the value changes.

Fields

hash: u64

The value’s hash.

value: V

The value the hash was taken from.

Implementations

impl<V: Hash> Hashed<V>

pub fn new(value: V) -> Self

Compute value’s hash once and keep it beside the value.

pub fn hash(&self) -> u64

The hash Self::new computed.

pub fn update(&mut self, rewrite: impl FnOnce(&mut V))

Rewrite the value in place and recompute the stored word.

The closure receives the value itself, so a caller can apply one of the value type’s own mutating methods — a set_-style rewrite, say — and leave the word in step with the value it describes. The recomputation costs what Self::new does, so this is the way to change a value that is already built, not a cheaper one.

Trait Implementations

impl<V: Clone> Clone for Hashed<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for Hashed<V>

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

Formats the value using the given formatter.

impl<V> Deref for Hashed<V>

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V: Eq> Eq for Hashed<V>

impl<V> Hash for Hashed<V>

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

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<V: PartialEq> PartialEq for Hashed<V>

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

Equality operator ==.

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

Inequality operator !=.