Struct Core 

pub(crate) struct Core<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> Core<K, V>

pub(crate) fn extract<R>(&mut self, range: R) -> ExtractCore<'_, K, V>

where R: RangeBounds<usize>,

impl<K, V> Core<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 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

pub(crate) fn get_index_of_raw<F>( &self, hash: HashValue, is_match: F, ) -> Option<usize>

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

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 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 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

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)

fn reserve_entries(&mut self, additional: usize)

Reserve entries capacity, rounded up to match the indices

pub(crate) fn insert_unique( &mut self, hash: HashValue, key: K, value: V, ) -> &mut Bucket<K, V>

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

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_insert_unique( &mut self, index: usize, hash: HashValue, key: K, value: V, ) -> &mut Bucket<K, V>

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

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.

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 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(crate) fn move_index(&mut self, from: usize, to: usize)

fn move_index_inner(&mut self, from: usize, to: usize)

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

Trait Implementations

impl<K, V> Clone for Core<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.