Enum Node

pub enum Node {
    Element(Element),
    Text(String),
    Comment(String),
    CData(String),
    PI(String),
    DocType(String),
}

Represents an XML node.

Variants

Element(Element)

XML Element

Text(String)

XML Character Data (specification)

Comment(String)

Comments (specification)

CData(String)

CDATA (specification)

PI(String)

Processing Instruction (specification)

DocType(String)

Document Type Declaration (specification)

Implementations

impl Node

pub fn as_element(&self) -> Option<Element>

Useful to use inside filter_map.

use edit_xml::{Document, Element};

let mut doc = Document::parse_str(r#"<?xml version="1.0" encoding="UTF-8"?>
<config>
    Random Text
    <max>1</max>
</config>
"#).unwrap();

let elems: Vec<Element> = doc
    .root_element()
    .unwrap()
    .children(&doc)
    .iter()
    .filter_map(|n| n.as_element())
    .collect();

pub fn text_content(&self, doc: &Document) -> String

Returns content if node is Text, CData, or PI. If node is Element, return Element::text_content()

Implementation of Node.textContent

pub fn possible_borrowed_text(&self) -> Option<Cow<'_, str>>

Returns content if node is Text, CData, or PI.

If node is Element Cow will be owned. Otherwise, Cow will be borrowed.

If None is returned it is a comment or doctype

pub fn debug<'node, 'doc>( &'node self, doc: &'doc Document, ) -> NodeDebug<'node, 'doc>

Debug the node

pub fn is_text(&self) -> bool

Returns true if the node is a text node

use edit_xml::Node;
let node = Node::Text("Hello".to_string());
assert!(node.is_text());

pub fn is_comment(&self) -> bool

Returns true if the node is a comment node

use edit_xml::Node;
let node = Node::Comment("Hello".to_string());
assert!(node.is_comment());

pub fn is_cdata(&self) -> bool

Returns true if the node is a CDATA node

use edit_xml::Node;
let node = Node::CData("Hello".to_string());
assert!(node.is_cdata());

pub fn is_pi(&self) -> bool

Returns true if the node is a Processing Instruction node

use edit_xml::Node;
let node = Node::PI("Hello".to_string());
assert!(node.is_pi());

pub fn is_doctype(&self) -> bool

Returns true if the node is a Document Type Declaration

use edit_xml::Node;
let node = Node::DocType("Hello".to_string());
assert!(node.is_doctype());

pub fn is_element(&self) -> bool

Returns true if the node is an element

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl From<&Element> for Node

fn from(elem: &Element) -> Self

Converts to this type from the input type.

impl From<Element> for Node

fn from(elem: Element) -> Self

Converts to this type from the input type.

impl PartialEq for Node

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