Struct trashmap::TrashMap

pub struct TrashMap<K: ?Sized, V, S = RandomState> { /* fields omitted */ }

A hash map that can operate on known hash values (Trash) instead of actual keys

Sometimes you need to access the same element in the hashmap multiple times and don't wish to re-hash each time. In such a case, you can use TrashMap, which will provide a Trash id that can be used to cheaply access map values as long as you keep it around.

An assumption made here is that there are no hash collisions in the u64 hash space for your hasher. If there are, this may result in unpredictable behavior.

use trashmap::TrashMap;

let mut map = TrashMap::new();
let id = map.insert("foo", "bar");
do_stuff(&mut map);
assert!(map.get(id) == Some(&"bar"));
map.remove(id);

Methods

impl<K: ?Sized, V, S> TrashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher, 

pub fn new() -> Self where
    S: Default, 

Construct a basic TrashMap

pub fn with_capacity_and_hasher(cap: usize, hasher: S) -> Self

Construct a TrashMap with a custom hasher and/or capacity

pub fn insert<Q: ?Sized>(&mut self, k: &Q, v: V) -> Trash where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Inserts a key-value pair, returning the Trash id for the entry

pub fn insert_id(&mut self, k: Trash, v: V) -> Option<V>

Inserts a key-value pair, using the Trash id for the key

Returns the old value if present

pub fn insert_replace<Q: ?Sized>(&mut self, k: &Q, v: V) -> (Trash, Option<V>) where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Inserts a key-value pair, returning the Trash id for the entry as well as the old entry, if present

pub fn get(&self, key: Trash) -> Option<&V>

Gets the entry corresponding to a given Trash id, if present

pub fn get_key<Q: ?Sized>(&self, key: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Gets the entry corresponding to a given key, if present.

pub fn remove(&mut self, key: Trash) -> Option<V>

Removes and returns the entry corresponding to a given Trash id, if present

pub fn remove_key<Q: ?Sized>(&mut self, key: &Q) -> Option<V> where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Removes and returns an entry corresponding to a given key

pub fn trash<Q: ?Sized>(&self, k: &Q) -> Trash where
    K: Borrow<Q>,
    Q: Hash + Eq, 

Get the Trash id for a given key

Trait Implementations

impl<K: ?Sized, V, S> Default for TrashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher + Default, 

fn default() -> Self

Returns the "default value" for a type.