Struct Collection

pub struct Collection<T, M>
where
    T: Val,
    M: Meta<T>,
{
    pub root: Location<T, M>,
    pub stash: Stash<T, M>,
    pub divisor: usize,
}

A collection of elements of type T, with metadata of type M.

This is the base type, that all the collection operations are implemented over.

Fields

root: Location<T, M>

The location on the stash that constitutes the root for this collection.

stash: Stash<T, M>

The store for values of type Node<T, M>

divisor: usize

The branching factor, currently hard-coded to 2, which means on average every fourth element will have weight > 0.

Implementations

impl<T, M> Collection<T, M>

where T: Val, M: Meta<T>,

pub fn new() -> Self

Returns a new, empty Collection.

pub fn new_from(root: Location<T, M>, stash: Stash<T, M>) -> Self

Constructs a Collection given a root and a stash

pub fn _html(&self) -> String

where T: Debug,

Produces a html representation of this Collection. For debug use only.

pub fn clone_mut(&mut self) -> Self

Clones the collection, mutating self

pub fn union_using<F, E>(&mut self, b: &mut Self) -> Self

where F: Meta<T> + Select<T> + PartialEq + Ord, E: Meta<T> + PartialEq, M: SubMeta<F> + SubMeta<E>,

Returns a new, cloned collection that is the result of a union operation given two Meta implementations F and E

F is used to select which T goes first in the union.

E is used to find overlapping common subtrees.

For Sets: F: Max<T>, E: CheckSum<T>, and for Maps: F: Key<T::Key>, E: KeySum<T>.

When the equality testing succeeds, elements will be picked from the Collection b.

pub fn mut_context<R: Relative>( &mut self, branch: Branch<T, M, R>, ) -> MutContext<'_, T, M, R>

Constructs a MutContext context, given a branch into the Collection.

impl<T, M> Collection<T, M>

where T: Val, M: Meta<T>,

pub fn iter<'a>(&'a self) -> Iter<'a, T, M, Beginning>

Returns an iterator over Collection

pub fn iter_rev<'a>(&'a self) -> Iter<'a, T, M, End>

Returns a reverse iterator over Collection

Trait Implementations

impl<T, M> PartialEq for Collection<T, M>

where T: Val, M: Meta<T> + SubMeta<CheckSum<u64>>,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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