[−][src]Struct minidom::element::Element
A struct representing a DOM Element.
Implementations
impl Element
[src]
pub fn builder<S: AsRef<str>, NS: Into<String>>(
name: S,
namespace: NS
) -> ElementBuilder
[src]
name: S,
namespace: NS
) -> ElementBuilder
Return a builder for an Element
with the given name
.
Examples
use minidom::Element; let elem = Element::builder("name", "namespace") .attr("name", "value") .append("inner") .build(); assert_eq!(elem.name(), "name"); assert_eq!(elem.ns(), "namespace".to_owned()); assert_eq!(elem.attr("name"), Some("value")); assert_eq!(elem.attr("inexistent"), None); assert_eq!(elem.text(), "inner");
pub fn bare<S: Into<String>, NS: Into<String>>(
name: S,
namespace: NS
) -> Element
[src]
name: S,
namespace: NS
) -> Element
Returns a bare minimum Element
with this name.
Examples
use minidom::Element; let bare = Element::bare("name", "namespace"); assert_eq!(bare.name(), "name"); assert_eq!(bare.ns(), "namespace"); assert_eq!(bare.attr("name"), None); assert_eq!(bare.text(), "");
pub fn name(&self) -> &str
[src]
Returns a reference to the local name of this element (that is, without a possible prefix).
pub fn ns(&self) -> String
[src]
Returns a reference to the namespace of this element, if it has one, else None
.
pub fn attr(&self, name: &str) -> Option<&str>
[src]
Returns a reference to the value of the given attribute, if it exists, else None
.
pub fn attrs(&self) -> Attrs<'_>ⓘ
[src]
Returns an iterator over the attributes of this element.
Example
use minidom::Element; let elm: Element = "<elem xmlns=\"ns1\" a=\"b\" />".parse().unwrap(); let mut iter = elm.attrs(); assert_eq!(iter.next().unwrap(), ("a", "b")); assert_eq!(iter.next(), None);
pub fn attrs_mut(&mut self) -> AttrsMut<'_>ⓘ
[src]
Returns an iterator over the attributes of this element, with the value being a mutable reference.
pub fn set_attr<S: Into<String>, V: IntoAttributeValue>(
&mut self,
name: S,
val: V
)
[src]
&mut self,
name: S,
val: V
)
Modifies the value of an attribute.
pub fn is<'a, N: AsRef<str>, NS: Into<NSChoice<'a>>>(
&self,
name: N,
namespace: NS
) -> bool
[src]
&self,
name: N,
namespace: NS
) -> bool
Returns whether the element has the given name and namespace.
Examples
use minidom::{Element, NSChoice}; let elem = Element::builder("name", "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); assert_eq!(elem.is("name", NSChoice::OneOf("namespace")), true); assert_eq!(elem.is("name", NSChoice::OneOf("foo")), false); assert_eq!(elem.is("name", NSChoice::AnyOf(&["foo", "namespace"])), true); assert_eq!(elem.is("name", NSChoice::Any), true);
pub fn has_ns<'a, NS: Into<NSChoice<'a>>>(&self, namespace: NS) -> bool
[src]
Returns whether the element has the given namespace.
Examples
use minidom::{Element, NSChoice}; let elem = Element::builder("name", "namespace").build(); assert_eq!(elem.has_ns("namespace"), true); assert_eq!(elem.has_ns("wrong"), false); assert_eq!(elem.has_ns(NSChoice::OneOf("namespace")), true); assert_eq!(elem.has_ns(NSChoice::OneOf("foo")), false); assert_eq!(elem.has_ns(NSChoice::AnyOf(&["foo", "namespace"])), true); assert_eq!(elem.has_ns(NSChoice::Any), true);
pub fn from_reader<R: BufRead>(reader: &mut EventReader<R>) -> Result<Element>
[src]
Parse a document from an EventReader
.
pub fn write_to<W: Write>(&self, writer: &mut W) -> Result<()>
[src]
Output a document to a Writer
.
pub fn write_to_decl<W: Write>(&self, writer: &mut W) -> Result<()>
[src]
Output a document to a Writer
.
pub fn to_writer<W: Write>(&self, writer: &mut EventWriter<W>) -> Result<()>
[src]
Output the document to quick-xml Writer
pub fn to_writer_decl<W: Write>(
&self,
writer: &mut EventWriter<W>
) -> Result<()>
[src]
&self,
writer: &mut EventWriter<W>
) -> Result<()>
Output the document to quick-xml Writer
pub fn write_to_inner<W: Write>(
&self,
writer: &mut EventWriter<W>,
all_prefixes: &mut BTreeMap<Option<String>, String>
) -> Result<()>
[src]
&self,
writer: &mut EventWriter<W>,
all_prefixes: &mut BTreeMap<Option<String>, String>
) -> Result<()>
Like write_to()
but without the <?xml?>
prelude
pub fn nodes(&self) -> Nodes<'_>
[src]
Returns an iterator over references to every child node of this element.
Examples
use minidom::Element; let elem: Element = "<root xmlns=\"ns1\">a<c1 />b<c2 />c</root>".parse().unwrap(); let mut iter = elem.nodes(); assert_eq!(iter.next().unwrap().as_text().unwrap(), "a"); assert_eq!(iter.next().unwrap().as_element().unwrap().name(), "c1"); assert_eq!(iter.next().unwrap().as_text().unwrap(), "b"); assert_eq!(iter.next().unwrap().as_element().unwrap().name(), "c2"); assert_eq!(iter.next().unwrap().as_text().unwrap(), "c"); assert_eq!(iter.next(), None);
pub fn nodes_mut(&mut self) -> NodesMut<'_>
[src]
Returns an iterator over mutable references to every child node of this element.
pub fn children(&self) -> Children<'_>ⓘ
[src]
Returns an iterator over references to every child element of this element.
Examples
use minidom::Element; let elem: Element = "<root xmlns=\"ns1\">hello<child1 xmlns=\"ns1\"/>this<child2 xmlns=\"ns1\"/>is<child3 xmlns=\"ns1\"/>ignored</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);
pub fn children_mut(&mut self) -> ChildrenMut<'_>ⓘNotable traits for ChildrenMut<'a>
impl<'a> Iterator for ChildrenMut<'a> type Item = &'a mut Element;
[src]
Notable traits for ChildrenMut<'a>
impl<'a> Iterator for ChildrenMut<'a> type Item = &'a mut Element;
Returns an iterator over mutable references to every child element of this element.
pub fn texts(&self) -> Texts<'_>ⓘ
[src]
Returns an iterator over references to every text node of this element.
Examples
use minidom::Element; let elem: Element = "<root xmlns=\"ns1\">hello<c /> world!</root>".parse().unwrap(); let mut iter = elem.texts(); assert_eq!(iter.next().unwrap(), "hello"); assert_eq!(iter.next().unwrap(), " world!"); assert_eq!(iter.next(), None);
pub fn texts_mut(&mut self) -> TextsMut<'_>ⓘ
[src]
Returns an iterator over mutable references to every text node of this element.
pub fn append_child(&mut self, child: Element) -> &mut Element
[src]
Appends a child node to the Element
, returning the appended node.
Examples
use minidom::Element; let mut elem = Element::bare("root", "ns1"); assert_eq!(elem.children().count(), 0); elem.append_child(Element::bare("child", "ns1")); { 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", "ns1")); assert_eq!(child.name(), "new");
pub fn append_text_node<S: Into<String>>(&mut self, child: S)
[src]
Appends a text node to an Element
.
Examples
use minidom::Element; let mut elem = Element::bare("node", "ns1"); assert_eq!(elem.text(), ""); elem.append_text_node("text"); assert_eq!(elem.text(), "text");
pub fn append_node(&mut self, node: Node)
[src]
Appends a node to an Element
.
Examples
use minidom::{Element, Node}; let mut elem = Element::bare("node", "ns1"); elem.append_node(Node::Text("hello".to_owned())); assert_eq!(elem.text(), "hello");
pub fn text(&self) -> String
[src]
Returns the concatenation of all text nodes in the Element
.
Examples
use minidom::Element; let elem: Element = "<node xmlns=\"ns1\">hello,<split /> world!</node>".parse().unwrap(); assert_eq!(elem.text(), "hello, world!");
pub fn get_child<'a, N: AsRef<str>, NS: Into<NSChoice<'a>>>(
&self,
name: N,
namespace: NS
) -> Option<&Element>
[src]
&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, NSChoice}; 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);
pub fn get_child_mut<'a, N: AsRef<str>, NS: Into<NSChoice<'a>>>(
&mut self,
name: N,
namespace: NS
) -> Option<&mut Element>
[src]
&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
.
pub fn has_child<'a, N: AsRef<str>, NS: Into<NSChoice<'a>>>(
&self,
name: N,
namespace: NS
) -> bool
[src]
&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, NSChoice}; 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);
pub fn remove_child<'a, N: AsRef<str>, NS: Into<NSChoice<'a>>>(
&mut self,
name: N,
namespace: NS
) -> Option<Element>
[src]
&mut self,
name: N,
namespace: NS
) -> Option<Element>
Removes the first child with this name and namespace, if it exists, and returns an
Option<Element>
containing this child if it succeeds.
Returns None
if no child matches this name and namespace.
Examples
use minidom::{Element, NSChoice}; let mut elem: Element = r#"<node xmlns="ns"><a /><a xmlns="other_ns" /><b /></node>"#.parse().unwrap(); assert!(elem.remove_child("a", "ns").unwrap().is("a", "ns")); assert!(elem.remove_child("a", "ns").is_none()); assert!(elem.remove_child("inexistent", "inexistent").is_none());
Trait Implementations
impl Clone for Element
[src]
impl Debug for Element
[src]
impl Eq for Element
[src]
impl FromStr for Element
[src]
type Err = Error
The associated error which can be returned from parsing.
pub fn from_str(s: &str) -> Result<Element>
[src]
impl PartialEq<Element> for Element
[src]
pub fn eq(&self, other: &Self) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl StructuralEq for Element
[src]
Auto Trait Implementations
impl RefUnwindSafe for Element
[src]
impl Send for Element
[src]
impl Sync for Element
[src]
impl Unpin for Element
[src]
impl UnwindSafe for Element
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,