Struct DependentNode 

pub struct DependentNode<K, T, S>
where
    K: Hash + Copy + Eq + Ord,
    S: BuildHasher + Default + Clone,
{
    pub id: K,
    pub from: Option<K>,
    pub to: IndexSet<K, S>,
    pub active: bool,
    pub bookmarked: bool,
    pub contents: T,
}

A Node in a DependentWeave document.

Fields

id: K

The node’s unique identifier.

from: Option<K>

The identifier corresponding to the node’s parent.

to: IndexSet<K, S>

The identifiers corresponding to the node’s children.

active: bool

If the node should be considered “active”.

DependentWeave only considers the node at the start of an active path to be “active”.

bookmarked: bool

If the node is bookmarked.

contents: T

The node’s contents.

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, S> Archive for DependentNode<K, T, S>

where K: Hash + Copy + Eq + Ord + Archive, S: BuildHasher + Default + Clone, Option<K>: Archive, IndexSet<K, S>: Archive, bool: Archive, T: Archive,

type Archived = ArchivedDependentNode<K, T, S>

The archived representation of this type.

type Resolver = DependentNodeResolver<K, T, 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, S> Clone for DependentNode<K, T, S>

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K, T: Debug, S> Debug for DependentNode<K, T, 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, S> Default for DependentNode<K, T, S>

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

fn default() -> DependentNode<K, T, S>

Returns the “default value” for a type.

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

where K: Hash + Copy + Eq + Ord + Archive, S: BuildHasher + Default + Clone, <K as Archive>::Archived: Deserialize<K, __D>, Option<K>: Archive, <Option<K> as Archive>::Archived: Deserialize<Option<K>, __D>, IndexSet<K, S>: Archive, <IndexSet<K, S> as Archive>::Archived: Deserialize<IndexSet<K, S>, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, T: Archive, <T as Archive>::Archived: Deserialize<T, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<DependentNode<K, T, 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, S> Eq for DependentNode<K, T, S>

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

impl<K, T, S> From<DependentNode<K, T, S>> for IndependentNode<K, T, S>

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

fn from(value: DependentNode<K, T, 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, S> Node<K, T> for DependentNode<K, T, S>

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

type From = Option<K>

Identifiers corresponding to the node’s parents.

type To = IndexSet<K, S>

Identifiers corresponding to the node’s children.

fn id(&self) -> K

Returns the node’s unique identifier.

fn from(&self) -> &Self::From

Returns a reference to the identifiers corresponding to the node’s parents.

fn to(&self) -> &Self::To

Returns a reference to the identifiers corresponding to the node’s children.

fn is_active(&self) -> bool

Returns true if the node is considered “active”.

fn contents(&self) -> &T

Returns a reference to the node’s contents.

impl<K, T, S> PartialEq for DependentNode<K, T, S>

where K: Hash + Copy + Eq + Ord, T: 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, S> Serialize<__S> for DependentNode<K, T, S>

where K: Hash + Copy + Eq + Ord + Serialize<__S>, S: BuildHasher + Default + Clone, Option<K>: Serialize<__S>, IndexSet<K, S>: Serialize<__S>, bool: Serialize<__S>, T: 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, S> TryFrom<IndependentNode<K, T, S>> for DependentNode<K, T, S>

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

type Error = IndependentNode<K, T, S>

The type returned in the event of a conversion error.

fn try_from(value: IndependentNode<K, T, 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.