Struct skew_forest::SkewMap

pub struct SkewMap<T> { /* fields omitted */ }

A mapping from the nodes in a SkewForest to values.

Synchronization

The SkewMap must be kept synchronized with the underlying SkewForest. This means that when a node is pushed onto a path in the SkewForest, then a value must also be pushed onto this SkewMap.

Example

use skew_forest::{SkewForest, SkewPath, SkewPathNode, SkewMap};
 
let mut forest = SkewForest::default();
let mut path = SkewPath::<[SkewPathNode; 8]>::default();
let mut map = SkewMap::default();
 
map.push(forest.push(&mut path), "some value");
map.push(forest.push(&mut path), "some other value");
 
assert_eq!(
    forest.iter(&path).map(|ix| map[ix]).collect::<Vec<_>>(),
    vec!["some value", "some other value"],
);

Methods

impl<T> SkewMap<T>

pub fn synchronize<Idx: Index>(
    &mut self,
    forest: &SkewForest<Idx>,
    f: impl FnMut() -> T
)

Synchronizes this SkewMap with the given SkewForest, inserting new elements by calling a function.

Example

use skew_forest::{SkewForest, SkewPath, SkewPathNode, SkewMap};
 
let mut forest = SkewForest::default();
let mut path = SkewPath::<[SkewPathNode; 8]>::default();
let mut map = SkewMap::default();
 
forest.push(&mut path);
 
// A value has been inserted in the forest without being inserted in the map - they are not
// synchronized!
assert!(!map.is_synchronized(&forest));
 
map.synchronize(&forest, || "some value");
 
// A value for each node has been inserted - we are synchronized again.
assert!(map.is_synchronized(&forest));

pub fn is_synchronized<Idx: Index>(&self, forest: &SkewForest<Idx>) -> bool

Whether this SkewMap is synchronized with the corresponding SkewForest.

pub fn push<Idx: Index>(&mut self, index: SkewIndex<Idx>, value: T) -> Option<T>

Pushes a value with the given index onto this map. If the returned index is one that previously contained a value (due to being reused after garbage collected), then the old value is returned, otherwise None.

Panics

May panic if the SkewMap was not synchronized with the SkewForest that created the SkewIndex prior to the push operation that created the SkewIndex.

Example

use skew_forest::{SkewForest, SkewPath, SkewPathNode, SkewMap};
 
let mut forest = SkewForest::default();
let mut path = SkewPath::<[SkewPathNode; 8]>::default();
let mut map = SkewMap::default();
 
map.push(forest.push(&mut path), "some value");
 
assert_eq!(map[path.last().unwrap()], "some value");

Trait Implementations

impl<T: Clone> Clone for SkewMap<T>

fn clone(&self) -> SkewMap<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SkewMap<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for SkewMap<T>

fn default() -> SkewMap<T>

Returns the "default value" for a type.

impl<T, Idx: Index> Index<SkewIndex<Idx>> for SkewMap<T>

type Output = T

The returned type after indexing.

fn index(&self, index: SkewIndex<Idx>) -> &T

Performs the indexing (container[index]) operation.

impl<T, Idx: Index> IndexMut<SkewIndex<Idx>> for SkewMap<T>

fn index_mut(&mut self, index: SkewIndex<Idx>) -> &mut T

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