Enum Node

pub enum Node<'s> {
    Element(Element<'s>),
    Text(Cow<'s, str>),
    Comment(Cow<'s, str>),
}

Variants

Element(Element<'s>)

Text(Cow<'s, str>)

Comment(Cow<'s, str>)

Implementations

impl<'s> Node<'s>

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

Get the text when it’s a text node

pub fn element(&self) -> Option<&Element<'_>>

Get the elemnt when it’s a element node

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

Get the comment when it’s a comment node

pub fn new_text(text: &'s str) -> Self

Create a new text node

pub fn new_comment(comment: &'s str) -> Self

Create a new comment node

pub fn parse(input: &'s str) -> Result<Vec<Self>>

Parse a dom from a html string

pub fn parse_json(json: &'s str) -> Result<Self>

Create the node from a json string

pub fn to_json(&self) -> Result<String>

Output the node as a json formatted string

pub fn to_json_pretty(&self) -> Result<String>

Output the node as a pretty json formatted string

pub fn fmt_opt<W>( &self, f: &mut W, o: &FormattingOptions, depth: usize, ) -> Result

where W: Write,

Trait Implementations

impl<'s> Clone for Node<'s>

fn clone(&self) -> Node<'s>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'s> Debug for Node<'s>

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

Formats the value using the given formatter.

impl<'de: 's, 's> Deserialize<'de> for Node<'s>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'s> Display for Node<'s>

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

Formats the value using the given formatter.

impl<'a> IntoIterator for &'a Node<'a>

type Item = &'a Node<'a>

The type of the elements being iterated over.

type IntoIter = NodeIntoIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'s> PartialEq for Node<'s>

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'s> StructuralPartialEq for Node<'s>