Struct IntTable 

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

A Map associating unique integers and randomly distributed integers to values.

Tries to match std::collections::HashMap’s API, but leaves out functions that either don’t apply (anything to do with hashers), or that just don’t make sense (like std::collections::HashMap::get_key_value, as the key can just be copied).

This is also the reason why this doesn’t include any code examples. In fact, I could leave this entire crate undocumented and just tell you to look at the built-in hashmap.

Implementations

impl<V> IntTable<V>

pub const fn new() -> Self

Creates a new, zero-capacity hashtable that will grow with insertions.

pub fn with_capacity(capacity: usize) -> Self

Creates a new IntTable with the given capacity.

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

Removes the given key from the table, returning its associated value.

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

Shrinks the capacity of the table with a lower limit. It will drop down no lower than the supplied limit.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the underlying table to the number of elements it contains.

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

Reserves at least additional spots in the backing allocation. This might allocate more. You know the drill.

pub fn capacity(&self) -> usize

Returns the map’s capacity

pub fn clear(&mut self)

Removes all elements from self

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

Insertns the given key-value pair into the table, returning the old value at key if there was one.

pub fn try_insert(&mut self, key: u64, value: V) -> Result<&mut V, V>

Attempts to insert value at key, but if key was occupied, this function doesn’t replace the old value.

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

Tries to reserve addional capacity, but doesn’t abort the programme on failure.

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

Returns the value at key

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

Returns a mutable reference to the value at key

pub fn get_many_mut<const N: usize>( &mut self, ks: [u64; N], ) -> Option<[&mut V; N]>

Attempts to get mutable references to N values in the map at once.

Returns an array of length N with the results of each query. For soundness, at most one mutable reference will be returned to any value. None will be returned if any of the keys are duplicates or missing.

pub unsafe fn get_many_unchecked_mut<const N: usize>( &mut self, ks: [u64; N], ) -> Option<[&mut V; N]>

Attempts to get mutable references to N values in the map at once, without validating that the values are unique.

Returns an array of length N with the resultsn of each query. None will be returned if one of the keys are missing.

For a safe alternative see [get_many_mut]

Safety

Calling this method with overlapping keys is undefined behaviour even if the resulting references are not used.

pub fn retain<F>(&mut self, p: F)

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

Removes all values for which p evaluates to false.

pub fn keys(&self) -> impl Iterator<Item = &u64>

Returns an iterator over the keys

pub fn values(&self) -> impl Iterator<Item = &V>

Returns an iterator over the values

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

Returns an iterator over mutable references to the stored values

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

Self-documenting.

pub fn entry(&mut self, key: u64) -> Entry<'_, V>

Gets the given key’s corresponding entry in the map for in-place manipulation.

pub fn len(&self) -> usize

Returns the number of elements in the map

pub fn is_empty(&self) -> bool

Self-documenting.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&u64, &mut V)>

Returns an iterator over the mutable values, but provides a key. For API consistency, it returns a reference to the key as well (instead of passing it by value).

pub fn drain(&mut self) -> impl Iterator<Item = (u64, V)> + '_

Removes all values from self and returns an iterator over all (key, value) pairs.

pub fn iter(&self) -> impl Iterator<Item = (&u64, &V)>

Returns an iterator over all (key, value) pairs.

pub fn extract_if<F>( &mut self, f: F, ) -> ExtractIf<'_, V, impl FnMut(&mut (u64, V)) -> bool>

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

Like Self::retain, but allows you to reuse the values removed in this fashion. Also, this one removes the value if the predicate evaluates to true.

Note that this lets the filter closure mutate every value, regardless of whether or not it shall be kept in the map.

If the returned iterator is not exhausted, like if it was dropped without iterating or the iteration short-circuits, then the remaining elements will be retained.

pub fn into_keys(self) -> impl Iterator<Item = u64>

Consumes self and returns an iterator over its keys.

pub fn into_values(self) -> impl Iterator<Item = V>

Consumes self and returns an iterator over its values.

impl<V> IntTable<V>

pub fn inner(&self) -> &HashTable<(u64, V)>

Returns the inner hashtable for your viewing pleasure.

pub fn into_inner(self) -> HashTable<(u64, V)>

Unwraps the inner hashtable.

Trait Implementations

impl<V> Debug for IntTable<V>

where V: Debug,

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

Formats the value using the given formatter.

impl<V> Default for IntTable<V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for IntTable<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V> Extend<(u64, V)> for IntTable<V>

fn extend<T: IntoIterator<Item = (u64, 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<V> FromIterator<(u64, V)> for IntTable<V>

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

Constructs an IntTable from an iterator. Note that this deduplicates the values and keeps the last value.

impl<V> Index<u64> for IntTable<V>

type Output = V

The returned type after indexing.

fn index(&self, index: u64) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<V> IntoIterator for IntTable<V>

type Item = (u64, V)

The type of the elements being iterated over.

type IntoIter = IntTableIter<<IntTable<V> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V> PartialEq for IntTable<V>

where V: PartialEq,

fn eq(&self, other: &IntTable<V>) -> 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<T: Serialize> Serialize for IntTable<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.