Struct DarkTree

pub struct DarkTree<T: Clone + Send + Sync> {
    leaf: DarkTreeLeaf<T>,
    children: Vec<DarkTree<T>>,
    min_capacity: usize,
    max_capacity: Option<usize>,
}

This struct represents a DFS post-order traversal Tree.

When we iterate through the tree, we first process tree node’s children, and then the node itself, recursively. Based on this, initial tree node (leaf), known as the root, will always show up at the end of iteration. It is advised to always execute .build() after finishing setting up the Tree, to properly index it and check its integrity.

Fields

leaf: DarkTreeLeaf<T>

This tree’s leaf information, along with its data

children: Vec<DarkTree<T>>

Vector containing all tree’s branches(children tree)

min_capacity: usize

Min capacity of the tree, including all children nodes recursively from the root. Since root is always present, min capacity must always be >= 1. This is enforced by the root, so children nodes don’t have to set it up. If children nodes children(recursively) make us not exceed that min capacity, we will be able to catch it using .check_min_capacity() or .integrity_check().

max_capacity: Option<usize>

Optional max capacity of the tree, including all children nodes recursively from the root. None indicates no capacity restrictions. This is enforced by the root, so children nodes don’t have to set it up. If children nodes children(recursively) make us exceed that capacity, we will be able to catch it using .check_max_capacity() or .integrity_check().

Implementations

impl<T: Clone + Send + Sync> DarkTree<T>

pub fn new( data: T, children: Vec<DarkTree<T>>, min_capacity: Option<usize>, max_capacity: Option<usize>, ) -> DarkTree<T>

Initialize a DarkTree, using provided data to generate its root.

pub fn build(&mut self) -> DarkTreeResult<()>

Build the DarkTree indexes and perform an integrity check on them. This should be used after we have appended all child nodes, so we don’t have to call .index() and .integrity_check() manually.

pub fn build_vec(&mut self) -> DarkTreeResult<Vec<DarkLeaf<T>>>

Build the DarkTree using .build() and then produce a flattened vector containing all the leafs in DFS post-order traversal order.

fn len(&self) -> usize

Return the count of all DarkTree leafs.

fn check_min_capacity(&self) -> DarkTreeResult<()>

Check if configured min capacity have not been exceeded.

fn check_max_capacity(&self) -> DarkTreeResult<()>

Check if configured max capacity have been exceeded.

pub fn append(&mut self, child: DarkTree<T>) -> DarkTreeResult<()>

Append a new child node to the DarkTree, if max capacity has not been exceeded. This call doesn’t update the indexes, so either .index() or .build() must be called after it.

fn set_parent_children_indexes(&mut self, parent_index: Option<usize>)

Set DarkTree’s leaf parent and children indexes, and trigger the setup of its children indexes.

fn index(&mut self)

Setup DarkTree’s leafs indexes, based on DFS post-order traversal order. This call assumes it was triggered for the root of the tree, which has no parent index.

fn check_parent_children_indexes( &self, parent_index: Option<usize>, ) -> DarkTreeResult<()>

Verify DarkTree’s leaf parent and children indexes validity, and trigger the check of its children indexes.

fn integrity_check(&self) -> DarkTreeResult<()>

Verify current DarkTree’s leafs indexes validity, based on DFS post-order traversal order. Additionally, check that min and max capacities have been properly configured, min capacity has been exceeded and max capacity has not. This call assumes it was triggered for the root of the tree, which has no parent index.

fn iter(&self) -> DarkTreeIter<'_, T>

Immutably iterate through the tree, using DFS post-order traversal.

fn iter_mut(&mut self) -> DarkTreeIterMut<'_, T>

Mutably iterate through the tree, using DFS post-order traversal.

Trait Implementations

impl<T: Clone + Clone + Send + Sync> Clone for DarkTree<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone + Send + Sync> Debug for DarkTree<T>

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

Formats the value using the given formatter.

impl<'a, T: Clone + Send + Sync> IntoIterator for &'a DarkTree<T>

Define fusion iteration behavior, allowing us to use the DarkTreeIter iterator in loops directly, without using .iter() method of DarkTree.

type Item = &'a DarkTreeLeaf<T>

The type of the elements being iterated over.

type IntoIter = DarkTreeIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: Clone + Send + Sync> IntoIterator for &'a mut DarkTree<T>

Define fusion iteration behavior, allowing us to use the DarkTreeIterMut iterator in loops directly, without using .iter_mut() method of DarkTree.

type Item = &'a mut DarkTreeLeaf<T>

The type of the elements being iterated over.

type IntoIter = DarkTreeIterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Clone + Send + Sync> IntoIterator for DarkTree<T>

Define fusion iteration behavior, allowing us to use the DarkTreeIntoIter .into_iter() method, to consume the DarkTree and iterate over it.

type Item = DarkTreeLeaf<T>

The type of the elements being iterated over.

type IntoIter = DarkTreeIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq + Clone + Send + Sync> PartialEq for DarkTree<T>

fn eq(&self, other: &DarkTree<T>) -> 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.

impl<T: Clone + Send + Sync> StructuralPartialEq for DarkTree<T>