Struct wasmer_runtime_core::structures::Map

pub struct Map<K, V> where
    K: TypedIndex,  { /* fields omitted */ }

Dense item map

Methods

impl<K, V> Map<K, V> where
    K: TypedIndex, 

pub fn new() -> Self

Creates a new Map.

pub fn with_capacity(capacity: usize) -> Self

Creates a new empty Map with the given capacity.

pub fn clear(&mut self)

Clears the map. Keeps the allocated memory for future use.

pub fn len(&self) -> usize

Returns the size of this map.

pub fn is_empty(&self) -> bool

Returns true if this map is empty.

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

Adds a new value to this map.

pub fn next_index(&self) -> K

Returns the next index into the map.

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

Reserves the given size.

pub fn into_boxed_map(self) -> BoxedMap<K, V>

Convert this into a BoxedMap.

pub fn into_vec(self) -> Vec<V>

Convert this into a Vec.

impl<K, V> Map<K, V> where
    K: TypedIndex,
    V: Clone, 

pub fn resize(&mut self, new_len: usize, value: V)

Resize this map to the given new length and value.

Methods from Deref<Target = SliceMap<K, V>>

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

Gets a reference to the value at the given index.

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

Gets a mutable reference to the value at the given index.

pub fn len(&self) -> usize

Gets the length of this slice map.

Important traits for Iter<'a, K, V>

impl<'a, K: TypedIndex, V: 'a> Iterator for Iter<'a, K, V> type Item = (K, &'a V);

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

Returns an iterator for this slice map.

Important traits for IterMut<'a, K, V>

impl<'a, K: TypedIndex, V: 'a> Iterator for IterMut<'a, K, V> type Item = (K, &'a mut V);

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

Returns a mutable iterator for this slice map.

pub fn as_ptr(&self) -> *const V

Gets a pointer to the SliceMap.

pub fn as_mut_ptr(&mut self) -> *mut V

Gets a mutable pointer to the SliceMap.

Trait Implementations

impl<K: Clone, V: Clone> Clone for Map<K, V> where
    K: TypedIndex, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for Map<K, V> where
    K: TypedIndex, 

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

Formats the value using the given formatter.

impl<K, V> Deref for Map<K, V> where
    K: TypedIndex, 

type Target = SliceMap<K, V>

The resulting type after dereferencing.

fn deref(&self) -> &SliceMap<K, V>

Dereferences the value.

impl<K, V> DerefMut for Map<K, V> where
    K: TypedIndex, 

fn deref_mut(&mut self) -> &mut SliceMap<K, V>

Mutably dereferences the value.

impl<'de, K, V> Deserialize<'de> for Map<K, V> where
    K: TypedIndex,
    V: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<K, V> Extend<V> for Map<K, V> where
    K: TypedIndex, 

fn extend<I: IntoIterator<Item = V>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

impl<K, V> FromIterator<V> for Map<K, V> where
    K: TypedIndex, 

fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self

Creates a value from an iterator.

impl<K, V> IntoIterator for Map<K, V> where
    K: TypedIndex, 

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) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a Map<K, V> where
    K: TypedIndex, 

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut Map<K, V> where
    K: TypedIndex, 

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> Serialize for Map<K, V> where
    K: TypedIndex,
    V: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.