Struct FzHashMap 

pub struct FzHashMap<K, V, BH = RandomState> { /* private fields */ }

A map optimized for fast read access with hashable keys.

A frozen collection differs from the traditional Rust collections, such as HashMap and HashSet types in three key ways. First, creating a frozen collection performs an analysis over the input data to determine the best implementation strategy. Depending on the situation, this analysis is performed at build time or runtime, and it can take a relatively long time when a collection is very large. Second, once created, the keys in frozen collections are immutable. And third, querying a frozen collection is typically considerably faster, which is the whole point.

This type requires that the keys implement the Eq and Hash traits. This can frequently be achieved by using #[derive(PartialEq, Eq, Hash)]. If you implement these yourself, it is important that the following property holds:

k1 == k2 -> hash(k1) == hash(k2)

In other words, if two keys are equal, their hashes must be equal. Violating this property is a logic error.

It is also a logic error for a key to be modified in such a way that the key’s hash, as determined by the Hash trait, or its equality, as determined by the Eq trait, changes while it is in the collection. This is normally only possible through core::cell::Cell, core::cell::RefCell, global state, I/O, or unsafe code.

The behavior resulting from either logic error can include panics, incorrect results, memory leaks, and non-termination.

Alternate Choices

If your keys are integers or enum variants, you should use the FzScalarMap type instead. If your keys are strings, you should use the FzStringMap type instead. Both of these will deliver better performance since they are specifically optimized for those key types.

If your keys are known at compile time, consider using the various fz_*_map macros instead of this type as they generally perform better.

Implementations

impl<K, V> FzHashMap<K, V>

pub fn new(entries: Vec<(K, V)>) -> FzHashMap<K, V>

where K: Eq + Hash,

Creates a frozen map. If the input contains duplicate keys, the latter one in the input is used and all former ones are discarded.

impl<K, V, BH> FzHashMap<K, V, BH>

where BH: BuildHasher,

pub fn with_hasher(entries: Vec<(K, V)>, bh: BH) -> FzHashMap<K, V, BH>

where K: Eq + Hash,

Creates a frozen map which uses the given hash builder to hash keys. If the input contains duplicate keys, the latter one in the input is used and all former ones are discarded.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns a mutable reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type.

pub fn get_key_value<Q>(&self, key: &Q) -> Option<(&K, &V)>

where Q: Hash + Equivalent<K> + ?Sized,

Returns the key-value pair corresponding to the supplied key.

This is potentially useful:

• for key types where non-identical keys can be considered equal;

• for getting the &K stored key value from a borrowed &Q lookup key; or

• for getting a reference to a key with the same lifetime as the collection.

• The supplied key may be any borrowed form of the map’s key type, but Hash and Eq on the borrowed form must match those for the key type.

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

where Q: Hash + Equivalent<K> + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type.

pub fn get_disjoint_mut<Q, const N: usize>( &mut self, keys: [&Q; N], ) -> [Option<&mut V>; N]

where Q: Hash + Eq + Equivalent<K> + ?Sized,

Gets multiple mutable values from the map.

Panics

Panics if the same key is specified multiple times.

pub unsafe fn get_disjoint_unchecked_mut<Q, const N: usize>( &mut self, keys: [&Q; N], ) -> [Option<&mut V>; N]

where Q: Hash + Equivalent<K> + ?Sized,

Gets multiple mutable values from the map.

Safety

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

pub fn len(&self) -> usize

Returns the number of elements in the collection.

pub fn is_empty(&self) -> bool

Returns true if the collection contains no elements.

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all entries in arbitrary order.

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

An iterator producing mutable references to all entries in arbitrary order.

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order.

pub fn into_keys(self) -> IntoKeys<K, V>

A consuming iterator visiting all keys in arbitrary order.

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order.

pub fn values_mut(&mut self) -> ValuesMut<'_, K, V>

An iterator visiting all values mutably in arbitrary order.

pub fn into_values(self) -> IntoValues<K, V>

A consuming iterator visiting all values in arbitrary order.

Trait Implementations

impl<K, V, BH> Clone for FzHashMap<K, V, BH>

where K: Clone, V: Clone, BH: Clone,

fn clone(&self) -> FzHashMap<K, V, BH>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, V, BH> Debug for FzHashMap<K, V, BH>

where K: Debug, V: Debug, BH: BuildHasher,

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

Formats the value using the given formatter.

impl<K, V, BH> Default for FzHashMap<K, V, BH>

where BH: Default,

fn default() -> FzHashMap<K, V, BH>

Returns the “default value” for a type.

impl<'de, K, V, BH> Deserialize<'de> for FzHashMap<K, V, BH>

where K: Deserialize<'de> + Hash + Eq, V: Deserialize<'de>, BH: BuildHasher + Default,

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<FzHashMap<K, V, BH>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, const N: usize, BH> From<[(K, V); N]> for FzHashMap<K, V, BH>

where K: Eq + Hash, BH: BuildHasher + Default,

fn from(entries: [(K, V); N]) -> FzHashMap<K, V, BH>

Converts to this type from the input type.

impl<T, BH> From<FzHashMap<T, (), BH>> for FzHashSet<T, BH>

where T: Hash + Eq, BH: BuildHasher + Default,

fn from(map: FzHashMap<T, (), BH>) -> FzHashSet<T, BH>

Converts to this type from the input type.

impl<K, V, BH> FromIterator<(K, V)> for FzHashMap<K, V, BH>

where K: Eq + Hash, BH: BuildHasher + Default,

fn from_iter<T>(iter: T) -> FzHashMap<K, V, BH>

where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<K, V, Q, BH> Index<&Q> for FzHashMap<K, V, BH>

where Q: Hash + Equivalent<K> + ?Sized, BH: BuildHasher,

type Output = V

The returned type after indexing.

fn index(&self, index: &Q) -> &<FzHashMap<K, V, BH> as Index<&Q>>::Output

Performs the indexing (container[index]) operation.

impl<'a, K, V, BH> IntoIterator for &'a FzHashMap<K, V, BH>

where BH: BuildHasher,

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a FzHashMap<K, V, BH> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, K, V, BH> IntoIterator for &'a mut FzHashMap<K, V, BH>

where BH: BuildHasher,

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut FzHashMap<K, V, BH> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V, BH> IntoIterator for FzHashMap<K, V, BH>

where BH: BuildHasher,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <FzHashMap<K, V, BH> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V, BH> Len for FzHashMap<K, V, BH>

where BH: BuildHasher,

fn len(&self) -> usize

Returns the number of elements in the collection.

fn is_empty(&self) -> bool

Returns true if the collection contains no elements.

impl<K, V, Q, BH> MapExtras<K, V, Q> for FzHashMap<K, V, BH>

where Q: Hash + Equivalent<K> + ?Sized, BH: BuildHasher,

fn get_key_value(&self, key: &Q) -> Option<(&K, &V)>

Returns the key-value pair corresponding to the supplied key.

fn get_disjoint_mut<const N: usize>( &mut self, keys: [&Q; N], ) -> [Option<&mut V>; N]

where Q: Eq,

Gets multiple mutable values from the map.

unsafe fn get_disjoint_unchecked_mut<const N: usize>( &mut self, keys: [&Q; N], ) -> [Option<&mut V>; N]

Safety

impl<K, V, BH> MapIteration<K, V> for FzHashMap<K, V, BH>

where BH: BuildHasher,

type Iterator<'a> = Iter<'a, K, V> where K: 'a, V: 'a, BH: 'a

The type of the iterator returned by Self::iter.

type KeyIterator<'a> = Keys<'a, K, V> where K: 'a, V: 'a, BH: 'a

The type of the iterator returned by Self::keys.

type ValueIterator<'a> = Values<'a, K, V> where K: 'a, V: 'a, BH: 'a

The type of the iterator returned by Self::values.

type MutIterator<'a> = IterMut<'a, K, V> where K: 'a, V: 'a, BH: 'a

The type of the mutable iterator returned by Self::iter_mut.

type ValueMutIterator<'a> = ValuesMut<'a, K, V> where K: 'a, V: 'a, BH: 'a

The type of the mutable iterator returned by Self::values_mut.

type IntoKeyIterator = IntoKeys<K, V>

The type of the iterator returned by Self::into_keys.

type IntoValueIterator = IntoValues<K, V>

The type of the iterator returned by Self::into_values.

fn iter(&self) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::Iterator<'_>

An iterator visiting all entries in arbitrary order.

fn iter_mut( &mut self, ) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::MutIterator<'_>

An iterator producing mutable references to all entries in arbitrary order.

fn keys(&self) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::KeyIterator<'_>

An iterator visiting all keys in arbitrary order.

fn into_keys( self, ) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::IntoKeyIterator

A consuming iterator visiting all keys in arbitrary order.

fn values( &self, ) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::ValueIterator<'_>

An iterator visiting all values in arbitrary order.

fn values_mut( &mut self, ) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::ValueMutIterator<'_>

An iterator visiting all values mutably in arbitrary order.

fn into_values( self, ) -> <FzHashMap<K, V, BH> as MapIteration<K, V>>::IntoValueIterator

A consuming iterator visiting all values in arbitrary order.

impl<K, V, Q, BH> MapQuery<Q, V> for FzHashMap<K, V, BH>

where Q: Hash + Equivalent<K> + ?Sized, BH: BuildHasher,

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

Returns a reference to the value corresponding to the key.

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

Returns a mutable reference to the value corresponding to the key.

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

Returns true if the map contains a value for the specified key.

impl<K, V, MT, BH> PartialEq<MT> for FzHashMap<K, V, BH>

where K: PartialEq + Hash, V: PartialEq, MT: MapQuery<K, V>, BH: BuildHasher,

fn eq(&self, other: &MT) -> 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<K, V, BH> Serialize for FzHashMap<K, V, BH>

where K: Serialize, V: Serialize, BH: BuildHasher,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, BH> Eq for FzHashMap<K, V, BH>

where K: Eq + Hash, V: Eq, BH: BuildHasher,

impl<K, V, Q, BH> Map<K, V, Q> for FzHashMap<K, V, BH>

where Q: Hash + Equivalent<K> + ?Sized, BH: BuildHasher,