Enum Node 

pub enum Node<'d> {
    Root(Root<'d>),
    Element(Element<'d>),
    Attribute(Attribute<'d>),
    Text(Text<'d>),
    Comment(Comment<'d>),
    Namespace(Namespace<'d>),
    ProcessingInstruction(ProcessingInstruction<'d>),
}

Any of the various types of nodes found in an XML document.

Variants

Root(Root<'d>)

Element(Element<'d>)

Attribute(Attribute<'d>)

Text(Text<'d>)

Comment(Comment<'d>)

Namespace(Namespace<'d>)

ProcessingInstruction(ProcessingInstruction<'d>)

Implementations

impl<'d> Node<'d>

pub fn document(&self) -> Document<'d>

The document to which this node belongs.

pub fn prefixed_name(&self) -> Option<String>

The name of the node, including a prefix that corresponds to the namespace, if any.

pub fn expanded_name(&self) -> Option<QName<'d>>

Returns the expanded name of the node, if any.

pub fn parent(&self) -> Option<Node<'d>>

Returns the parent of the node, if any.

pub fn children(&self) -> Vec<Node<'d>>

Returns the children of the node, if any.

pub fn preceding_siblings(&self) -> Vec<Node<'d>>

Returns the nodes with the same parent that occur before this node.

pub fn following_siblings(&self) -> Vec<Node<'d>>

Returns the nodes with the same parent that occur after this node.

pub fn string_value(&self) -> String

Returns the string value of this node.

pub fn root(self) -> Option<Root<'d>>

pub fn element(self) -> Option<Element<'d>>

pub fn attribute(self) -> Option<Attribute<'d>>

pub fn text(self) -> Option<Text<'d>>

pub fn comment(self) -> Option<Comment<'d>>

pub fn processing_instruction(self) -> Option<ProcessingInstruction<'d>>

pub fn namespace(self) -> Option<Namespace<'d>>

Trait Implementations

impl<'d> Clone for Node<'d>

fn clone(&self) -> Node<'d>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'d> Debug for Node<'d>

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

Formats the value using the given formatter.

impl<'d> Extend<Node<'d>> for Nodeset<'d>

fn extend<I>(&mut self, iter: I)

where I: IntoIterator<Item = Node<'d>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'d> From<Attribute<'d>> for Node<'d>

fn from(v: Attribute<'d>) -> Node<'d>

Converts to this type from the input type.

impl<'d> From<Comment<'d>> for Node<'d>

fn from(v: Comment<'d>) -> Node<'d>

Converts to this type from the input type.

impl<'d> From<Element<'d>> for Node<'d>

fn from(v: Element<'d>) -> Node<'d>

Converts to this type from the input type.

impl<'d> From<ProcessingInstruction<'d>> for Node<'d>

fn from(v: ProcessingInstruction<'d>) -> Node<'d>

Converts to this type from the input type.

impl<'d> From<Root<'d>> for Node<'d>

fn from(v: Root<'d>) -> Node<'d>

Converts to this type from the input type.

impl<'d> From<Text<'d>> for Node<'d>

fn from(v: Text<'d>) -> Node<'d>

Converts to this type from the input type.

impl<'d> FromIterator<Node<'d>> for Nodeset<'d>

fn from_iter<I>(iterator: I) -> Nodeset<'d>

where I: IntoIterator<Item = Node<'d>>,

Creates a value from an iterator.

impl<'d> FromIterator<Node<'d>> for OrderedNodes<'d>

fn from_iter<I>(iterator: I) -> OrderedNodes<'d>

where I: IntoIterator<Item = Node<'d>>,

Creates a value from an iterator.

impl<'d> Hash for Node<'d>

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<'d> Into<Node<'d>> for ChildOfElement<'d>

fn into(self) -> Node<'d>

Converts this type into the (usually inferred) input type.

impl<'d> Into<Node<'d>> for ChildOfRoot<'d>

fn into(self) -> Node<'d>

Converts this type into the (usually inferred) input type.

impl<'d> Into<Node<'d>> for ParentOfChild<'d>

fn into(self) -> Node<'d>

Converts this type into the (usually inferred) input type.

impl<'d> PartialEq for Node<'d>

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

impl<'d> Eq for Node<'d>

impl<'d> StructuralPartialEq for Node<'d>