Struct roxmltree::Document[][src]

pub struct Document<'input> { /* fields omitted */ }

An XML tree container.

A tree consists of Nodes. There are no separate structs for each node type. So you should check the current node type yourself via Node::node_type(). There are only 5 types: Root, Element, PI, Comment and Text.

As you can see there are no XML declaration and CDATA types. The XML declaration is basically skipped, since it doesn’t contain any valuable information (we support only UTF-8 anyway). And CDATA will be converted into a Text node as is, without any preprocessing (you can read more about it here).

Also, the Text node data can be accessed from the text node itself or from the parent element via Node::text() or Node::tail().


impl<'input> Document<'input>[src]

pub fn parse(text: &str) -> Result<Document<'_>, Error>[src]

Parses the input XML string.

We do not support &[u8] or Reader because the input must be an already allocated UTF-8 string.

This is a shorthand for Document::parse_with_options(data, ParsingOptions::default()).


let doc = roxmltree::Document::parse("<e/>").unwrap();
assert_eq!(doc.descendants().count(), 2); // root node + `e` element node

pub fn parse_with_options(
    text: &str,
    opt: ParsingOptions
) -> Result<Document<'_>, Error>

Parses the input XML string using to selected options.

We do not support &[u8] or Reader because the input must be an already allocated UTF-8 string.


let opt = roxmltree::ParsingOptions::default();
let doc = roxmltree::Document::parse_with_options("<e/>", opt).unwrap();
assert_eq!(doc.descendants().count(), 2); // root node + `e` element node

impl<'input> Document<'input>[src]

pub fn root<'a>(&'a self) -> Node<'a, 'input>[src]

Returns the root node.


let doc = roxmltree::Document::parse("<e/>").unwrap();

pub fn get_node<'a>(&'a self, id: NodeId) -> Option<Node<'a, 'input>>[src]

Returns the node of the tree with the given NodeId.

Note: NodeId::new(0) represents the root node


let doc = roxmltree::Document::parse("\

use roxmltree::NodeId;
assert_eq!(doc.get_node(NodeId::new(0)).unwrap(), doc.root());
assert_eq!(doc.get_node(NodeId::new(1)), doc.descendants().find(|n| n.has_tag_name("p")));
assert_eq!(doc.get_node(NodeId::new(2)), doc.descendants().find(|n| n.is_text()));
assert_eq!(doc.get_node(NodeId::new(3)), None);

pub fn root_element<'a>(&'a self) -> Node<'a, 'input>[src]

Returns the root element of the document.

Unlike root, will return a first element node.

The root element always exists.


let doc = roxmltree::Document::parse("<!-- comment --><e/>").unwrap();

pub fn descendants(&self) -> Descendants<'_, '_>

Notable traits for Descendants<'a, 'input>

impl<'a, 'input> Iterator for Descendants<'a, 'input> type Item = Node<'a, 'input>;

Returns an iterator over document’s descendant nodes.

Shorthand for doc.root().descendants().

pub fn text_pos_at(&self, pos: usize) -> TextPos[src]

Calculates TextPos in the original document from position in bytes.

Note: this operation is expensive.


use roxmltree::*;

let doc = Document::parse("\
<!-- comment -->

assert_eq!(doc.text_pos_at(10), TextPos::new(1, 11));
assert_eq!(doc.text_pos_at(9999), TextPos::new(2, 5));

pub fn input_text(&self) -> &'input str[src]

Returns the input text of the original document.


use roxmltree::*;

let doc = Document::parse("<e/>").unwrap();

assert_eq!(doc.input_text(), "<e/>");

Trait Implementations

impl<'input> Debug for Document<'input>[src]

Auto Trait Implementations

impl<'input> RefUnwindSafe for Document<'input>

impl<'input> Send for Document<'input>

impl<'input> Sync for Document<'input>

impl<'input> Unpin for Document<'input>

impl<'input> UnwindSafe for Document<'input>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.