Struct IndexedMap

pub struct IndexedMap<K, V, S, const IMAP: bool = true> { /* private fields */ }

A hash map that you can find a value by an index as well.

It’s encouraged to prefer accessing item by an index over using a key because it is simpler in terms of required operations. Plus, values are laid on sequential memory block, so that we can expect faster iteration as well. However, the map allocates more memory than usual hash map.

If you want to use an index as key interchangeably, then set IMAP to true. Then, the map keeps index->key relation as well so that the map can find a corresponding key from an index.

Implementations

impl<K, V, S> IndexedMap<K, V, S, true>

where S: BuildHasher,

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

Retrieves a shared reference to a key corresponding to the given index.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.get_key(index), Some(&'a'));

impl<K, V, S> IndexedMap<K, V, S, true>

where K: Hash + Eq + Clone, S: BuildHasher,

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

Removes a value at the given index then returns it.

Consider using IndexedMap::remove2 if you need to remove a value by a key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.remove(index), Some("alpha"));

pub fn remove_entry(&mut self, index: usize) -> Option<(K, V)>

Removes a value at the given index then returns it with the corresponding key.

Consider using IndexedMap::remove_entry2 if you need to remove a value by a key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.remove_entry(index), Some(('a', "alpha")));

impl<K, V, S, const IMAP: bool> IndexedMap<K, V, S, IMAP>

where S: Default,

pub fn new() -> Self

Creates a new empty map.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let map = IndexedMap::<char, &'static str, RandomState>::new();

impl<K, V, S, const IMAP: bool> IndexedMap<K, V, S, IMAP>

where K: Hash + Eq + Clone, S: BuildHasher,

pub fn len(&self) -> usize

Returns number of items.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
assert_eq!(map.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let map = IndexedMap::<char, &'static str, RandomState>::new();
assert!(map.is_empty());

pub fn contains_key<Q>(&self, key: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the map contains the given key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
assert!(map.contains_key(&'a'));

pub fn contains_index(&self, index: usize) -> bool

Returns true if the map contains value corresponding to the given index.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert!(map.contains_index(index));

pub fn next_index<Q>(&self, key: &Q) -> usize

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns the next index that will be returned on the next call to IndexedMap::insert with the given key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let next_index = map.next_index(&'a');
let (index, _) = map.insert('a', "alpha");
assert_eq!(next_index, index);

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

Inserts the given key-value pair into the map and returns corresponding index.

If the map contains the key, then replaces values and returns old value.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
let (_, old) = map.insert('a', "ah");
assert_eq!(old, Some("alpha"));

pub fn remove2<Q>(&mut self, key: &Q) -> Option<V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes a value corresponding to the given key then returns it.

Consider using IndexedMap::remove if you need to remove a value by an index.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
assert_eq!(map.remove2(&'a'), Some("alpha"));

pub fn remove_entry2<Q>(&mut self, key: &Q) -> Option<(K, V)>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes a value corresponding to the given key then returns it with the key.

Consider using IndexedMap::remove_entry if you need to remove a value by an index.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
assert_eq!(map.remove_entry2(&'a'), Some(('a', "alpha")));

pub fn get_index<Q>(&self, key: &Q) -> Option<usize>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves an index corresponding to the given key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.get_index(&'a'), Some(index));

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

Retrieves a shared reference to a value at the given index.

Consider using IndexedMap::get2 if you need to get a value by a key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.get(index), Some(&"alpha"));

pub fn get2<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a shared reference to a value corresponding to the given key.

Consider using IndexedMap::get if you need to get a value by an index.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.get2(&'a'), Some(&"alpha"));

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

Retrieves a mutable reference to a value at the given index.

Consider using IndexedMap::get_mut2 if you need to get a value by a key.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.get_mut(index), Some(&mut "alpha"));

pub fn get_mut2<Q>(&mut self, key: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a mutable reference to a value corresponding to the given key.

Consider using IndexedMap::get_mut if you need to get a value by an index.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
let (index, _) = map.insert('a', "alpha");
assert_eq!(map.get_mut2(&'a'), Some(&mut "alpha"));

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

Returns an iterator visiting key-index-value pairs in the map in arbitrary order.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
map.insert('b', "beta");
for (key, index, value) in map.iter() {
    println!("{key}, {index}, {value}");
}

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

Returns a mutable iterator visiting key-index-value pairs in the map in arbitrary order.

You can modify values only through the iterator.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha".to_owned());
map.insert('b', "beta".to_owned());
for (key, index, value) in map.iter_mut() {
    value.push('*');
    println!("{key}, {index}, {value}");
}

pub fn values(&self) -> impl Iterator<Item = &V> + Clone

Returns an iterator visiting all values.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha");
map.insert('b', "beta");
for v in map.values() {
    println!("{v}");
}

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

Returns a mutable iterator visiting all values.

Examples

use my_ecs::ds::IndexedMap;
use std::hash::RandomState;

let mut map = IndexedMap::<_, _, RandomState>::new();
map.insert('a', "alpha".to_owned());
map.insert('b', "beta".to_owned());
for v in map.values_mut() {
    v.push('*');
    println!("{v}");
}

Trait Implementations

impl<K: Clone, V: Clone, S: Clone, const IMAP: bool> Clone for IndexedMap<K, V, S, IMAP>

fn clone(&self) -> IndexedMap<K, V, S, IMAP>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S: Debug, const IMAP: bool> Debug for IndexedMap<K, V, S, IMAP>

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

Formats the value using the given formatter.

impl<K, V, S, const IMAP: bool> Default for IndexedMap<K, V, S, IMAP>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K, V, S, const IMAP: bool> From<&'a IndexedMap<K, V, S, IMAP>> for &'a [Option<V>]

where S: BuildHasher,

fn from(value: &'a IndexedMap<K, V, S, IMAP>) -> Self

Converts to this type from the input type.

impl<K, V, S, const IMAP: bool> Resource for IndexedMap<K, V, S, IMAP>

where K: Send + 'static, V: Send + 'static, S: Send + 'static,