Struct stateright::util::DenseNatMap

pub struct DenseNatMap<K, V> { /* private fields */ }

A map optimized for cases where each key corresponds with a unique entry in the range [0..self.len()] and vice versa (each number in that range corresponds with a unique key in the map). DenseNatMap<K, V> serves as a replacement for a similar Vec<V> pattern but provides additional type safety to distinguish indices derived from K1: Into<usize> versus some other K2: Into<usize>.

Purpose

For example, if a model’s state has no gaps in FileIds or ProcessIds, one approach is the following.

struct MyStruct {
    file_metadata:    Vec<Metadata>, // indexed by `Into::<usize>::into(FileId)`
    file_contents:    Vec<RawBytes>, // indexed by `Into::<usize>::into(FileId)`
    process_metadata: Vec<Metadata>, // indexed by `Into::<usize>::into(ProcessId)`
    process_memory:   Vec<RawBytes>, // indexed by `Into::<usize>::into(ProcessId)`
}

Unfortunately the above fails to indicate to the compiler that the file_* fields have a different indexing relationship than the process_* fields. DenseNatMap serves the same purpose as Vec, but in contrast with the above example, indexing by a key of the wrong type would be a type error.

use stateright::util::DenseNatMap;
struct MyStruct {
    file_metadata:    DenseNatMap<FileId,    Metadata>,
    file_contents:    DenseNatMap<FileId,    RawBytes>,
    process_metadata: DenseNatMap<ProcessId, Metadata>,
    process_memory:   DenseNatMap<ProcessId, RawBytes>,
}

Usage

Multiple mechanisms are available to construct a DenseNatMap. For example:

1. Construct an empty map with DenseNatMap::new, then insert the key-value pairs in order: first the pair whose key corresponds with 0, then the pair whose key corresponds with 1, and so on. Note that inserting out of order will panic.

   let mut m = DenseNatMap::new();
   m.insert(Id::from(0), "first");
   m.insert(Id::from(1), "second");

2. Or leverage Iterator::collect.

   let mut m: DenseNatMap<Id, &'static str> = vec![
       (Id::from(1), "second"),
       (Id::from(0), "first"),
   ].into_iter().collect();

Implementations

impl<K, V> DenseNatMap<K, V>

pub fn new() -> Self

Constructs an empty DenseNatMap.

pub fn get(&self, key: K) -> Option<&V>where usize: From<K>,

Accepts a key, and returns None if invalid, otherwise Some(value).

pub fn insert(&mut self, key: K, value: V) -> Option<V>where usize: From<K>, K: From<usize>,

Inserts a key-value pair and returns None if no value was previously associated, otherwise Some(previous_value). Panics if neither overwriting a key nor inserting at the end.

pub fn iter(&self) -> impl Iterator<Item = (K, &V)>where K: From<usize>,

Returns an iterator over pairs in the map whereby values are borrowed.

See also DenseNatMap::values.

pub fn len(&self) -> usize

Returns the number of elements in the map.

pub fn values(&self) -> impl Iterator<Item = &V>

Returns an iterator over values in the map.

See also DenseNatMap::iter.

Trait Implementations

impl<K: Clone, V: Clone> Clone for DenseNatMap<K, V>

fn clone(&self) -> DenseNatMap<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 DenseNatMap<K, V>

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

Formats the value using the given formatter.

impl<K, V> Default for DenseNatMap<K, V>

fn default() -> Self

Returns the “default value” for a type.

impl<R, V> From<&DenseNatMap<R, V>> for RewritePlan<R, DenseNatMap<R, R>>where R: From<usize> + Copy, usize: From<R>, V: Ord,

fn from(s: &DenseNatMap<R, V>) -> Self

Converts to this type from the input type.

impl<R, V> From<DenseNatMap<R, V>> for RewritePlan<R, DenseNatMap<R, R>>where R: From<usize> + Copy, usize: From<R>, V: Ord,

fn from(s: DenseNatMap<R, V>) -> Self

Converts to this type from the input type.

impl<K, V> From<Vec<V, Global>> for DenseNatMap<K, V>

fn from(values: Vec<V>) -> Self

Converts to this type from the input type.

impl<K, V> FromIterator<(K, V)> for DenseNatMap<K, V>where usize: From<K>,

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

Creates a value from an iterator.

impl<K, V> FromIterator<V> for DenseNatMap<K, V>

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

Creates a value from an iterator.

impl<K: Hash, V: Hash> Hash for DenseNatMap<K, V>

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<K, V> Index<K> for DenseNatMap<K, V>where usize: From<K>,

type Output = V

The returned type after indexing.

fn index(&self, key: K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<K, V> IndexMut<K> for DenseNatMap<K, V>where usize: From<K>,

fn index_mut(&mut self, key: K) -> &mut Self::Output

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

impl<K, V> IntoIterator for DenseNatMap<K, V>where K: From<usize>,

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<K: PartialEq, V: PartialEq> PartialEq<DenseNatMap<K, V>> for DenseNatMap<K, V>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R, K, V> Rewrite<R> for DenseNatMap<K, V>where K: From<usize> + Rewrite<R>, V: Rewrite<R>, usize: From<K>,

fn rewrite<S>(&self, plan: &RewritePlan<R, S>) -> Self

Generates a corresponding instance with values revised based on a particular RewritePlan.

impl<K: Eq, V: Eq> Eq for DenseNatMap<K, V>

impl<K, V> StructuralEq for DenseNatMap<K, V>

impl<K, V> StructuralPartialEq for DenseNatMap<K, V>