Struct minidom::element::Element

pub struct Element { /* fields omitted */ }

A struct representing a DOM Element.

Methods

impl Element

fn builder<S: Into<String>>(name: S) -> ElementBuilder

Return a builder for an Element with the given name.

Examples

use minidom::Element;

let elem = Element::builder("name")
                   .ns("namespace")
                   .attr("name", "value")
                   .append("inner")
                   .build();

assert_eq!(elem.name(), "name");
assert_eq!(elem.ns(), Some("namespace"));
assert_eq!(elem.attr("name"), Some("value"));
assert_eq!(elem.attr("inexistent"), None);
assert_eq!(elem.text(), "inner");

fn bare<S: Into<String>>(name: S) -> Element

Returns a bare minimum Element with this name.

Examples

use minidom::Element;

let bare = Element::bare("name");

assert_eq!(bare.name(), "name");
assert_eq!(bare.ns(), None);
assert_eq!(bare.attr("name"), None);
assert_eq!(bare.text(), "");

fn name(&self) -> &str

Returns a reference to the name of this element.

fn ns(&self) -> Option<&str>

Returns a reference to the namespace of this element, if it has one, else None.

fn attr(&self, name: &str) -> Option<&str>

Returns a reference to the value of the given attribute, if it exists, else None.

fn set_attr<S: Into<String>, V: IntoAttributeValue>(&mut self, name: S, val: V)

Modifies the value of an attribute.

fn is<N: AsRef<str>, NS: AsRef<str>>(&self, name: N, namespace: NS) -> bool

Returns whether the element has the given name and namespace.

Examples

use minidom::Element;

let elem = Element::builder("name").ns("namespace").build();

assert_eq!(elem.is("name", "namespace"), true);
assert_eq!(elem.is("name", "wrong"), false);
assert_eq!(elem.is("wrong", "namespace"), false);
assert_eq!(elem.is("wrong", "wrong"), false);

fn from_reader<R: Read>(reader: &mut EventReader<R>) -> Result<Element, Error>

Parse a document from an EventReader.

fn write_to<W: Write>(&self, writer: &mut EventWriter<W>) -> Result<(), Error>

Output a document to an EventWriter.

fn children<'a>(&'a self) -> Children<'a>

Returns an iterator over references to the children of this element.

Examples

use minidom::Element;

let elem: Element = "<root><child1 /><child2 /><child3 /></root>".parse().unwrap();

let mut iter = elem.children();
assert_eq!(iter.next().unwrap().name(), "child1");
assert_eq!(iter.next().unwrap().name(), "child2");
assert_eq!(iter.next().unwrap().name(), "child3");
assert_eq!(iter.next(), None);

fn children_mut<'a>(&'a mut self) -> ChildrenMut<'a>

Returns an iterator over mutable references to the children of this element.

fn append_child(&mut self, child: Element) -> &mut Element

Appends a child node to the Element, returning the appended node.

Examples

use minidom::Element;

let mut elem = Element::bare("root");

assert_eq!(elem.children().count(), 0);

elem.append_child(Element::bare("child"));

{
    let mut iter = elem.children();
    assert_eq!(iter.next().unwrap().name(), "child");
    assert_eq!(iter.next(), None);
}

let child = elem.append_child(Element::bare("new"));

assert_eq!(child.name(), "new");

fn append_text_node<S: Into<String>>(&mut self, child: S)

Appends a text node to an Element.

Examples

use minidom::Element;

let mut elem = Element::bare("node");

assert_eq!(elem.text(), "");

elem.append_text_node("text");

assert_eq!(elem.text(), "text");

fn append_node(&mut self, node: Node)

Appends a node to an Element.

Examples

use minidom::{Element, Node};

let mut elem = Element::bare("node");

elem.append_node(Node::Text("hello".to_owned()));

assert_eq!(elem.text(), "hello");

fn text(&self) -> String

Returns the concatenation of all text nodes in the Element.

Examples

use minidom::Element;

let elem: Element = "<node>hello, world!</node>".parse().unwrap();

assert_eq!(elem.text(), "hello, world!");

fn get_child<N: AsRef<str>, NS: AsRef<str>>(
    &self,
    name: N,
    namespace: NS
) -> Option<&Element>

Returns a reference to the first child element with the specific name and namespace, if it exists in the direct descendants of this Element, else returns None.

Examples

use minidom::Element;

let elem: Element = r#"<node xmlns="ns"><a /><a xmlns="other_ns" /><b /></node>"#.parse().unwrap();

assert!(elem.get_child("a", "ns").unwrap().is("a", "ns"));
assert!(elem.get_child("a", "other_ns").unwrap().is("a", "other_ns"));
assert!(elem.get_child("b", "ns").unwrap().is("b", "ns"));
assert_eq!(elem.get_child("c", "ns"), None);
assert_eq!(elem.get_child("b", "other_ns"), None);
assert_eq!(elem.get_child("a", "inexistent_ns"), None);

fn get_child_mut<N: AsRef<str>, NS: AsRef<str>>(
    &mut self,
    name: N,
    namespace: NS
) -> Option<&mut Element>

Returns a mutable reference to the first child element with the specific name and namespace, if it exists in the direct descendants of this Element, else returns None.

fn has_child<N: AsRef<str>, NS: AsRef<str>>(
    &self,
    name: N,
    namespace: NS
) -> bool

Returns whether a specific child with this name and namespace exists in the direct descendants of the Element.

Examples

use minidom::Element;

let elem: Element = r#"<node xmlns="ns"><a /><a xmlns="other_ns" /><b /></node>"#.parse().unwrap();

assert_eq!(elem.has_child("a", "other_ns"), true);
assert_eq!(elem.has_child("a", "ns"), true);
assert_eq!(elem.has_child("a", "inexistent_ns"), false);
assert_eq!(elem.has_child("b", "ns"), true);
assert_eq!(elem.has_child("b", "other_ns"), false);
assert_eq!(elem.has_child("b", "inexistent_ns"), false);

Trait Implementations

impl Clone for Element

fn clone(&self) -> Element

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Eq for Element

impl PartialEq for Element

fn eq(&self, other: &Element) -> 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 !=.

impl Debug for Element

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl FromStr for Element

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Element, Error>

Parses a string s to return a value of this type.

impl IntoElements for Element

fn into_elements(self, emitter: &mut ElementEmitter)

Emits this as a sequence of text nodes and Elements.