Struct CountedWeave 

pub struct CountedWeave<W, K, N, T>
where
    W: Weave<K, N, T>,
    K: Hash + Copy + Eq + Ord,
    N: Node<K, T>,
{
    pub weave: W,
    pub count: WeaveActionCount,
    /* private fields */
}

A Weave wrapper which logs the number of actions successfully performed on the inner Weave.

See WeaveActionCount for the complete list of loggable actions.

Fields

weave: W

The Weave being wrapped.

Actions performed directly on the inner Weave (without using the wrapper’s functions) are not logged.

count: WeaveActionCount

The number of actions that were performed on the attached Weave.

Implementations

impl<W, K, N, T> CountedWeave<W, K, N, T>

where W: Weave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

pub const fn new(weave: W, count: WeaveActionCount) -> Self

Creates a CountedWeave from a Weave and WeaveActionCount pair.

pub fn from_weave(weave: W) -> Self

Creates a CountedWeave from a Weave.

pub fn into_weave(self) -> W

Converts a CountedWeave into it’s inner Weave.

pub const fn as_weave(&self) -> &W

Returns a reference to the inner Weave.

pub const fn as_count(&self) -> &WeaveActionCount

Returns a reference to the inner WeaveActionCount.

pub fn reset_count(&mut self)

Resets the inner WeaveActionCount to zero.

Trait Implementations

impl<W, K, N, T> ActivePathWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: ActivePathWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

type Active = <W as ActivePathWeave<K, N, T>>::Active

Identifiers of active nodes.

fn active(&self) -> &Self::Active

Returns a reference to the identifiers of active nodes.

fn set_active_path(&mut self, active: impl Iterator<Item = K>)

Replaces the currently active path with the specified set of node IDs.

impl<W, K, N, T> ActiveSingularWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: ActiveSingularWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

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

Returns the active node’s identifier, if any.

impl<W, K, N, T> Archive for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Archive, K: Hash + Copy + Eq + Ord, N: Node<K, T>, WeaveActionCount: Archive, PhantomData<K>: Archive, PhantomData<N>: Archive, PhantomData<T>: Archive,

type Archived = ArchivedCountedWeave<W, K, N, T>

The archived representation of this type.

type Resolver = CountedWeaveResolver<W, K, N, T>

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<W, K, N, T> AsRef<W> for CountedWeave<W, K, N, T>

where W: Weave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

fn as_ref(&self) -> &W

Converts this type into a shared reference of the (usually inferred) input type.

impl<W, K, N, T> BookmarkableWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: BookmarkableWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

type Bookmarks = <W as BookmarkableWeave<K, N, T>>::Bookmarks

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.

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

Sets the bookmarked status of a node with the specified identifier.

impl<W, K, N, T: Clone> Clone for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Clone, K: Hash + Copy + Eq + Ord + Clone, N: Node<K, T> + Clone,

fn clone(&self) -> CountedWeave<W, K, N, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W, K, N, T: Copy> Copy for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Copy, K: Hash + Copy + Eq + Ord + Copy, N: Node<K, T> + Copy,

impl<W, K, N, T: Debug> Debug for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Debug, K: Hash + Copy + Eq + Ord + Debug, N: Node<K, T> + Debug,

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

Formats the value using the given formatter.

impl<W, K, N, T> DeduplicatableWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: DeduplicatableWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>, T: DeduplicatableContents,

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<W, K, N, T: Default> Default for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Default, K: Hash + Copy + Eq + Ord + Default, N: Node<K, T> + Default,

fn default() -> CountedWeave<W, K, N, T>

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized, W, K, N, T> Deserialize<CountedWeave<W, K, N, T>, __D> for Archived<CountedWeave<W, K, N, T>>

where W: Weave<K, N, T> + Archive, K: Hash + Copy + Eq + Ord, N: Node<K, T>, <W as Archive>::Archived: Deserialize<W, __D>, WeaveActionCount: Archive, <WeaveActionCount as Archive>::Archived: Deserialize<WeaveActionCount, __D>, PhantomData<K>: Archive, <PhantomData<K> as Archive>::Archived: Deserialize<PhantomData<K>, __D>, PhantomData<N>: Archive, <PhantomData<N> as Archive>::Archived: Deserialize<PhantomData<N>, __D>, PhantomData<T>: Archive, <PhantomData<T> as Archive>::Archived: Deserialize<PhantomData<T>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<CountedWeave<W, K, N, T>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<W, K, N, T> DiscreteWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: DiscreteWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>, T: DiscreteContents,

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

Splits a node with the specified identifier at the given index, creating a new child node with the identifier new_id.

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

Merges a node with the specified identifier with its parent, with the newly merged node inheriting the parent’s identifier.

impl<W, K, N, T: Eq> Eq for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Eq, K: Hash + Copy + Eq + Ord + Eq, N: Node<K, T> + Eq,

impl<W, K, N, T> From<W> for CountedWeave<W, K, N, T>

where W: Weave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

fn from(value: W) -> Self

Converts to this type from the input type.

impl<W, K, N, T: Hash> Hash for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Hash, K: Hash + Copy + Eq + Ord + Hash, N: Node<K, T> + Hash,

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<W, K, N, T> IndependentWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: IndependentWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>, T: IndependentContents,

fn move_node(&mut self, id: &K, new_parents: &[K]) -> bool

Moves a node with the specified identifier to a new set of parent nodes, returning true if the move was successful.

impl<W, K, N, T, M> MetadataWeave<K, N, T, M> for CountedWeave<W, K, N, T>

where W: MetadataWeave<K, N, T, M>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

fn metadata(&self) -> &M

Returns a reference to the Weave’s associated metadata.

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

Mutable access to the Weave’s associated metadata.

impl<W, K, N, T: Ord> Ord for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Ord, K: Hash + Copy + Eq + Ord + Ord, N: Node<K, T> + Ord,

fn cmp(&self, other: &CountedWeave<W, K, N, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<W, K, N, T: PartialEq> PartialEq for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + PartialEq, K: Hash + Copy + Eq + Ord + PartialEq, N: Node<K, T> + PartialEq,

fn eq(&self, other: &CountedWeave<W, K, N, T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<W, K, N, T: PartialOrd> PartialOrd for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + PartialOrd, K: Hash + Copy + Eq + Ord + PartialOrd, N: Node<K, T> + PartialOrd,

fn partial_cmp(&self, other: &CountedWeave<W, K, N, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<W, K, N, T> SemiIndependentWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: SemiIndependentWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>, T: IndependentContents,

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

Mutable access to the contents of a node with the specified identifier.

impl<__S: Fallible + ?Sized, W, K, N, T> Serialize<__S> for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + Serialize<__S>, K: Hash + Copy + Eq + Ord, N: Node<K, T>, WeaveActionCount: Serialize<__S>, PhantomData<K>: Serialize<__S>, PhantomData<N>: Serialize<__S>, PhantomData<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<W, K, N, T> SortableBookmarkableWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: SortableBookmarkableWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

fn sort_bookmarks_by(&mut self, cmp: impl FnMut(&N, &N) -> Ordering)

Sorts bookmarked nodes using the comparison function cmp.

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

Sorts the identifiers of bookmarked nodes using the comparison function cmp.

impl<W, K, N, T> SortableWeave<K, N, T> for CountedWeave<W, K, N, T>

where W: SortableWeave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

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

Builds a list of all node identifiers ordered by their positions in the Weave.

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

Recursively builds a list of all children of the specified node ordered by their positions in the Weave.

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

Sorts the child nodes of a parent node with the specified identifier using the comparison function cmp.

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

Sorts the identifiers of a parent node’s children with the specified identifier using the comparison function cmp.

fn sort_roots_by(&mut self, cmp: impl FnMut(&N, &N) -> Ordering)

Sorts root nodes (nodes which do not have any parents) using the comparison function cmp.

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

Sorts the identifiers of root nodes (nodes which do not have any parents) using the comparison function cmp.

impl<W, K, N, T: PartialEq> StructuralPartialEq for CountedWeave<W, K, N, T>

where W: Weave<K, N, T> + PartialEq, K: Hash + Copy + Eq + Ord + PartialEq, N: Node<K, T> + PartialEq,

impl<W, K, N, T> Weave<K, N, T> for CountedWeave<W, K, N, T>

where W: Weave<K, N, T>, K: Hash + Copy + Eq + Ord, N: Node<K, T>,

type Nodes = <W as Weave<K, N, T>>::Nodes

Mapping between identifiers and nodes.

type Roots = <W as Weave<K, N, T>>::Roots

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<&N>

Returns a reference to the node corresponding to the identifier.

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

Builds a list of all node identifiers ordered by their positions in the Weave.

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

Recursively builds a list of all children of the specified node ordered by their positions in the Weave.

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

Builds a path through the Weave starting at the deepest active node and ending at a root node.

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

Builds a path through the Weave starting at the specified node and ending at a root node.

fn add_node(&mut self, node: N) -> bool

Inserts a node into the Weave, returning true if the insertion was successful.

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

Sets the active status of a node with the specified identifier.

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

Removes a node with the specified identifier, returning its value if it was present within the Weave.

fn remove_node_tracked(&mut self, id: &K, on_removal: impl FnMut(N)) -> bool

Removes a node with the specified identifier, returning true if it was present within the Weave.

fn remove_all_nodes(&mut self)

Removes all nodes from the Weave.