Struct mt_dom::patch::TreePath

pub struct TreePath {
    pub path: Vec<usize>,
}

Describe the path traversal of a Node starting from the root node

The figure below shows node_idx in a depth first traversal.

           .─.
          ( 0 )
           `-'
          /   \
         /     \
        /       \
       ▼         ▼
      .─.         .─.
     ( 1 )       ( 4 )
      `-'         `-'
     /  \          | \ '.
    /    \         |  \  '.
   ▼      ▼        |   \   '.
 .─.      .─.      ▼    ▼     ▼
( 2 )    ( 3 )    .─.   .─.   .─.
 `─'      `─'    ( 5 ) ( 6 ) ( 7 )
                  `─'   `─'   `─'

The figure below shows the index of each child node relative to their parent node

            .─.
           ( 0 )
            `-'
           /   \
          /     \
         /       \
        ▼         ▼
       .─.         .─.
      ( 0 )       ( 1 )
       `-'         `-'
      /  \          | \ '.
     /    \         |  \  '.
    ▼      ▼        |   \   '.
  .─.      .─.      ▼    ▼     ▼
 ( 0 )    ( 1 )    .─.   .─.   .─.
  `─'      `─'    ( 0 ) ( 1 ) ( 2 )
                   `─'   `─'   `─'

The equivalent idx and path are as follows:

   0 = []
   1 = [0]
   2 = [0,0]
   3 = [0,1]
   4 = [1]
   5 = [1,0]
   6 = [1,1]
   7 = [1,2]

Fields

path: Vec<usize>

An array of child index at each level of the dom tree. The children of the nodes at each child index is traverse at each traversal the first element of path is removed until the path becomes empty. If the path has become empty the node is said to be found.

Empty path means root node

Implementations

impl TreePath

pub fn new(path: impl IntoIterator<Item = usize>) -> Self

create a TreePath with node index node_idx and traversal path path

pub fn root() -> Self

create a TreePath which starts at empty vec which is the root node of a DOM tree

pub fn push(&mut self, node_idx: usize)

add a path node idx

pub fn traverse(&self, node_idx: usize) -> Self

create a new TreePath with an added node_index This is used for traversing into child elements

pub fn backtrack(&self) -> Self

backtrack to the parent node path

pub fn remove_first(&mut self) -> usize

remove first node index of this treepath Everytime a node is traversed, the first element should be removed until no more index is in this path

pub fn pluck(&mut self) -> usize

pluck the next in line node index in this treepath

pub fn is_empty(&self) -> bool

returns tree if the path is empty This is used for checking if the path has been traversed

pub fn find_node_by_path<'a, Ns, Tag, Leaf, Att, Val>( &self, node: &'a Node<Ns, Tag, Leaf, Att, Val> ) -> Option<&'a Node<Ns, Tag, Leaf, Att, Val>>

where Ns: PartialEq + Clone + Debug, Tag: PartialEq + Clone + Debug, Leaf: PartialEq + Clone + Debug, Att: PartialEq + Clone + Debug, Val: PartialEq + Clone + Debug,

find the node using the path of this tree path

Trait Implementations

impl Clone for TreePath

fn clone(&self) -> TreePath

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TreePath

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

Formats the value using the given formatter.

impl<const N: usize> From<[usize; N]> for TreePath

fn from(array: [usize; N]) -> Self

Converts to this type from the input type.

impl From<Vec<usize>> for TreePath

fn from(vec: Vec<usize>) -> Self

Converts to this type from the input type.

impl Ord for TreePath

fn cmp(&self, other: &TreePath) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for TreePath

fn eq(&self, other: &TreePath) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for TreePath

fn partial_cmp(&self, other: &TreePath) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for TreePath

impl StructuralPartialEq for TreePath