Struct DependentWeave 

pub struct DependentWeave<K, T, M, S>
where
    K: Hash + Copy + Eq + Ord,
    S: BuildHasher + Default + Clone,
{
    pub metadata: M,
    /* private fields */
}

A tree-based Weave where each Node depends on the contents of the previous Node.

Fields

metadata: M

The metadata associated with the weave.

Implementations

impl<K, T, M, S> DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

pub fn with_capacity(capacity: usize, metadata: M) -> Self

Creates a new, empty DependentWeave with at least the specified capacity.

Contracts

Post-condition: ret.nodes.is_empty()

Post-condition: ret.validate()

pub fn capacity(&self) -> usize

Returns the number of nodes the weave can hold without reallocating.

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more nodes.

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the weave with a lower limit.

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<K, T, M, S> DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

pub fn validate(&self) -> bool

Validates that the weave is internally consistent.

Trait Implementations

impl<K, T, M, S> ActionableWeave<K, DependentNode<K, T, S>, T, M, S> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents + DiscreteContents, S: BuildHasher + Default + Clone,

fn apply(&mut self, action: WeaveAction<K, DependentNode<K, T, S>, T, M>)

Applies a WeaveAction to a Weave.

impl<K, T, M, S> ActiveSingularWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn active(&self) -> Option<K>

Returns the active node’s identifier, if any.

impl<K, T, M, S> Archive for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, HashMap<K, DependentNode<K, T, S>, S>: Archive, IndexSet<K, S>: Archive, Option<K>: Archive, Skip: ArchiveWith<Vec<K>>, M: Archive,

type Archived = ArchivedDependentWeave<K, T, M, S>

The archived representation of this type.

type Resolver = DependentWeaveResolver<K, T, M, S>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<K, T, M, S> BookmarkableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn set_node_bookmarked_status(&mut self, id: &K, value: bool) -> bool

Contracts

Post-condition: ! ret || value == self.bookmarked.contains(id)

Post-condition: ret || old(self.bookmarked.clone()) == self.bookmarked

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Invariant: self.validate()

type Bookmarks = IndexSet<K, S>

Identifiers of bookmarked nodes.

fn bookmarks(&self) -> &Self::Bookmarks

Returns a reference to the identifiers of bookmarked nodes.

fn contains_bookmark(&self, id: &K) -> bool

Returns true if the Weave contains a bookmarked node with the specified identifier.

impl<K, T: Clone, M: Clone, S> Clone for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord + Clone, S: BuildHasher + Default + Clone + Clone,

fn clone(&self) -> DependentWeave<K, T, M, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, T: Debug, M: Debug, S> Debug for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord + Debug, S: BuildHasher + Default + Clone + Debug,

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

Formats the value using the given formatter.

impl<K, T, M, S> DeduplicatableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: DeduplicatableContents, S: BuildHasher + Default + Clone,

fn find_duplicates(&self, id: &K) -> impl Iterator<Item = K>

An iterator over the specified node’s sibling identifiers which contain contents which are duplicates of the specified node’s contents.

impl<K, T: Default, M: Default, S> Default for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord + Default, S: BuildHasher + Default + Clone + Default,

fn default() -> DependentWeave<K, T, M, S>

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized, K, T, M, S> Deserialize<DependentWeave<K, T, M, S>, __D> for Archived<DependentWeave<K, T, M, S>>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, HashMap<K, DependentNode<K, T, S>, S>: Archive, <HashMap<K, DependentNode<K, T, S>, S> as Archive>::Archived: Deserialize<HashMap<K, DependentNode<K, T, S>, S>, __D>, IndexSet<K, S>: Archive, <IndexSet<K, S> as Archive>::Archived: Deserialize<IndexSet<K, S>, __D>, Option<K>: Archive, <Option<K> as Archive>::Archived: Deserialize<Option<K>, __D>, Skip: ArchiveWith<Vec<K>> + DeserializeWith<<Skip as ArchiveWith<Vec<K>>>::Archived, Vec<K>, __D>, M: Archive, <M as Archive>::Archived: Deserialize<M, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<DependentWeave<K, T, M, S>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<K, T, M, S> DiscreteWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: DiscreteContents, S: BuildHasher + Default + Clone,

fn split_node(&mut self, id: &K, at: usize, new_id: K) -> bool

Contracts

Post-condition: ! ret || old(self.nodes.len()) + 1 == self.nodes.len()

Post-condition: ! ret || self.nodes.contains_key(id)

Post-condition: ! ret || self.nodes.contains_key(&new_id)

Post-condition: ! ret || old(!self.nodes.contains_key(&new_id))

Post-condition: ! ret || self.nodes [id].to.contains(&new_id) && self.nodes [id].to.len() == 1

Post-condition: ! ret || self.nodes [&new_id].from == Some(*id)

Post-condition: ! ret || old(self.nodes.get(id).map(|n| n.to.clone())).unwrap() == self.nodes [&new_id].to

Post-condition: ret || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn merge_with_parent(&mut self, id: &K) -> Option<K>

Contracts

Post-condition: ret.is_none() || old(self.nodes.len()) - 1 == self.nodes.len()

Post-condition: ret.is_none() || ! self.nodes.contains_key(id)

Post-condition: ret.is_none() || old(self.nodes.contains_key(id))

Post-condition: ret.is_none() || ! old(self.contains_active(id)) || old(self.contains_active(id)) && self.contains_active(&ret.unwrap())

Post-condition: ret.is_none() || old(self.contains_active(id)) || old(self.nodes.get(id).and_then(|n| n.from).and_then(|p| self.nodes.get(&p)).map(|p| p.active)).unwrap() == self.nodes [&ret.unwrap()].active

Post-condition: ret.is_none() || old(self.nodes.get(id).and_then(|n| n.from).and_then(|p| self.nodes.get(&p)).map(|p| p.from)).unwrap() == self.nodes [&ret.unwrap()].from

Post-condition: ret.is_none() || old(self.nodes.get(id).map(|node| node.to.clone())).unwrap() == self.nodes [&ret.unwrap()].to

Post-condition: ret.is_none() || ret.unwrap() == old(self.nodes.get(id).and_then(|node| node.from)).unwrap()

Post-condition: ret.is_some() || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret.is_some() || old(self.active) == self.active

Post-condition: ret.is_some() || old(self.bookmarked.clone()) == self.bookmarked

Post-condition: old(self.roots.clone()) == self.roots

Invariant: self.validate()

impl<K, T, M, S> Eq for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: Eq, M: Eq, S: BuildHasher + Default + Clone,

impl<K, T, M, S> From<DependentWeave<K, T, M, S>> for IndependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents, S: BuildHasher + Default + Clone,

fn from(value: DependentWeave<K, T, M, S>) -> Self

Converts to this type from the input type.

impl<K, T, M, S> MetadataWeave<K, DependentNode<K, T, S>, T, M> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn metadata_mut<O>(&mut self, callback: impl FnOnce(&mut M) -> O) -> O

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn metadata(&self) -> &M

Returns a reference to the Weave’s associated metadata.

impl<K, T, M, S> PartialEq for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: PartialEq, M: PartialEq, S: BuildHasher + Default + Clone,

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

Equality operator ==.

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

Inequality operator !=.

impl<K, T, M, S> SemiIndependentWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents, S: BuildHasher + Default + Clone,

fn get_contents_mut<O>( &mut self, id: &K, callback: impl FnOnce(&mut T) -> O, ) -> Option<O>

Contracts

Post-condition: ret.is_some() == old(self.nodes.contains_key(id))

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<__S: Fallible + ?Sized, K, T, M, S> Serialize<__S> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone, HashMap<K, DependentNode<K, T, S>, S>: Serialize<__S>, IndexSet<K, S>: Serialize<__S>, Option<K>: Serialize<__S>, Skip: SerializeWith<Vec<K>, __S>, M: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<K, T, M, S> SortableBookmarkableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn sort_bookmarks_by( &mut self, cmp: impl FnMut(&DependentNode<K, T, S>, &DependentNode<K, T, S>) -> Ordering, )

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_bookmarks_by_id(&mut self, cmp: impl FnMut(&K, &K) -> Ordering)

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<K, T, M, S> SortableWeave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn get_ordered_node_identifiers_mirrored(&mut self, output: &mut Vec<K>)

Contracts

Post-condition: output.len() == self.nodes.len()

Post-condition: valid_topological_sort(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_ordered_node_identifiers_mirrored_from( &mut self, id: &K, output: &mut Vec<K>, )

Contracts

Post-condition: lacks_duplicates(output)

Post-condition: ! self.nodes.contains_key(id) || output.first() == Some(id)

Post-condition: self.nodes.contains_key(id) || output.is_empty()

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_node_children_by( &mut self, id: &K, cmp: impl FnMut(&DependentNode<K, T, S>, &DependentNode<K, T, S>) -> Ordering, ) -> bool

Contracts

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.get(id).map(|n| n.to.clone())) == self.nodes.get(id).map(|n| n.to.clone())

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_node_children_by_id( &mut self, id: &K, cmp: impl FnMut(&K, &K) -> Ordering, ) -> bool

Contracts

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.get(id).map(|n| n.to.clone())) == self.nodes.get(id).map(|n| n.to.clone())

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_roots_by( &mut self, cmp: impl FnMut(&DependentNode<K, T, S>, &DependentNode<K, T, S>) -> Ordering, )

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn sort_roots_by_id(&mut self, cmp: impl FnMut(&K, &K) -> Ordering)

Contracts

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

impl<K, T, M, S> TryFrom<IndependentWeave<K, T, M, S>> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, T: IndependentContents, S: BuildHasher + Default + Clone,

type Error = IndependentWeave<K, T, M, S>

The type returned in the event of a conversion error.

fn try_from(value: IndependentWeave<K, T, M, S>) -> Result<Self, Self::Error>

Performs the conversion.

impl<K, T, M, S> Weave<K, DependentNode<K, T, S>, T> for DependentWeave<K, T, M, S>

where K: Hash + Copy + Eq + Ord, S: BuildHasher + Default + Clone,

fn get_ordered_node_identifiers(&mut self, output: &mut Vec<K>)

Contracts

Post-condition: output.len() == self.nodes.len()

Post-condition: valid_topological_sort(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_ordered_node_identifiers_from(&mut self, id: &K, output: &mut Vec<K>)

Contracts

Post-condition: lacks_duplicates(output)

Post-condition: ! self.nodes.contains_key(id) || output.first() == Some(id)

Post-condition: self.nodes.contains_key(id) || output.is_empty()

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_active_path(&mut self, output: &mut Vec<K>)

Contracts

Post-condition: self.active == output.first().copied()

Post-condition: lacks_duplicates(output)

Post-condition: valid_path(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn get_path_from(&mut self, id: &K, output: &mut Vec<K>)

Contracts

Post-condition: ! self.nodes.contains_key(id) || output.first() == Some(id)

Post-condition: self.nodes.contains_key(id) || output.is_empty()

Post-condition: lacks_duplicates(output)

Post-condition: valid_path(&self.nodes, output)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.active) == self.active

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn add_node(&mut self, node: DependentNode<K, T, S>) -> bool

Contracts

Post-condition: ! ret || old(self.nodes.len()) + 1 == self.nodes.len()

Post-condition: ! ret || old(!self.nodes.contains_key(&node.id))

Post-condition: ! ret || self.nodes.contains_key(&old(node.id))

Post-condition: ! ret || old(node.active) == (self.active == Some(old(node.id)))

Post-condition: ! ret || old(node.bookmarked) == self.bookmarked.contains(&old(node.id))

Post-condition: ! ret || old(node.from.is_some()) || self.roots.contains(&old(node.id))

Post-condition: ! ret || old(node.from.is_none()) || old(self.roots.clone()) == self.roots

Post-condition: ret || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret || old(self.roots.clone()) == self.roots

Post-condition: ret || old(self.active) == self.active

Post-condition: ret || old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn set_node_active_status(&mut self, id: &K, value: bool) -> bool

Contracts

Post-condition: ! ret || value == self.contains_active(id)

Post-condition: ret || old(self.active) == self.active

Post-condition: ret == self.nodes.contains_key(id)

Post-condition: old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: old(self.roots.clone()) == self.roots

Post-condition: old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn remove_node(&mut self, id: &K) -> Option<DependentNode<K, T, S>>

Contracts

Post-condition: ! self.nodes.contains_key(id)

Post-condition: ret.is_some() == old(self.nodes.contains_key(id))

Post-condition: ret.as_ref().is_none_or(|node| &node.id == id)

Post-condition: ret.is_none() || old(self.nodes.len()) > self.nodes.len()

Post-condition: ret.is_none() || old(self.bookmarked.len()) >= self.bookmarked.len()

Post-condition: ret.is_some() || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret.is_some() || old(self.roots.clone()) == self.roots

Post-condition: ret.is_some() || old(self.active) == self.active

Post-condition: ret.is_some() || old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn remove_node_tracked( &mut self, id: &K, on_removal: impl FnMut(DependentNode<K, T, S>), ) -> bool

Contracts

Post-condition: ! self.nodes.contains_key(id)

Post-condition: ret == old(self.nodes.contains_key(id))

Post-condition: ! ret || old(self.nodes.len()) > self.nodes.len()

Post-condition: ! ret || old(self.bookmarked.len()) >= self.bookmarked.len()

Post-condition: ret || old(self.nodes.keys().copied().collect::<HashSet<_>>()) == self.nodes.keys().copied().collect ::< HashSet < _ >> ()

Post-condition: ret || old(self.roots.clone()) == self.roots

Post-condition: ret || old(self.active) == self.active

Post-condition: ret || old(self.bookmarked.clone()) == self.bookmarked

Invariant: self.validate()

fn remove_all_nodes(&mut self)

Contracts

Post-condition: self.nodes.is_empty()

Post-condition: self.validate()

type Nodes = HashMap<K, DependentNode<K, T, S>, S>

Mapping between identifiers and nodes.

type Roots = IndexSet<K, S>

Identifiers of root nodes (nodes which do not have any parents).

fn len(&self) -> usize

Returns the number of nodes stored within the Weave.

fn is_empty(&self) -> bool

Returns true if the Weave does not contain any nodes.

fn nodes(&self) -> &Self::Nodes

Returns a reference to the identifier:node mapping.

fn roots(&self) -> &Self::Roots

Returns a reference to the identifiers of root nodes (nodes which do not have any parents).

fn contains(&self, id: &K) -> bool

Returns true if the Weave contains a node with the specified identifier.

fn contains_active(&self, id: &K) -> bool

Returns true if the Weave contains an active node (node.is_active() == true) with the specified identifier.

fn get_node(&self, id: &K) -> Option<&DependentNode<K, T, S>>

Returns a reference to the node corresponding to the identifier.