Struct boomphf::hashmap::BoomHashMap2

pub struct BoomHashMap2<K: Hash, D1, D2> { /* private fields */ }

A HashMap data structure where the mapping between keys and 2 values is encoded in a Mphf. You should usually use BoomHashMap with a tuple/struct value type. If the layout overhead of the struct / tuple must be avoided, this variant of is an alternative. This lets us store the keys and values in dense arrays, with ~3 bits/item overhead in the Mphf.

Implementations

impl<K, D1, D2> BoomHashMap2<K, D1, D2>where K: Hash + Debug + PartialEq, D1: Debug, D2: Debug,

pub fn new( keys: Vec<K>, values: Vec<D1>, aux_values: Vec<D2> ) -> BoomHashMap2<K, D1, D2>

Create a new hash map from the parallel arrays keys and values, and aux_values

pub fn get<Q>(&self, kmer: &Q) -> Option<(&D1, &D2)>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

pub fn get_mut<Q>(&mut self, kmer: &Q) -> Option<(&mut D1, &mut D2)>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

pub fn get_key_id<Q>(&self, kmer: &Q) -> Option<usize>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Boom2Iterator<'_, K, D1, D2>

pub fn get_key(&self, id: usize) -> Option<&K>

impl<K, D1, D2> BoomHashMap2<K, D1, D2>where K: Hash + Debug + PartialEq + Send + Sync, D1: Debug, D2: Debug,

pub fn new_parallel( keys: Vec<K>, data: Vec<D1>, aux_data: Vec<D2> ) -> BoomHashMap2<K, D1, D2>

Create a new hash map from the parallel arrays keys and values, and aux_values, using a parallel algorithm to construct the Mphf.

Trait Implementations

impl<K: Clone + Hash, D1: Clone, D2: Clone> Clone for BoomHashMap2<K, D1, D2>

fn clone(&self) -> BoomHashMap2<K, D1, D2>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug + Hash, D1: Debug, D2: Debug> Debug for BoomHashMap2<K, D1, D2>

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

Formats the value using the given formatter.

impl<K, D1, D2> FromIterator<(K, D1, D2)> for BoomHashMap2<K, D1, D2>where K: Hash + Debug + PartialEq, D1: Debug, D2: Debug,

fn from_iter<I: IntoIterator<Item = (K, D1, D2)>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, K: Hash, D1, D2> IntoIterator for &'a BoomHashMap2<K, D1, D2>

type Item = (&'a K, &'a D1, &'a D2)

The type of the elements being iterated over.

type IntoIter = Boom2Iterator<'a, K, D1, D2>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Boom2Iterator<'a, K, D1, D2>

Creates an iterator from a value.