Struct exile::Element

pub struct Element {
    pub namespace: Option<String>,
    pub name: String,
    pub attributes: OrdMap,
    pub nodes: Vec<Node>,
}

Represents an Element in an XML Document.

Fields

namespace: Option<String>

The namespace of this element. e.g. in foo:bar, foo is the namespace.

name: String

The name of this element. e.g. in foo:bar, bar is the name.

attributes: OrdMap

Attributes of this element.

nodes: Vec<Node>

Children of this element.

Implementations

impl Element

pub fn from_name<S: AsRef<str>>(name: S) -> Self

Create a new element using the given name.

pub fn children(&self) -> impl Iterator<Item = &Element>

Returns the 'child' elements of the current element. Consider the XML document:

<r>
  <a/>
  <b/>
</r>

r's children() function would return an iterator over 'a' and 'b'. Text nodes, processing instructions and comments are skipped/ignored by the iterator.

pub fn child<S: AsRef<str>>(&self, name: S) -> Option<&Element>

Find the first occurrance specific child element (does not recurse to lower levels of children).

pub fn add_child(&mut self, element: Element)

Add an element as a child of this element.

pub fn fullname(&self) -> String

The fullname of the element (including both the namespace and the name).

pub fn set_name<S: AsRef<str>>(&mut self, name: S)

Sets the name of this element.

pub fn add_attribute<K, V>(&mut self, key: K, value: V) -> Option<String> where
    K: AsRef<str>,
    V: AsRef<str>, 

Inserts a key-value pair into the attributes map.

If the map did not have this key present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned.

pub fn add_new_child(&mut self) -> Result<&mut Element, XErr>

Creates a new element as the last child of this element and returns a mut ref to it.

pub fn add_text<S: AsRef<str>>(&mut self, text: S)

Append a text node to this element's nodes.

pub fn add_pi(&mut self, pi: PI)

Append a processing instruction to this element's nodes.

pub fn has_children(&self) -> bool

Does this element have any sub elements. For example, if the element is empty or contains only text and/or pis and/or comments, then false. if the element has elements, then true.

pub fn is_text(&self) -> bool

Returns true if there is exactly one sub node, and that sub node is either text or cdata.

pub fn text(&self) -> Option<String>

Returns the contents of the first Text or CData node encountered in the element. Useful for simple 'text' elements like <something>text is here</something> where this function will return Some("text is here").

pub fn write<W>(
    &self,
    writer: &mut W,
    opts: &WriteOpts,
    depth: usize
) -> Result<(), XErr> where
    W: Write, 

Write the element to the Write object.

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

fn default() -> Self

Returns the "default value" for a type.

impl Eq for Element

impl<'a> From<&'a Element> for Cow<'a, Element>

fn from(x: &'a Element) -> Cow<'a, Element>

Performs the conversion.

impl<'a> From<Element> for Cow<'a, Element>

fn from(x: Element) -> Cow<'a, Element>

Performs the conversion.

impl Hash for Element

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Element> 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: &Element) -> bool

This method tests for !=.

impl PartialOrd<Element> for Element

fn partial_cmp(&self, other: &Element) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Element) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Element) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Element) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Element) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for Element

impl StructuralPartialEq for Element