Struct SumHashes 

pub struct SumHashes<C: ProvidesHasher>(/* private fields */);

Adds hashing to any collection according to the hash of each element, but without respecting iteration order. Instantly usable with HashMap or HashSet. Deref and DerefMut provide access to the wrapped type. To create, use the new method or From.

use hash_that_set::SumHashes;

let my_map: HashMap<i8, String> = HashMap::new();
let mut my_map = SumHashes::new(my_map);

my_map.insert(2, String::from("hello"));

This may be used with any collection, although it requires the wrapped collection to implement ProvidesHasher.

The layout of this struct is guaranteed to be the same as the wrapped collection. This means it is possible to transmute references; however, hash_by_summing_hashes is usually a better option than relying on unsafe.

Implementations

impl<C: ProvidesHasher> SumHashes<C>

pub fn new(value: C) -> Self

Creates the wrapper

pub fn into_inner(self) -> C

Destructures into the inner collection

Trait Implementations

impl<C: Clone + ProvidesHasher> Clone for SumHashes<C>

fn clone(&self) -> SumHashes<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + ProvidesHasher> Debug for SumHashes<C>

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

Formats the value using the given formatter.

impl<C: Default + ProvidesHasher> Default for SumHashes<C>

fn default() -> SumHashes<C>

Returns the “default value” for a type.

impl<C: ProvidesHasher> Deref for SumHashes<C>

type Target = C

The resulting type after dereferencing.

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

Dereferences the value.

impl<C: ProvidesHasher> DerefMut for SumHashes<C>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<C: ProvidesHasher> From<C> for SumHashes<C>

fn from(value: C) -> Self

Creates the wrapper

impl<C: ProvidesHasher> Hash for SumHashes<C>

where for<'c> &'c C: IntoIterator, for<'c> <&'c C as IntoIterator>::Item: Hash,

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<C: ProvidesHasher + IntoIterator> IntoIterator for SumHashes<C>

type Item = <C as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <C as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<C: PartialEq + ProvidesHasher> PartialEq for SumHashes<C>

fn eq(&self, other: &SumHashes<C>) -> 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<C: Eq + ProvidesHasher> Eq for SumHashes<C>

impl<C: ProvidesHasher> StructuralPartialEq for SumHashes<C>