Struct mt_dom::patch::TreePath

pub struct TreePath {
    pub node_idx: usize,
    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 = [0]
   1 = [0,0]
   2 = [0,0,0]
   3 = [0,0,1]
   4 = [0,1]
   5 = [0,1,0]
   6 = [0,1,1]
   7 = [0,1,2]

Fields

node_idx: usize

The node_idx is the index when traversing the DOM tree depth first. 0 is the root node, 1 is the first child of the root node, 2 is the first child of first child

path: Vec<usize>

an alternative path vector, where it specifies the first element is the index of the root node which is always 0 the second element is the index of the child to traverse to and so on. Given a DOM tree where node_idx and path was derived from, we can verify that node_idx and path point to the same node. The advantage of using this is that this doesn’t need to traverse nodes that are not relevant. Traversal operation complexity is O(log n)

Implementations

impl TreePath

pub fn new() -> Self

create a tree path which starts at node_idx 0 and traversal path path at vec![0].

pub fn start_at(node_idx: usize, path: Vec<usize>) -> Self

create a TreePath with node index node_idx and traversal path path

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

add a path node idx

pub fn find_node_by_path<'a, NS, TAG, ATT, VAL>(
    &self,
    node: &'a Node<NS, TAG, ATT, VAL>
) -> Option<&'a Node<NS, TAG, ATT, VAL>> where
    NS: PartialEq + Clone + Debug,
    TAG: PartialEq + Clone + Debug,
    ATT: PartialEq + Clone + Debug,
    VAL: PartialEq + Clone + Debug, 

find the node using the path of this tree path

pub fn find_node_by_node_idx<'a, NS, TAG, ATT, VAL>(
    &self,
    node: &'a Node<NS, TAG, ATT, VAL>
) -> Option<&'a Node<NS, TAG, ATT, VAL>> where
    NS: PartialEq + Clone + Debug,
    TAG: PartialEq + Clone + Debug,
    ATT: PartialEq + Clone + Debug,
    VAL: PartialEq + Clone + Debug, 

find the node using the node_idx 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 PartialEq<TreePath> 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: &TreePath) -> bool

This method tests for !=.

impl StructuralPartialEq for TreePath