Struct Element

pub struct Element {
    pub name: CompactString,
    pub text_content: CompactString,
    pub attributes: IndexMap<CompactString, CompactString>,
    pub children: Vec<Element>,
}

An owned XML element. Slightly easier to work with than ElementRef.

Fields

name: CompactString

The name of the element, e.g. LuaComponent in <LuaComponent />.

text_content: CompactString

The text content of the element, e.g. hello in <SomeComponent>hello</SomeComponent>.

If there are multiple text nodes, they are concatenated into a single string with spaces between them.

attributes: IndexMap<CompactString, CompactString>

A map of element attributes, e.g. name="comp" in <SomeComponent name="comp" />, where the key is name and the value is comp.

children: Vec<Element>

A list of child elements, e.g. [<SomeComponent/>, <SomeOtherComponent/>] in

<Entity>
    <SomeComponent/>
    <SomeOtherComponent/>
</Entity>

Implementations

impl Element

pub fn new(name: impl ToCompactString) -> Element

Create a new element with the given name.

pub fn as_ref(&self) -> ElementRef<'_>

Create an ElementRef view of this element.

Example

let element = nxml!(<root><thing/><thing/></root>);

let element_ref: ElementRef = element.as_ref();

assert_eq!(element_ref.to_string(), "<root><thing/><thing/></root>");

impl Element

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

A shorthand for getting an attribute value.

Example

let element = nxml!(<Entity key="value"/>);

assert_eq!(element.attr("key"), Some("value"));

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

Find the first child element with the given name.

Example

let element = nxml!(<Entity><Child>"hello"</Child></Entity>);

assert_eq!(element.child("Child").unwrap().text_content, "hello");

pub fn child_mut(&mut self, name: &str) -> Option<&mut Self>

Find the first child element with the given name, mutable version.

Example

let mut element = nxml!(<Entity><Child/></Entity>);

element.child_mut("Child").unwrap().text_content = "world".into();

assert_eq!(element.child("Child").unwrap().text_content, "world");

pub fn children<'a>( &'a self, name: &'a str, ) -> impl Iterator<Item = &'a Self> + 'a

Iterate over all child elements with the given name.

Example

let element = nxml!(<Entity><Child/><Other/><Child/></Entity>);

assert_eq!(element.children("Child").count(), 2);

pub fn children_mut<'a>( &'a mut self, name: &'a str, ) -> impl Iterator<Item = &'a mut Self> + 'a

Iterate over all child elements with the given name, mutable version.

Example

let mut element = nxml!(<Entity><Child/><Other/><Child/></Entity>);

for child in element.children_mut("Child") {
   child.text_content = "text".into();
}

assert_eq!(element.to_string(), "<Entity><Child>text</Child><Other/><Child>text</Child></Entity>");

pub fn set_attr( &mut self, key: impl ToCompactString, value: impl ToCompactString, )

A shorthand for setting an attribute value.

Example

let mut element = nxml!(<Entity />);

element.set_attr("key", "value");

assert_eq!(element.to_string(), "<Entity key=\"value\"/>");

pub fn remove_attr(&mut self, key: &str) -> Option<CompactString>

A shorthand for removing an attribute value.

Example

let mut element = nxml!(<Entity key="value" other="other" />);

element.remove_attr("key");

assert_eq!(element.to_string(), "<Entity other=\"other\"/>");

pub fn with_attr( self, key: impl ToCompactString, value: impl ToCompactString, ) -> Self

Chained version of set_attr.

Example

let element = Element::new("Entity")
    .with_attr("key", "value");

assert_eq!(element.to_string(), "<Entity key=\"value\"/>");

pub fn with_text(self, text: impl ToCompactString) -> Self

Chained shorthand for setting the text content.

Example

let element = Element::new("Entity")
    .with_text("hello");

assert_eq!(element.to_string(), "<Entity>hello</Entity>");

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

Chained shorthand for adding a child element.

Example

let element = Element::new("Entity")
     .with_child(Element::new("Child"));

assert_eq!(element.to_string(), "<Entity><Child/></Entity>");

pub fn display(&self) -> PrettyDisplay<'_, Self>

A customizable Display impl that pretty-prints the element.

Example

let element = nxml!(<Entity><Child/></Entity>);

assert_eq!(element.display().indent_width(0).to_string(), "<Entity>\n<Child/>\n</Entity>");

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 Debug for Element

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

Formats the value using the given formatter.

impl Display for Element

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

Formats the value using the given formatter.

impl<'e> Div<&str> for &'e Element

fn div(self, rhs: &str) -> Self::Output

A chainable child element accessor

Example

let element = nxml!(<Entity><Child><Grandchild>"hello"</Grandchild></Child></Entity>);

assert_eq!(&element / "Child" / "Grandchild" % Text, "hello");

type Output = &'e Element

The resulting type after applying the / operator.

impl<'e> Div<&str> for &'e mut Element

fn div(self, rhs: &str) -> Self::Output

A mutable version of the child accessor.

Example

let mut element = nxml!(<Entity><Child><Grandchild>hello</Grandchild></Child></Entity>);

(&mut element / "Child").children.clear();

assert_eq!(element.to_string(), "<Entity><Child/></Entity>");

type Output = &'e mut Element

The resulting type after applying the / operator.

impl PartialEq for Element

fn eq(&self, other: &Element) -> 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<'e> Rem<&str> for &'e Element

fn rem(self, rhs: &str) -> Self::Output

A shorthand for getting an attribute value. Not index because &element / "child" % "key" is better than &(&element / "child")["key"].

Example

let element = nxml!(<Entity key="value"/>);

assert_eq!(&element % "key", "value");

type Output = &'e str

The resulting type after applying the % operator.

impl<'e> Rem<Text> for &'e Element

fn rem(self, _: Text) -> Self::Output

A shorthand for getting the text content.

Example

let element = nxml!(<Entity>"hello"</Entity>);

assert_eq!(&element % Text, "hello");

type Output = &'e str

The resulting type after applying the % operator.

impl Eq for Element

impl StructuralPartialEq for Element