Enum minidom::node::Node

pub enum Node {
    Element(Element),
    Text(String),
}

A node in an element tree.

Variants

Element(Element)

An Element.

Text(String)

A text node.

Implementations

impl Node

pub fn as_element(&self) -> Option<&Element>

Turns this into a reference to an Element if this is an element node. Else this returns None.

Examples

use minidom::Node;

let elm = Node::Element("<meow xmlns=\"ns1\"/>".parse().unwrap());
let txt = Node::Text("meow".to_owned());

assert_eq!(elm.as_element().unwrap().name(), "meow");
assert_eq!(txt.as_element(), None);

pub fn as_element_mut(&mut self) -> Option<&mut Element>

Turns this into a mutable reference of an Element if this is an element node. Else this returns None.

Examples

use minidom::Node;

let mut elm = Node::Element("<meow xmlns=\"ns1\"/>".parse().unwrap());
let mut txt = Node::Text("meow".to_owned());

assert_eq!(elm.as_element_mut().unwrap().name(), "meow");
assert_eq!(txt.as_element_mut(), None);

pub fn into_element(self) -> Option<Element>

Turns this into an Element, consuming self, if this is an element node. Else this returns None.

Examples

use minidom::Node;

let elm = Node::Element("<meow xmlns=\"ns1\"/>".parse().unwrap());
let txt = Node::Text("meow".to_owned());

assert_eq!(elm.into_element().unwrap().name(), "meow");
assert_eq!(txt.into_element(), None);

pub fn as_text(&self) -> Option<&str>

Turns this into an &str if this is a text node. Else this returns None.

Examples

use minidom::Node;

let elm = Node::Element("<meow xmlns=\"ns1\"/>".parse().unwrap());
let txt = Node::Text("meow".to_owned());

assert_eq!(elm.as_text(), None);
assert_eq!(txt.as_text().unwrap(), "meow");

pub fn as_text_mut(&mut self) -> Option<&mut String>

Turns this into an &mut String if this is a text node. Else this returns None.

Examples

use minidom::Node;

let mut elm = Node::Element("<meow xmlns=\"ns1\"/>".parse().unwrap());
let mut txt = Node::Text("meow".to_owned());

assert_eq!(elm.as_text_mut(), None);
{
    let text_mut = txt.as_text_mut().unwrap();
    assert_eq!(text_mut, "meow");
    text_mut.push_str("zies");
    assert_eq!(text_mut, "meowzies");
}
assert_eq!(txt.as_text().unwrap(), "meowzies");

pub fn into_text(self) -> Option<String>

Turns this into an String, consuming self, if this is a text node. Else this returns None.

Examples

use minidom::Node;

let elm = Node::Element("<meow xmlns=\"ns1\"/>".parse().unwrap());
let txt = Node::Text("meow".to_owned());

assert_eq!(elm.into_text(), None);
assert_eq!(txt.into_text().unwrap(), "meow");

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for Node

fn from(s: &'a str) -> Node

Converts to this type from the input type.

impl From<ElementBuilder> for Node

fn from(builder: ElementBuilder) -> Node

Converts to this type from the input type.

impl<I> From<I> for Nodewhere I: Into<Element>,

fn from(elm: I) -> Node

Converts to this type from the input type.

impl From<String> for Node

fn from(s: String) -> Node

Converts to this type from the input type.

impl PartialEq<Node> for Node

fn eq(&self, other: &Self) -> 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 Eq for Node

impl StructuralEq for Node