Enum DepthFirstSequenceError 

pub enum DepthFirstSequenceError {
    NonZeroRootDepth,
    DepthIncreaseGreaterThanOne {
        depth: usize,
        succeeding_depth: usize,
    },
}

A depth first sequence, or DepthFirstSequence is simply a sequence of (usize, T) tuples corresponding to (depth, value) pairs of nodes of a tree which are ordered by the depth-first traversal order.

Therefore, not all IntoIterator<Item = (usize, T)> types satisfy the depth-first sequence requirement. The invalid sequences are represented by the DepthFirstSequenceError type.

Variants

NonZeroRootDepth

The first element of the depth-first sequence must be the root with depth 0. Therefore, any sequence with a first element having a non-zero depth leads to this error.

Note that empty sequences are valid and represent an empty tree.

DepthIncreaseGreaterThanOne

While traversing a tree in depth first order, we

• either move one level down to access the child (depth = previous depth + 1)
• or stay at the same level to access the sibling to the right (depth = previous depth)
• or move up and then right to access the next child of an ancestor (depth < previous depth)

This list represents valid depth transition. However, we never

• move n > 1 level down (depth > previous depth + 1)

This leaves a gap in the depth-first traversal, and hance, is the invalid case that this error variant represents.

Fields

depth: usize

Depth of the node where the error is observed.

succeeding_depth: usize

Depth succeeding the depth which is at least two more than the previous.

Trait Implementations

impl Clone for DepthFirstSequenceError

fn clone(&self) -> DepthFirstSequenceError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DepthFirstSequenceError

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

Formats the value using the given formatter.

impl Eq for DepthFirstSequenceError

impl PartialEq for DepthFirstSequenceError

fn eq(&self, other: &DepthFirstSequenceError) -> 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 StructuralPartialEq for DepthFirstSequenceError