Struct AbseilHashTable 

pub struct AbseilHashTable<TKey, TValue, TConfig>
where
    TKey: Eq + Hash,
    TConfig: AbseilConfig,
{ /* private fields */ }

The Abseil hash table.

Implementations

impl<TKey, TValue, TConfig> AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TConfig: AbseilConfig,

pub fn new() -> Self

where TConfig: Default,

Creates a new AbseilHashTable with the default configuration.

pub const fn with_config(config: TConfig) -> Self

Creates a new AbseilHashTable with the specified configuration.

pub fn with_capacity_and_config( capacity: Length, config: TConfig, ) -> Result<Self, HashTableError>

Creates a new AbseilHashTable with the specified configuration and capacity.

Errors

For details see HashTableError.

pub fn with_capacity(capacity: Length) -> Result<Self, HashTableError>

where TConfig: Default,

Creates a new AbseilHashTable with the capacity and default configuration.

Errors

For details see HashTableError.

pub const fn length(&self) -> Length

Returns the length of the AbseilHashTable.

pub const fn capacity(&self) -> Length

Returns the capacity of the AbseilHashTable.

Trait Implementations

impl<TKey, TValue, TConfig> Clone for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash + TryClone, TValue: TryClone, TConfig: AbseilConfig + TryClone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TKey, TValue: Debug, TConfig> Debug for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash + Debug, TConfig: AbseilConfig + Debug,

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

Formats the value using the given formatter.

impl<TKey, TValue, TConfig> Default for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TConfig: AbseilConfig + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, TKey, TValue, TConfig> Deserialize<'de> for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash + Deserialize<'de>, TValue: Deserialize<'de>, TConfig: AbseilConfig + Default,

Available on crate feature serde only.

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<TKey, TValue, TConfig> Drop for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TConfig: AbseilConfig,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<TKey, TValue, TConfig> Eq for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TValue: Eq, TConfig: AbseilConfig,

impl<TKey, TValue, TConfig> Hash for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TValue: Hash, TConfig: AbseilConfig,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<TKey, TValue, TConfig> ImmutableHashTable<TKey, TValue> for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TConfig: AbseilConfig,

fn length(&self) -> Length

Returns the number of (TKey, TValue) pairs the table contains. This typically does not correspond to the actual size of the table in bytes.

fn contains<Q>(&self, key: &Q) -> bool

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Checks if the table contains the corresponding key.

fn get<Q>(&self, key: &Q) -> Option<&TValue>

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Checks if the table contains the corresponding key, and if so then returns the reference to the TValue, or None otherwise.

fn get_key_value<Q>(&self, key: &Q) -> Option<KVP<&TKey, &TValue>>

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Checks if the table contains the corresponding key, and if so then returns the (&TKey, &TValue) pair or None otherwise.

fn iter<'a>(&'a self) -> impl Iterator<Item = KVP<&'a TKey, &'a TValue>>

where TKey: 'a, TValue: 'a, Self: 'a,

Returns an iterator over the key-value pairs in the table.

fn is_empty(&self) -> bool

Checks if the table is empty. This does not mean that it doesn’t take space in memory. Equivalent to self.length() == 0 check.

impl<TKey, TValue, TConfig> MutableHashTable<TKey, TValue> for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TConfig: AbseilConfig,

fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut TValue>

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Checks if the table contains the corresponding key, and if so then returns a mutable reference to the TValue, or None otherwise.

fn get_key_value_mut<Q>(&mut self, key: &Q) -> Option<KVP<&TKey, &mut TValue>>

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Checks if the table contains the corresponding key, and if so then returns a mutable reference to the TValue, or None otherwise.

fn remove_entry<Q>(&mut self, key: &Q) -> Option<KVP<TKey, TValue>>

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Removes entire entry from the table. Returns (TKey, TValue) pair for the matching key or None if there is no match.

fn try_insert_or_update_with<FAdd, FUpdate>( &mut self, key: TKey, adder: FAdd, updater: FUpdate, ) -> Result<&mut TValue, HashTableError>

where FAdd: FnOnce() -> TValue, FUpdate: FnOnce(&mut TValue),

Searches the table for a given key. If the table contains it, then it runs updater on the corresponding TValue. Otherwise runs adder to add a new TValue to the table. Returns the mutable reference to the final TValue.

fn iter_mut<'a>( &'a mut self, ) -> impl Iterator<Item = KVP<&'a TKey, &'a mut TValue>> + 'a

where TKey: 'a, TValue: 'a, Self: 'a,

Returns a mutable iterator over the key-value pairs in the table.

fn insert(&mut self, key: TKey, value: TValue) -> Option<TValue>

Inserts given (TKey, TValue) pair into the table.

fn try_insert( &mut self, key: TKey, value: TValue, ) -> Result<Option<TValue>, HashTableError>

Tries to insert given (TKey, TValue) pair into the table.

fn insert_or_update_with<FAdd, FUpdate>( &mut self, key: TKey, adder: FAdd, updater: FUpdate, ) -> &mut TValue

where FAdd: FnOnce() -> TValue, FUpdate: FnOnce(&mut TValue),

Searches the table for a given key. If the table contains it, then it runs updater on the corresponding TValue. Otherwise runs adder to add a new TValue to the table. Returns the mutable reference to the final TValue.

fn remove<Q>(&mut self, key: &Q) -> Option<TValue>

where TKey: Borrow<Q>, Q: Eq + Hash + ?Sized,

Removes entire entry from the table. Similar to MutableHashTable::remove_entry, but returns TValue only for the matching key or None if there is no match.

fn get_or_insert_default(&mut self, key: TKey) -> &mut TValue

where TValue: Default,

Retrieves an existing TValue, or inserts a default one.

fn try_get_or_insert_default( &mut self, key: TKey, ) -> Result<&mut TValue, HashTableError>

where TValue: Default,

Retrieves an existing TValue, or inserts a default one.

fn get_or_insert(&mut self, key: TKey, value: TValue) -> &mut TValue

Retrieves an existing TValue, or inserts the passed one.

fn try_get_or_insert( &mut self, key: TKey, value: TValue, ) -> Result<&mut TValue, HashTableError>

Retrieves an existing TValue, or inserts the passed one.

impl<TKey, TValue, TConfig> PartialEq for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash, TValue: PartialEq, TConfig: AbseilConfig,

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<TKey, TValue, TConfig> ReprC for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash + ReprC, TValue: ReprC, TConfig: AbseilConfig + ReprC,

const CHECK: ()

This field is used for const checks only.

impl<TKey, TValue, TConfig> Send for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Send + Eq + Hash, TValue: Send, TConfig: AbseilConfig + Send,

impl<TKey, TValue, TConfig> Serialize for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash + Serialize, TValue: Serialize, TConfig: AbseilConfig,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<TKey, TValue, TConfig> Sync for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Sync + Eq + Hash, TValue: Sync, TConfig: AbseilConfig + Sync,

impl<TKey, TValue, TConfig> TryClone for AbseilHashTable<TKey, TValue, TConfig>

where TKey: Eq + Hash + TryClone, TValue: TryClone, TConfig: AbseilConfig + TryClone,

type Error = TryCloneHashTableError

fn try_clone(&self) -> Result<Self, Self::Error>

Tries to clone the type.