Struct boomphf::hashmap::BoomHashMap2

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

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: ?Sized>(&self, kmer: &Q) -> Option<(&D1, &D2)> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

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

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: Debug + Hash, D1: Debug, D2: Debug> Debug for BoomHashMap2<K, D1, D2>

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

Formats the value using the given formatter.

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?

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

Creates an iterator from a value.