Struct IndexMapCore 

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

Core of the map that does not depend on S

Fields

indices: HashTable<usize>

indices mapping from the entry hash to its index.

entries: Vec<Bucket<K, V>>

entries is a dense vec maintaining entry 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(crate) fn extract<R>(&mut self, range: R) -> ExtractCore<'_, K, V>

where R: RangeBounds<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

fn borrow_mut(&mut self) -> RefMut<'_, K, V>

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

pub(crate) fn into_entries(self) -> Vec<Bucket<K, V>>

pub(crate) fn as_entries(&self) -> &[Bucket<K, V>]

pub(crate) fn as_entries_mut(&mut self) -> &mut [Bucket<K, V>]

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

where F: FnOnce(&mut [Bucket<K, V>]),

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.

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

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

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

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

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

pub(crate) fn replace_index_unique( &mut self, index: usize, hash: HashValue, key: K, ) -> K

Replaces the key at the given index, without checking whether it already exists.

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

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 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 duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for IndexMapCore<K, V>

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

Formats the value using the given formatter.