Struct Tree

pub struct Tree<T> { /* private fields */ }

Vec-backed, flattened in pre-order, Tree.

Always contains at least a root node.

Implementations

impl<T: Debug> Tree<T>

pub fn new(root: T) -> Self

Create a new Tree with the specified value

pub fn with_capacity(root: T, capacity: usize) -> Self

Create a new Tree with the specified value & set the capacity of the internal vectors

pub fn capacity(&self) -> usize

Returns the total number of elements the tree can hold without reallocating.

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

Reserves capacity for at least additional more elements to be inserted in the given Tree<T>. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

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

Reserves the minimum capacity for at least additional more elements to be inserted in the given Tree<T>. Unlike reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling reserve_exact, capacity will be greater than or equal to self.len() + additional. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer reserve if future insertions are expected.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Tries to reserve capacity for at least additional more elements to be inserted in the given Tree<T>. The collection may reserve more space to speculatively avoid frequent reallocations. After calling try_reserve, capacity will be greater than or equal to self.len() + additional if it returns Ok(()). Does nothing if capacity is already sufficient. This method preserves the contents even if an error occurs.

Errors

If the capacity overflows, or the allocator reports a failure, then an error is returned.

pub fn try_reserve_exact( &mut self, additional: usize, ) -> Result<(), TryReserveError>

Tries to reserve the minimum capacity for at least additional elements to be inserted in the given Tree<T>. Unlike try_reserve, this will not deliberately over-allocate to speculatively avoid frequent allocations. After calling try_reserve_exact, capacity will be greater than or equal to self.len() + additional if it returns Ok(()). Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore, capacity can not be relied upon to be precisely minimal. Prefer try_reserve if future insertions are expected.

Errors

If the capacity overflows, or the allocator reports a failure, then an error is returned.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the tree as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the tree that there is space for a few more elements.

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

Shrinks the capacity of the tree with a lower bound.

The capacity will remain at least as large as both the length and the supplied value.

If the current capacity is less than the lower limit, this is a no-op.

pub fn truncate(&mut self, len: usize)

Shortens the tree, keeping the first len elements and dropping the rest.

If len is greater than the tree’s current length, this has no effect.

The drain method can emulate truncate, but causes the excess elements to be returned instead of dropped.

Note that this method has no effect on the allocated capacity of the tree.

pub fn push_with_level( &mut self, data: T, level: usize, parent: NodeId, ) -> NodeId

Push a node into the tree

#WARNING

This assumes you are pushing in pre-order!

pub fn pop(&mut self) -> Option<(T, usize, NodeId)>

Removes the last element from a tree and returns it as a triple (data: T, level: usize, parent: NodeId), or None if it is empty.

pub fn drain<R>( &mut self, range: R, ) -> impl Iterator<Item = (T, usize, NodeId)> + '_

where R: RangeBounds<usize> + Clone,

Removes the specified range from the tree in bulk, returning all removed elements as an iterator. If the iterator is dropped before being fully consumed, it drops the remaining removed elements.

The returned iterator keeps a mutable borrow on the tree to optimize its implementation.

Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

Leaking

If the returned iterator goes out of scope without being dropped (due to [mem::forget], for example), the tree may have lost and leaked elements arbitrarily, including elements outside the range.

pub fn clear(&mut self)

Clears the tree, removing all values.

Note that this method has no effect on the allocated capacity of the tree.

pub fn len(&self) -> usize

Returns the number of elements in the tree, also referred to as its ‘length’.

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

pub fn tree_root_mut(&mut self) -> TreeMut<'_, T>

Get a mutable TreeMut handle of the root, so you can push children

This always success

pub fn tree_node_mut(&mut self, id: NodeId) -> Option<TreeMut<'_, T>>

Get a mutable TreeMut from his NodeId, so you can push children

pub fn node(&self, id: NodeId) -> Option<Node<'_, T>>

Get the Node from his NodeId

pub fn root(&self) -> Node<'_, T>

Get the root Node

pub fn node_mut(&mut self, id: NodeId) -> Option<NodeMut<'_, T>>

Get a mutable NodeMut from his NodeId.

pub fn root_mut(&mut self) -> NodeMut<'_, T>

Get a mutable NodeMut handle of the root.

This always success

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

pub fn into_iter(&self) -> IntoIter<'_, T>

pub fn as_data(&self) -> &[T]

A slice view of the internal data

pub fn as_data_mut(&mut self) -> &mut [T]

A slice view of the internal data

pub fn as_level(&self) -> &[usize]

A slice view of the internal level

pub fn get_level(&self, of: NodeId) -> usize

Get the level from a NodeId

pub fn as_parents(&self) -> &[usize]

A slice view of the internal parents

pub fn to_data(self) -> Vec<T>

Consume tree and move-out the data

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

where T: Display,

Pretty-print the tree

Trait Implementations

impl<T: Clone> Clone for Tree<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Tree<T>

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

Formats the value using the given formatter.

impl<T: Debug + Display> Display for Tree<T>

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

Formats the value using the given formatter.

impl<'a, T: Debug> IntoIterator for &'a Tree<T>

type Item = Node<'a, T>

The type of the elements being iterated over.

type IntoIter = TreeIter<'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: Ord> Ord for Tree<T>

fn cmp(&self, other: &Tree<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<T: PartialEq> PartialEq for Tree<T>

fn eq(&self, other: &Tree<T>) -> bool

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

const 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: PartialOrd> PartialOrd for Tree<T>

fn partial_cmp(&self, other: &Tree<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<T: Eq> Eq for Tree<T>

impl<T> StructuralPartialEq for Tree<T>