Struct wasmtime_environ::entity::PrimaryMap

pub struct PrimaryMap<K, V> where
    K: EntityRef,  { /* fields omitted */ }

A primary mapping K -> V allocating dense entity references.

The PrimaryMap data structure uses the dense index space to implement a map with a vector.

A primary map contains the main definition of an entity, and it can be used to allocate new entity references with the push method.

There should only be a single PrimaryMap instance for a given EntityRef type, otherwise conflicting references will be created. Using unknown keys for indexing will cause a panic.

Note that PrimaryMap doesn’t implement Deref or DerefMut, which would allow &PrimaryMap<K, V> to convert to &[V]. One of the main advantages of PrimaryMap is that it only allows indexing with the distinct EntityRef key type, so converting to a plain slice would make it easier to use incorrectly. To make a slice of a PrimaryMap, use into_boxed_slice.

Implementations

impl<K, V> PrimaryMap<K, V> where
    K: EntityRef, 

pub fn new() -> PrimaryMap<K, V>

Create a new empty map.

pub fn with_capacity(capacity: usize) -> PrimaryMap<K, V>

Create a new empty map with the given capacity.

pub fn is_valid(&self, k: K) -> bool

Check if k is a valid key in the map.

pub fn get(&self, k: K) -> Option<&V>

Get the element at k if it exists.

pub fn get_mut(&mut self, k: K) -> Option<&mut V>

Get the element at k if it exists, mutable version.

pub fn is_empty(&self) -> bool

Is this map completely empty?

pub fn len(&self) -> usize

Get the total number of entity references created.

pub fn keys(&self) -> Keys<K>

Iterate over all the keys in this map.

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

Iterate over all the values in this map.

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

Iterate over all the values in this map, mutable edition.

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

Iterate over all the keys and values in this map.

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

Iterate over all the keys and values in this map, mutable edition.

pub fn clear(&mut self)

Remove all entries from this map.

pub fn next_key(&self) -> K

Get the key that will be assigned to the next pushed value.

pub fn push(&mut self, v: V) -> K

Append v to the mapping, assigning a new key which is returned.

pub fn last(&self) -> Option<&V>

Returns the last element that was inserted in the map.

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

Reserves capacity for at least additional more elements to be inserted.

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

Reserves the minimum capacity for exactly additional more elements to be inserted.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the PrimaryMap as much as possible.

pub fn into_boxed_slice(self) -> BoxedSlice<K, V>

Consumes this PrimaryMap and produces a BoxedSlice.

pub fn binary_search_values_by_key<'a, B, F>(
    &'a self,
    b: &B,
    f: F
) -> Result<K, K> where
    F: FnMut(&'a V) -> B,
    B: Ord, 

Performs a binary search on the values with a key extraction function.

Assumes that the values are sorted by the key extracted by the function.

If the value is found then Ok(K) is returned, containing the entity key of the matching value.

If there are multiple matches, then any one of the matches could be returned.

If the value is not found then Err(K) is returned, containing the entity key where a matching element could be inserted while maintaining sorted order.

Trait Implementations

impl<K, V> Clone for PrimaryMap<K, V> where
    K: Clone + EntityRef,
    V: Clone, 

pub fn clone(&self) -> PrimaryMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for PrimaryMap<K, V> where
    K: Debug + EntityRef,
    V: Debug, 

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

Formats the value using the given formatter.

impl<K, V> Default for PrimaryMap<K, V> where
    K: EntityRef, 

pub fn default() -> PrimaryMap<K, V>

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for PrimaryMap<K, V> where
    K: EntityRef,
    V: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<PrimaryMap<K, V>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<K, V> FromIterator<V> for PrimaryMap<K, V> where
    K: EntityRef, 

pub fn from_iter<T>(iter: T) -> PrimaryMap<K, V> where
    T: IntoIterator<Item = V>, 

Creates a value from an iterator.

impl<K, V> Hash for PrimaryMap<K, V> where
    K: Hash + EntityRef,
    V: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<K, V> Index<K> for PrimaryMap<K, V> where
    K: EntityRef, 

Immutable indexing into an PrimaryMap. The indexed value must be in the map.

type Output = V

The returned type after indexing.

pub fn index(&self, k: K) -> &V

Performs the indexing (container[index]) operation.

impl<K, V> IndexMut<K> for PrimaryMap<K, V> where
    K: EntityRef, 

Mutable indexing into an PrimaryMap.

pub fn index_mut(&mut self, k: K) -> &mut V

Performs the mutable indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a mut PrimaryMap<K, V> where
    K: EntityRef, 

type Item = (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?

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

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a PrimaryMap<K, V> where
    K: EntityRef, 

type Item = (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?

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

Creates an iterator from a value.

impl<K, V> IntoIterator for PrimaryMap<K, V> where
    K: EntityRef, 

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?

pub fn into_iter(self) -> <PrimaryMap<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V> PartialEq<PrimaryMap<K, V>> for PrimaryMap<K, V> where
    K: PartialEq<K> + EntityRef,
    V: PartialEq<V>, 

pub fn eq(&self, other: &PrimaryMap<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &PrimaryMap<K, V>) -> bool

This method tests for !=.

impl<K, V> Serialize for PrimaryMap<K, V> where
    K: EntityRef,
    V: Serialize, 

pub 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> Eq for PrimaryMap<K, V> where
    K: Eq + EntityRef,
    V: Eq, 

impl<K, V> StructuralEq for PrimaryMap<K, V> where
    K: EntityRef, 

impl<K, V> StructuralPartialEq for PrimaryMap<K, V> where
    K: EntityRef,