Struct ccache::hashmap::SimpleHmap

pub struct SimpleHmap<Entry, Key, Val, Cid, Umeta, BuildHasher = RandomState> where
    Entry: EntryT<Key, Val, Cid, Umeta>,
    Key: Hash,
    Val: Val,
    Cid: Cid,
    Umeta: Meta<Val>,
    BuildHasher: BuildHasher + Default,  { /* fields omitted */ }

Simple, stable hashmap with indexes

This simple hashmap has some limitations:

• It will not resize
• It always has the same maximum size
• Should not be used in multithread

But it should be efficient enugh, and stable

So if you add or remove elements, the other will not be reshuffled at any time

It also supports O(1) access via indexes

Since it is built around user::EntryT you can even add metadata that will receive callbacks on get/insert operations, and you can combine multiple caches and distinguish them via the user::Cid

In reimplementing the needed types, remember that:

• user::EntryT must have a default type that will be used as “empty-space” marker in the hash_map
• user::Cid needs the default type which is used by EntryT to mark “empty-space”

Implementations

impl<Entry, Key, Val, Cid, Umeta, BuildHasher> SimpleHmap<Entry, Key, Val, Cid, Umeta, BuildHasher> where
    Entry: EntryT<Key, Val, Cid, Umeta>,
    Key: Hash,
    Val: Val,
    Cid: Cid,
    Umeta: Meta<Val>,
    BuildHasher: BuildHasher + Default, 

pub fn with_capacity(capacity: usize) -> Self

pub fn with_capacity_and_hasher(
    capacity: usize,
    hash_builder: BuildHasher
) -> Self

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

pub fn get_full(&self, key: &Key) -> Option<(usize, &Entry)>

pub fn get_full_mut(&mut self, key: &Key) -> Option<(usize, &mut Entry)>

pub fn get_index(&self, idx: usize) -> Option<&Entry>

pub fn get_index_mut(&mut self, idx: usize) -> Option<&mut Entry>

pub fn remove(&mut self, item: &Entry) -> Entry

just mark the entry as not part of a Cid and return a copy don’t bother actually deleting the data

pub fn remove_idx(&mut self, idx: usize) -> Entry

just mark the entry as not part of a Cid and return a copy don’t bother actually deleting the data If not present, return a default Entry

pub fn clear(&mut self)

pub fn insert(&mut self, entry: Entry) -> (Option<Entry>, usize, &Entry)

returns: any eventual clash in Option<Entry> plus the index and a ref to the actual entry. If the hashmap is full and we can not insert the element, returns Err

pub fn insert_mut(&mut self, entry: Entry) -> (Option<Entry>, usize, &mut Entry)

pub fn hasher(&self) -> &BuildHasher

Trait Implementations

impl<Entry, Key, Val, Cid, Umeta, BuildHasher> HashMap<Entry, Key, Val, Cid, Umeta, BuildHasher> for SimpleHmap<Entry, Key, Val, Cid, Umeta, BuildHasher> where
    Entry: EntryT<Key, Val, Cid, Umeta>,
    Key: Hash,
    Val: Val,
    Cid: Cid,
    Umeta: Meta<Val>,
    BuildHasher: BuildHasher + Default, 

fn with_capacity(capacity: usize) -> Self

Construct an Hashmap with the given capacity

fn with_capacity_and_hasher(capacity: usize, hash_builder: BuildHasher) -> Self

Construct an Hashmap with the given capacity and hash builder

fn capacity(&self) -> usize

return the current hashmap max capacity

fn len(&self) -> usize

Returns the current number of elements in the hashmap

fn get_full(&self, key: &Key) -> Option<(usize, &Entry)>

Get the index and the reference to an element if present

fn get_full_mut(&mut self, key: &Key) -> Option<(usize, &mut Entry)>

Get the index and a mutable reference to an element if present

fn get_index(&self, idx: usize) -> Option<&Entry>

Return a reference to the object at the given index, if any

fn get_index_mut(&mut self, idx: usize) -> Option<&mut Entry>

Return a reference to the object at the given index, if any

unsafe fn index_from_entry(&self, e: &Entry) -> usize

Get a ref to an Entry and translate it to an index

fn remove(&mut self, item: &Entry) -> Entry

Remove and ojbect. Returns the removed object Must not reshuffle after removal

fn remove_idx(&mut self, idx: usize) -> Entry

Remove and ojbect at idx. Returns the removed object If no object was present, return a default object Must not reshuffle after removal

fn clear(&mut self)

Remove all objects in the hashmap

fn insert(&mut self, entry: Entry) -> (Option<Entry>, usize, &Entry)

Insert a new element in the hashmap. Returns a pair with a possible clash Option<V> plus the index and the reference to the object just inserted Must not reshuffle or reallocate

fn insert_mut(&mut self, entry: Entry) -> (Option<Entry>, usize, &mut Entry)

Insert a new element in the hashmap. Returns a pair with a possible clash Option<V> plus the index and the mutable reference to the object just inserted Must not reshuffle or reallocate

fn hasher(&self) -> &BuildHasher

returns a reference to the current hasher