Struct ManuallyHash

pub struct ManuallyHash<T>
where
    T: ?Sized,
{ /* private fields */ }

A wrapper type with a manually computed hash.

This can be used to turn an unhashable type into a hashable one where the hash is provided manually. Typically, the hash is derived from the data which was used to construct to the unhashable type.

For instance, you could hash the bytes that were parsed into an unhashable data structure.

Equality

Because Typst uses high-quality 128 bit hashes in all places, the risk of a hash collision is reduced to an absolute minimum. Therefore, this type additionally provides PartialEq and Eq implementations that compare by hash instead of by value. For this to be correct, your hash implementation must feed all information relevant to the PartialEq impl to the hasher.

Implementations

impl<T> ManuallyHash<T>

pub fn new(value: T, hash: u128) -> ManuallyHash<T>

Wraps an item with a pre-computed hash.

The hash should be computed with typst_utils::hash128.

pub fn into_inner(self) -> T

Returns the wrapped value.

Trait Implementations

impl<T> Clone for ManuallyHash<T>

where T: Clone + ?Sized,

fn clone(&self) -> ManuallyHash<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for ManuallyHash<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Deref for ManuallyHash<T>

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<ManuallyHash<T> as Deref>::Target

Dereferences the value.

impl<T> Hash for ManuallyHash<T>

where T: ?Sized,

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<T> PartialEq for ManuallyHash<T>

where T: ?Sized,

fn eq(&self, other: &ManuallyHash<T>) -> bool

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

const 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<T> Eq for ManuallyHash<T>

where T: ?Sized,