Struct NumberKeyMap 

pub struct NumberKeyMap<V> { /* private fields */ }

A small, specialized hash map keyed by usize values.

It is optimized for zero-misses and so optimized for 99+% reading operations.

It is optimized for integer keys and expects an external invariant that usize::MAX marks vacant slots.

Example

use std::sync::{Mutex, RwLock};
use orengine_utils::NumberKeyMap;

static POOLS: RwLock<NumberKeyMap<Mutex<Vec<Box<[u8]>>>>> = RwLock::new(NumberKeyMap::new());

fn acquire_from_pool(size: usize) -> Box<[u8]> {
    if let Some(v) = POOLS.read().unwrap().get(size) {
        v.lock().unwrap().pop().unwrap_or_else(|| vec![0; size].into_boxed_slice())
    } else {
        vec![0; size].into_boxed_slice()
    }
}

fn put_to_pool(buf: Box<[u8]>) {
    let read_pool = POOLS.read().unwrap();

    if let Some(v) = read_pool.get(buf.len()) {
        v.lock().unwrap().push(buf);
        return;
    }

    drop(read_pool);

    let mut write_pool = POOLS.write().unwrap();
    let res = write_pool.insert(buf.len(), Mutex::new(vec![buf]));

    if let Err(mut v) = res {
        let buf = v.get_mut().unwrap().pop().unwrap();

        write_pool.get(buf.len()).unwrap().lock().unwrap().push(buf);
    }
}

Implementations

impl<V> NumberKeyMap<V>

pub const fn new() -> Self

Create an empty NumberKeyMap.

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

Retrieve a reference to a value stored under key, if present.

If the slot is occupied and contains the requested key, a reference to the value is returned.

Panics

This function panics if key is equal to usize::MAX.

pub fn get_mut(&mut self, key: usize) -> Option<&mut V>

Retrieve a mutable reference to a value stored under key, if present.

If the slot is occupied and contains the requested key, a reference to the value is returned.

Panics

This function panics if key is equal to usize::MAX.

pub fn insert(&mut self, key: usize, value: V) -> Result<(), V>

Insert a key/value pair into the map.

Note

This operation is very expensive! If you want to call it frequently, consider using a HashMap instead.

Errors

Returns Err(V) if the key already exists in the map; otherwise returns Ok(()).

Panics

This function panics if key is equal to usize::MAX

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

Removes an item from the map and returns it if it exists.

Panics

This function panics if key is equal to usize::MAX

pub fn clear_with(&mut self, func: impl Fn((usize, V)))

Clears the NumberKeyMap with the provided function.

pub fn clear(&mut self)

Clears the NumberKeyMap.

impl<V> NumberKeyMap<V>

pub fn iter(&self) -> impl Iterator<Item = (usize, &V)>

Iterate immutably over all (key, &value).

pub fn iter_mut(&mut self) -> impl Iterator<Item = (usize, &mut V)>

Iterate mutably over all (key, &mut value).

impl<V: 'static> NumberKeyMap<V>

pub fn drain(&mut self) -> impl Iterator<Item = (usize, V)>

Remove all entries and yield owned (key, value).

Trait Implementations

impl<V> Default for NumberKeyMap<V>

fn default() -> Self

Returns the “default value” for a type.

impl<V> Drop for NumberKeyMap<V>

fn drop(&mut self)

Executes the destructor for this type.

impl<V> IntoIterator for NumberKeyMap<V>

type Item = (usize, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V> Send for NumberKeyMap<V>

impl<V> Sync for NumberKeyMap<V>