Struct jupiter::ig::symbols::SymbolMap

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

Provides a efficient lookup map using Symbol as key.

This map is optimized as we know for sure, that the key is an i32. Also, we will use this map for objects within Node and therefore know that most commonly there will be only a few keys (most probably < 8 and almost always < 32).

Therefore we simply use a Vec of tuples to store the keys and their value. We also keep this vector sorted by the key so that a lookup can be done via binary_search.

Using this approach easily beats HashMap in both, performance and memory consumption.

Implementations

impl<V: Default> SymbolMap<V>

pub fn new() -> Self

Creates a new and empty map.

Examples

let mut map = SymbolMap::<i32>::new();
assert_eq!(map.len(), 0);

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

Retrieves the value for the given key.

Examples

let mut map = SymbolMap::<i32>::new();

map.put(42, 1);

assert_eq!(map.get(42).unwrap(), &1);
assert_eq!(map.get(99), None);

pub fn get_or_insert( &mut self, key: Symbol, factory: impl FnMut() -> V ) -> &mut V

Retrieves the value for the given key or creates a new one in none exists.

If a new value is created, Default::default is invoked and a mutable reference is returned.

Examples

let mut map = SymbolMap::<i32>::new();

map.put(42, 1);

assert_eq!(map.get_or_insert(42, || 1), &1);
assert_eq!(map.get_or_insert(23, || 0), &0);

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

Retrieves the value for the given key as mutable reference.

Examples

let mut map = SymbolMap::<String>::new();

map.put(42, "Hello".to_owned());
map.get_mut(42).unwrap().push_str(" World");

assert_eq!(map.get(42).unwrap().as_str(), "Hello World");

pub fn put(&mut self, key: Symbol, value: V)

Puts a value in the for the given key.

Examples

let mut map = SymbolMap::<String>::new();

map.put(42, "Hello".to_owned());

assert_eq!(map.get(42).unwrap().as_str(), "Hello");

pub fn len(&self) -> usize

Counts the number of entries in the map.

Examples

let mut map = SymbolMap::<String>::new();

// If an entry is put in the map, its size is incremented...
map.put(42, "Hello".to_owned());
assert_eq!(map.len(), 1);
    
// If the entry is overwritten, the size remains the same...
map.put(42, "Hello".to_owned());
assert_eq!(map.len(), 1);

// If another entry is added, its size grows once again...
map.put(99, "World".to_owned());
assert_eq!(map.len(), 2);

pub fn is_empty(&self) -> bool

Determines if this map is empty.

Examples

let mut map = SymbolMap::<String>::new();

assert_eq!(map.is_empty(), true);
map.put(42, "Hello".to_owned());
assert_eq!(map.is_empty(), false);

pub fn capacity(&self) -> usize

Reports the capacity currently reserved.

Examples

let mut map = SymbolMap::<String>::new();

let initial_capacity = map.capacity();

for i in 1..=initial_capacity+1 {
    map.put(i as i32, "Hello".to_owned());
}

assert_eq!(map.capacity() > initial_capacity, true);

pub fn entries(&self) -> Iter<'_, (Symbol, V)>

Provides an iterator over all entries in the map.

Examples

let mut map = SymbolMap::<String>::new();

map.put(42, "Hello".to_owned());
map.put(99, "World".to_owned());

let string = map.entries().map(|(key, value)| format!("{}: {}", key, value)).join(", ");
assert_eq!(string, "42: Hello, 99: World");

Trait Implementations

impl<V: Debug> Debug for SymbolMap<V>

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

Formats the value using the given formatter.

impl<V: Default> Default for SymbolMap<V>

fn default() -> SymbolMap<V>

Returns the “default value” for a type.

impl<V: PartialEq> PartialEq for SymbolMap<V>

fn eq(&self, other: &SymbolMap<V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V: Eq> Eq for SymbolMap<V>

impl<V> StructuralPartialEq for SymbolMap<V>