Struct AliveMap 

pub struct AliveMap<K, V, S = DefaultHashBuilder> { /* private fields */ }

An insertion-order-preserving hash map that tracks alive entries.

Entries can be removed (marked dead) and later resurrected, and the map can be compacted to remove dead slots while preserving order.

Implementations

impl<K, V> AliveMap<K, V, DefaultHashBuilder>

pub fn new() -> Self

Creates an empty HashMap.

The hash map is initially created with a capacity of 0, so it will not allocate until it is first inserted into.

pub fn with_capacity(n: usize) -> Self

Creates an empty HashMap with the specified capacity.

The hash map will be able to hold at least capacity elements without reallocating. If capacity is 0, the hash map will not allocate.

impl<K, V, S> AliveMap<K, V, S>

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

pub fn with_hasher(h: S) -> Self

Creates an empty AliveMap using the provided hasher h.

pub fn with_capacity_and_hasher(n: usize, h: S) -> Self

Creates an empty AliveMap with the specified initial capacity n and hasher h.

The map will be able to hold at least n elements without reallocating.

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

Inserts a key-value pair into the map.

If the key already exists and is alive, its value is updated. If the key exists but is marked dead, it is resurrected and its value updated.

Examples

use alive_map::AliveMap;

let mut map = AliveMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.insert(1, "b"), Some("a"));

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

Removes a key from the map, returning its value if it was alive.

The slot is marked dead but not removed from internal storage.

Examples

use alive_map::AliveMap;

let mut map = AliveMap::new();
map.insert(1, "a");
assert_eq!(map.remove(&1), Some("a"));
assert_eq!(map.get(&1), None);

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

Returns a reference to the value corresponding to the key, if it is alive.

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

Returns a mutable reference to the value corresponding to the key, if it is alive.

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

Returns true if the map contains a value for the specified key.

pub const fn len(&self) -> usize

Returns the number of alive entries in the map.

pub const fn is_empty(&self) -> bool

Returns true if the map contains no alive entries.

pub fn shrink_to_fit_alive(&mut self)

where K: Clone, V: Clone,

Examples

use alive_map::AliveMap;

let mut map = AliveMap::new();

// Insert entries
map.insert(1, "a");
map.insert(2, "b");
map.insert(3, "c");
assert_eq!(map.len(), 3); // three alive entries

// Remove an entry
assert_eq!(map.remove(&2), Some("b")); // remove key 2
assert_eq!(map.get(&2), None);        // key 2 is dead
assert_eq!(map.len(), 2);             // only two alive entries remain

// Iterate over alive entries in insertion order
let items: Vec<_> = map.iter().collect();
assert_eq!(items, vec![(&1, &"a"), (&3, &"c")]);

// Resurrect a dead entry by reinserting
map.insert(2, "B"); // key 2 resurrected with new value
assert_eq!(map.len(), 3); // three alive entries again

// Iteration still preserves insertion order for alive entries
let items: Vec<_> = map.iter().collect();
assert_eq!(items, vec![(&1, &"a"), (&3, &"c"), (&2, &"B")]);

// Compact internal storage, removing dead slots
map.shrink_to_fit_alive();
assert_eq!(map.len(), 3); // alive count unchanged

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more alive entries.

Examples

use alive_map::AliveMap;

let mut map = AliveMap::<i32, i32>::new();
map.reserve(100);

pub fn iter(&self) -> Iter<'_, K, V>

Returns an iterator over alive entries in insertion order.

The iterator implements ExactSizeIterator and FusedIterator.

pub fn unlink(&mut self, idx: usize)

Removes an entry from the internal linked list

Marked as public just in case

pub fn link_tail(&mut self, idx: usize)

Adds an entry to the end of the internal linked list.

Marked as public just in case

Trait Implementations

impl<K, V> Clone for AliveMap<K, V, DefaultHashBuilder>

where K: Eq + Hash + Clone, V: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, S> Debug for AliveMap<K, V, S>

where K: Debug + Eq + Hash + Clone, V: Debug, S: Default + BuildHasher,

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

Formats the value using the given formatter.

impl<K, V, S> Default for AliveMap<K, V, S>

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

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S> Drop for AliveMap<K, V, S>

fn drop(&mut self)

Executes the destructor for this type.

impl<K, V, S> Extend<(K, V)> for AliveMap<K, V, S>

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

fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K, V, S> FromIterator<(K, V)> for AliveMap<K, V, S>

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

fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<K, V, S> PartialEq for AliveMap<K, V, S>

where K: Eq + Hash + Clone, V: PartialEq, S: Default + BuildHasher,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<K, V, S> Eq for AliveMap<K, V, S>

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