Struct cranelift_entity::SecondaryMap

source ·

pub struct SecondaryMap<K, V>where
    K: EntityRef,
    V: Clone,{ /* private fields */ }

Expand description

A mapping K -> V for densely indexed entity references.

The SecondaryMap data structure uses the dense index space to implement a map with a vector. Unlike PrimaryMap, an SecondaryMap can’t be used to allocate entity references. It is used to associate secondary information with entities.

The map does not track if an entry for a key has been inserted or not. Instead it behaves as if all keys have a default entry from the beginning.

Implementations§

source §

impl<K, V> SecondaryMap<K, V>where
K: EntityRef,
V: Clone,

Shared SecondaryMap implementation for all value types.

source

pub fn new() -> Selfwhere
V: Default,

Create a new empty map.

Examples found in repository ?

src/map.rs (line 147)

146
147
148

    fn default() -> SecondaryMap<K, V> {
        SecondaryMap::new()
    }

More examples

Hide additional examples

src/sparse.rs (line 77)

    pub fn new() -> Self {
        Self {
            sparse: SecondaryMap::new(),
            dense: Vec::new(),
        }
    }

source

pub fn with_capacity(capacity: usize) -> Selfwhere
V: Default,

Create a new, empty map with the specified capacity.

The map will be able to hold exactly capacity elements without reallocating.

source

pub fn with_default(default: V) -> Self

Create a new empty map with a specified default value.

This constructor does not require V to implement Default.

source

pub fn capacity(&self) -> usize

Returns the number of elements the map can hold without reallocating.

source

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

Get the element at k if it exists.

Examples found in repository ?

src/sparse.rs (line 99)

    pub fn get(&self, key: K) -> Option<&V> {
        if let Some(idx) = self.sparse.get(key).cloned() {
            if let Some(entry) = self.dense.get(idx as usize) {
                if entry.key() == key {
                    return Some(entry);
                }
            }
        }
        None
    }

    /// Returns a mutable reference to the value corresponding to the key.
    ///
    /// Note that the returned value must not be mutated in a way that would change its key. This
    /// would invalidate the sparse set data structure.
    pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
        if let Some(idx) = self.sparse.get(key).cloned() {
            if let Some(entry) = self.dense.get_mut(idx as usize) {
                if entry.key() == key {
                    return Some(entry);
                }
            }
        }
        None
    }

    /// Return the index into `dense` of the value corresponding to `key`.
    fn index(&self, key: K) -> Option<usize> {
        if let Some(idx) = self.sparse.get(key).cloned() {
            let idx = idx as usize;
            if let Some(entry) = self.dense.get(idx) {
                if entry.key() == key {
                    return Some(idx);
                }
            }
        }
        None
    }