Enum NodeEdge 

pub enum NodeEdge {
    Start(Node),
    End(Node),
}

Node edges.

Used by Xot::traverse and Xot::reverse_traverse.

Variants

Start(Node)

The start edge of a node. In case of an element this is the start tag. In case of document this is the start of the document.

End(Node)

The end edge of a node. In case of an element this is the end tag. In case of document this is the end of the document. For any other values, the end edge occurs immediately after the start edge.

Implementations

impl NodeEdge

pub fn node(self) -> Node

Returns the starting or ending node.

Examples

let mut xot = xot::Xot::new();
let root = xot.parse("<p><a/><b><c/></b></p>").unwrap();
let p = xot.document_element(root).unwrap();
let a = xot.first_child(p).unwrap();
let b = xot.next_sibling(a).unwrap();
let c = xot.first_child(b).unwrap();
let traversed: Vec<xot::Node> = xot
    .traverse(p)
    .map(|edge| edge.node())
    .collect();
assert_eq!(traversed, &[p, a, a, b, c, c, b, p]);

pub fn next(self, xot: &Xot) -> Option<Self>

Returns the next edge in depth-first traversal order.

Examples

let mut xot = xot::Xot::new();
let root = xot.parse("<p><a/><b><c/><d/><e/></b><f><g/><h/></f></p>").unwrap();
let traversed: Vec<xot::NodeEdge> = xot.traverse(root).collect();

let mut current = xot::NodeEdge::Start(root);
let mut traversed2 = vec![current];
while let Some(next) = current.next(&xot) {
    if let xot::NodeEdge::End(node) = current {
        // You can use `&mut Xot` inside the loop.
        xot.remove(node);
    }

    traversed2.push(next);
    current = next;
}
assert_eq!(traversed, traversed2);

pub fn previous(self, xot: &Xot) -> Option<Self>

Returns the previous edge in depth-first traversal order.

Examples

let mut xot = xot::Xot::new();
let root = xot.parse("<p><a/><b><c/><d/><e/></b><f><g/><h/></f></p>").unwrap();
let rev_traversed: Vec<xot::NodeEdge> = xot.reverse_traverse(root).collect();

let mut current = xot::NodeEdge::End(root);
let mut rev_traversed2 = vec![current];
while let Some(next) = current.previous(&xot) {
    if let xot::NodeEdge::Start(node) = current {
        // You can use `&mut Xot` inside the loop.
        xot.remove(node);
    }

    rev_traversed2.push(next);
    current = next;
}
assert_eq!(rev_traversed, rev_traversed2);

Trait Implementations

impl Clone for NodeEdge

fn clone(&self) -> NodeEdge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeEdge

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

Formats the value using the given formatter.

impl Hash for NodeEdge

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for NodeEdge

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

impl Eq for NodeEdge

impl StructuralPartialEq for NodeEdge