Struct indexmap::map::core::IndexMapCore

pub(crate) struct IndexMapCore<K, V> {
    indices: RawTable<usize>,
    entries: Vec<Bucket<K, V>>,
}

Core of the map that does not depend on S

Fields

indices: RawTable<usize>

indices mapping from the entry hash to its index.

entries: Vec<Bucket<K, V>>

entries is a dense vec of entries in their order.

Implementations

impl<K, V> IndexMapCore<K, V>

pub(crate) fn entry(&mut self, hash: HashValue, key: K) -> Entry<'_, K, V>

where K: Eq,

impl<K, V> IndexMapCore<K, V>

pub(super) fn erase_indices_sweep(&mut self, start: usize, end: usize)

Sweep the whole table to erase indices start..end

pub(crate) fn find_or_insert( &mut self, hash: HashValue, key: &K, ) -> Result<usize, usize>

where K: Eq,

Search for a key in the table and return Ok(entry_index) if found. Otherwise, insert the key and return Err(new_index).

Note that hashbrown may resize the table to reserve space for insertion, even before checking if it’s already present, so this is somewhat biased towards new items.

pub(super) fn raw_entry( &mut self, hash: HashValue, is_match: impl FnMut(&K) -> bool, ) -> Result<RawTableEntry<'_, K, V>, &mut Self>

pub(super) fn index_raw_entry( &mut self, index: usize, ) -> Option<RawTableEntry<'_, K, V>>

pub(super) fn indices_mut(&mut self) -> impl Iterator<Item = &mut usize>

impl<K, V> IndexMapCore<K, V>

const MAX_ENTRIES_CAPACITY: usize = _

The maximum capacity before the entries allocation would exceed isize::MAX.

pub(crate) const fn new() -> Self

pub(crate) fn with_capacity(n: usize) -> Self

pub(crate) fn len(&self) -> usize

pub(crate) fn capacity(&self) -> usize

pub(crate) fn clear(&mut self)

pub(crate) fn truncate(&mut self, len: usize)

pub(crate) fn drain<R>(&mut self, range: R) -> Drain<'_, Bucket<K, V>>

where R: RangeBounds<usize>,

pub(crate) fn split_off(&mut self, at: usize) -> Self

pub(crate) fn split_splice<R>( &mut self, range: R, ) -> (Self, IntoIter<Bucket<K, V>>)

where R: RangeBounds<usize>,

pub(crate) fn append_unchecked(&mut self, other: &mut Self)

Append from another map without checking whether items already exist.

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

Reserve capacity for additional more key-value pairs.

fn reserve_entries(&mut self, additional: usize)

Reserve entries capacity, rounded up to match the indices

pub(crate) fn reserve_exact(&mut self, additional: usize)

Reserve capacity for additional more key-value pairs, without over-allocating.

pub(crate) fn try_reserve( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Try to reserve capacity for additional more key-value pairs.

fn try_reserve_entries( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Try to reserve entries capacity, rounded up to match the indices

pub(crate) fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Try to reserve capacity for additional more key-value pairs, without over-allocating.

pub(crate) fn shrink_to(&mut self, min_capacity: usize)

Shrink the capacity of the map with a lower bound

pub(crate) fn pop(&mut self) -> Option<(K, V)>

Remove the last key-value pair

fn push_entry(&mut self, hash: HashValue, key: K, value: V)

Append a key-value pair to entries, without checking whether it already exists.

fn insert_entry(&mut self, index: usize, hash: HashValue, key: K, value: V)

Insert a key-value pair in entries at a particular index, without checking whether it already exists.

pub(crate) fn get_index_of<Q>(&self, hash: HashValue, key: &Q) -> Option<usize>

where Q: ?Sized + Equivalent<K>,

Return the index in entries where an equivalent key can be found

pub(crate) fn insert_full( &mut self, hash: HashValue, key: K, value: V, ) -> (usize, Option<V>)

where K: Eq,

pub(crate) fn replace_full( &mut self, hash: HashValue, key: K, value: V, ) -> (usize, Option<(K, V)>)

where K: Eq,

Same as insert_full, except it also replaces the key

fn insert_unique(&mut self, hash: HashValue, key: K, value: V) -> usize

fn shift_insert_unique( &mut self, index: usize, hash: HashValue, key: K, value: V, )

pub(crate) fn shift_remove_full<Q>( &mut self, hash: HashValue, key: &Q, ) -> Option<(usize, K, V)>

where Q: ?Sized + Equivalent<K>,

Remove an entry by shifting all entries that follow it

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

Remove an entry by shifting all entries that follow it

fn shift_remove_finish(&mut self, index: usize) -> (K, V)

Remove an entry by shifting all entries that follow it

The index should already be removed from self.indices.

fn decrement_indices(&mut self, start: usize, end: usize)

Decrement all indices in the range start..end.

The index start - 1 should not exist in self.indices. All entries should still be in their original positions.

fn increment_indices(&mut self, start: usize, end: usize)

Increment all indices in the range start..end.

The index end should not exist in self.indices. All entries should still be in their original positions.

pub(super) fn move_index(&mut self, from: usize, to: usize)

pub(crate) fn swap_indices(&mut self, a: usize, b: usize)

pub(crate) fn swap_remove_full<Q>( &mut self, hash: HashValue, key: &Q, ) -> Option<(usize, K, V)>

where Q: ?Sized + Equivalent<K>,

Remove an entry by swapping it with the last

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

Remove an entry by swapping it with the last

fn swap_remove_finish(&mut self, index: usize) -> (K, V)

Finish removing an entry by swapping it with the last

The index should already be removed from self.indices.

fn erase_indices(&mut self, start: usize, end: usize)

Erase start..end from indices, and shift end.. indices down to start..

All of these items should still be at their original location in entries. This is used by drain, which will let Vec::drain do the work on entries.

pub(crate) fn retain_in_order<F>(&mut self, keep: F)

where F: FnMut(&mut K, &mut V) -> bool,

fn rebuild_hash_table(&mut self)

pub(crate) fn reverse(&mut self)

Trait Implementations

impl<K, V> Clone for IndexMapCore<K, V>

where K: Clone, V: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Entries for IndexMapCore<K, V>

type Entry = Bucket<K, V>

fn into_entries(self) -> Vec<Self::Entry>

fn as_entries(&self) -> &[Self::Entry]

fn as_entries_mut(&mut self) -> &mut [Self::Entry]

fn with_entries<F>(&mut self, f: F)

where F: FnOnce(&mut [Self::Entry]),