Enum Xml 

pub enum Xml<'a> {
    Element {
        name: Cow<'a, str>,
        attrs: HashMap<Cow<'a, str>, Cow<'a, str>>,
        children: Vec<Xml<'a>>,
    },
    Text(Cow<'a, str>),
}

XML node.

Variants

Element

XML element.

Fields

name: Cow<'a, str>

Element name.

attrs: HashMap<Cow<'a, str>, Cow<'a, str>>

Element attributes.

children: Vec<Xml<'a>>

Element children.

Text(Cow<'a, str>)

XML text content.

Implementations

impl<'a> Xml<'a>

pub fn text(text: impl Into<Cow<'a, str>>) -> Self

Create a new text node.

Examples

let node = Xml::text("hello");
assert_eq!(node.content(), Some("hello"));

pub fn element(name: impl Into<Cow<'a, str>>) -> Self

Create a new element node.

Examples

let node = Xml::element("div");
assert_eq!(node.name(), Some("div"));

pub fn is_text(&self) -> bool

Check if the node is a text node.

pub fn is_element(&self) -> bool

Check if the node is an element.

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

Get element name.

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

Get element attribute.

pub fn attr_mut(&mut self, key: &str) -> Option<&mut String>

Get mutable reference to element attribute.

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

Get text content.

pub fn with_attr( self, key: impl Into<Cow<'a, str>>, value: impl Into<Cow<'a, str>>, ) -> Self

Add attribute to element.

Examples

let element = Xml::element("div")
    .with_attr("id", "main")
    .with_attr("class", "container");

assert_eq!(element.attr("id"), Some("main"));
assert_eq!(element.attr("class"), Some("container"));

pub fn with_child(self, child: Self) -> Self

Add child to element.

Examples

let element = Xml::element("div")
    .with_child(Xml::text("Hello, world!"));

assert_eq!(element.children().count(), 1);
assert_eq!(element.children().next().unwrap().content(), Some("Hello, world!"));

pub fn children(&self) -> Iter<'_, Xml<'_>>

Iterate over direct children.

Examples

let xml = xmlite::document("<a><b></b><c></c></a>").unwrap();
let child = xml.children().find(|e| e.name() == Some("c"));
assert_eq!(child, Some(&Xml::element("c")));

pub fn children_mut<'b>(&'b mut self) -> IterMut<'b, Xml<'a>>

Iterate over direct children, mutably.

pub fn descendants(&self) -> impl Iterator<Item = &Xml<'_>>

Iterate over descendants of this node (excludes self).

Trait Implementations

impl<'a> Clone for Xml<'a>

fn clone(&self) -> Xml<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Xml<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Xml<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Xml<'a>

fn eq(&self, other: &Xml<'a>) -> 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<'a> StructuralPartialEq for Xml<'a>