Struct xmpp_parsers::Element

source ·

pub struct Element {
    pub prefixes: Prefixes,
    /* private fields */
}

Expand description

A struct representing a DOM Element.

Fields§

§prefixes: Prefixes

Namespace declarations

Implementations§

source §

impl Element

source

pub fn builder<S, NS>(name: S, namespace: NS) -> ElementBuilder
where S: AsRef<str>, NS: Into<String>,

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");

source

pub fn bare<S, NS>(name: S, namespace: NS) -> Element
where S: Into<String>, NS: Into<String>,

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(), "");

source

pub fn name(&self) -> &str

Returns a reference to the local name of this element (that is, without a possible prefix).

source

pub fn ns(&self) -> String

Returns a reference to the namespace of this element.

source

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

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

source

pub fn attrs(&self) -> Attrs<'_>

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);

source

pub fn attrs_mut(&mut self) -> AttrsMut<'_>

Returns an iterator over the attributes of this element, with the value being a mutable reference.

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);

source

pub fn nodes_mut(&mut self) -> IterMut<'_, Node>

Returns an iterator over mutable references to every child node of this element.

source

pub fn children(&self) -> Children<'_>

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);

source

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

Returns an iterator over mutable references to every child element of this element.

source

pub fn texts(&self) -> Texts<'_>

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);

Appends a string as plain text to an Element.

If the last child node of the element is a text node, the string will be appended to it. Otherwise, a new text node will be created.

§Examples

use minidom::Element;

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

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

elem.append_text_node("text");

elem.append_text(" and more text");

assert_eq!(elem.nodes().count(), 1);

source

pub fn append_node(&mut self, node: Node)

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");

source

pub fn text(&self) -> String

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!");

source

pub fn get_child<'a, N, NS>(&self, name: N, namespace: NS) -> Option<&Element>
where N: AsRef<str>, NS: Into<NSChoice<'a>>,

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);

Remove the leading nodes up to the first child element and return it

Trait Implementations§

source §

impl Clone for Element

source §

fn clone(&self) -> Element

Returns a copy of the value. Read more

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

source §

impl FromXml for Element

§

type Builder = ElementFromEvents

A builder type used to construct the element. Read more

source §

fn from_events( qname: (Namespace, NcName), attrs: XmlMap<String>, ) -> Result<<Element as FromXml>::Builder, FromEventsError>

Attempt to initiate the streamed construction of this struct from XML. Read more

source §

The type returned in the event of a conversion error.

source §

fn try_from(elem: Element) -> Result<Subject, FromElementError>

Performs the conversion.

§

type Error = FromElementError

The type returned in the event of a conversion error.

source §

fn try_from(elem: Element) -> Result<Subscribe, FromElementError>

impl Eq for Element

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.

Implementations§

impl Element

pub fn builder<S, NS>(name: S, namespace: NS) -> ElementBuilderwhere S: AsRef<str>, NS: Into<String>,

§Examples

pub fn bare<S, NS>(name: S, namespace: NS) -> Elementwhere S: Into<String>, NS: Into<String>,

§Examples

pub fn name(&self) -> &str

pub fn ns(&self) -> String

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

pub fn attrs(&self) -> Attrs<'_>

§Example

pub fn attrs_mut(&mut self) -> AttrsMut<'_>

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

pub fn is<'a, N, NS>(&self, name: N, namespace: NS) -> boolwhere N: AsRef<str>, NS: Into<NSChoice<'a>>,

§Examples

pub fn has_ns<'a, NS>(&self, namespace: NS) -> boolwhere NS: Into<NSChoice<'a>>,

§Examples

pub fn from_reader<R>(reader: R) -> Result<Element, Error>where R: BufRead,

pub fn from_reader_with_prefixes<R, P>( reader: R, prefixes: P, ) -> Result<Element, Error>where R: BufRead, P: Into<Prefixes>,

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

pub fn write_to_decl<W>(&self, writer: &mut W) -> Result<(), Error>where W: Write,

pub fn to_writer<W>( &self, writer: &mut CustomItemWriter<W, SimpleNamespaces>, ) -> Result<(), Error>where W: Write,

pub fn to_writer_decl<W>( &self, writer: &mut CustomItemWriter<W, SimpleNamespaces>, ) -> Result<(), Error>where W: Write,

pub fn write_to_inner<W>( &self, writer: &mut CustomItemWriter<W, SimpleNamespaces>, ) -> Result<(), Error>where W: Write,

pub fn take_nodes(&mut self) -> Vec<Node>

pub fn nodes(&self) -> Iter<'_, Node>

§Examples

pub fn nodes_mut(&mut self) -> IterMut<'_, Node>

pub fn children(&self) -> Children<'_>

§Examples

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

pub fn texts(&self) -> Texts<'_>

§Examples

pub fn texts_mut(&mut self) -> TextsMut<'_>

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

§Examples

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

§Examples

pub fn append_text<S>(&mut self, text: S)where S: Into<String>,

§Examples

pub fn append_node(&mut self, node: Node)

§Examples

pub fn text(&self) -> String

§Examples

pub fn get_child<'a, N, NS>(&self, name: N, namespace: NS) -> Option<&Element>where N: AsRef<str>, NS: Into<NSChoice<'a>>,

§Examples

pub fn get_child_mut<'a, N, NS>( &mut self, name: N, namespace: NS, ) -> Option<&mut Element>where N: AsRef<str>, NS: Into<NSChoice<'a>>,

pub fn has_child<'a, N, NS>(&self, name: N, namespace: NS) -> boolwhere N: AsRef<str>, NS: Into<NSChoice<'a>>,

§Examples

pub fn remove_child<'a, N, NS>( &mut self, name: N, namespace: NS, ) -> Option<Element>where N: AsRef<str>, NS: Into<NSChoice<'a>>,

§Examples

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

Trait Implementations§

impl Clone for Element

fn clone(&self) -> Element

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

impl Debug for Element

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

impl<'a> From<&'a Element> for String

fn from(elem: &'a Element) -> String

impl From<A> for Element

fn from(elem: A) -> Element

impl From<Abort> for Element

fn from(other: Abort) -> Self

impl From<Action> for Element

fn from(action: Action) -> Element

impl From<Active> for Element

fn from(other: Active) -> Self

impl From<Actor> for Element

fn from(actor: Actor) -> Element

impl From<Affiliation> for Element

fn from(elem: Affiliation) -> Element

impl From<Affiliation> for Element

fn from(elem: Affiliation) -> Element

impl From<Affiliations> for Element

fn from(elem: Affiliations) -> Element

impl From<Affiliations> for Element

fn from(elem: Affiliations) -> Element

Struct xmpp_parsers::Element

pub fn builder<S, NS>(name: S, namespace: NS) -> ElementBuilder
where S: AsRef<str>, NS: Into<String>,

pub fn bare<S, NS>(name: S, namespace: NS) -> Element
where S: Into<String>, NS: Into<String>,

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

pub fn is<'a, N, NS>(&self, name: N, namespace: NS) -> bool
where N: AsRef<str>, NS: Into<NSChoice<'a>>,

pub fn has_ns<'a, NS>(&self, namespace: NS) -> bool
where NS: Into<NSChoice<'a>>,

pub fn from_reader<R>(reader: R) -> Result<Element, Error>
where R: BufRead,

pub fn from_reader_with_prefixes<R, P>( reader: R, prefixes: P, ) -> Result<Element, Error>
where R: BufRead, P: Into<Prefixes>,

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

pub fn write_to_decl<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

pub fn to_writer<W>( &self, writer: &mut CustomItemWriter<W, SimpleNamespaces>, ) -> Result<(), Error>
where W: Write,

pub fn to_writer_decl<W>( &self, writer: &mut CustomItemWriter<W, SimpleNamespaces>, ) -> Result<(), Error>
where W: Write,

pub fn write_to_inner<W>( &self, writer: &mut CustomItemWriter<W, SimpleNamespaces>, ) -> Result<(), Error>
where W: Write,

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

pub fn append_text<S>(&mut self, text: S)
where S: Into<String>,

pub fn get_child<'a, N, NS>(&self, name: N, namespace: NS) -> Option<&Element>
where N: AsRef<str>, NS: Into<NSChoice<'a>>,

pub fn get_child_mut<'a, N, NS>( &mut self, name: N, namespace: NS, ) -> Option<&mut Element>
where N: AsRef<str>, NS: Into<NSChoice<'a>>,

pub fn has_child<'a, N, NS>(&self, name: N, namespace: NS) -> bool
where N: AsRef<str>, NS: Into<NSChoice<'a>>,

pub fn remove_child<'a, N, NS>( &mut self, name: N, namespace: NS, ) -> Option<Element>
where N: AsRef<str>, NS: Into<NSChoice<'a>>,