Struct parsercher::dom::Dom

pub struct Dom {
    pub dom_type: DomType,
    // some fields omitted
}

A structure that represents the parsing result of a tag document.

Fields

dom_type: DomType

Type of Dom structure

Implementations

impl Dom

pub fn new(dom_type: DomType) -> Dom

Create new Dom structure.

pub fn new_root() -> Dom

Create the new root dom.

The root dom has a Tag structure whose name is root.

pub fn set_tag(&mut self, tag: Tag)

Set Tag structure.

Panics

self.dom_type is not DomType::Tag

pub fn get_tag(&self) -> Option<&Tag>

Returns the Tag structure. If it does not have a Tag structure, it returns None.

pub fn set_text(&mut self, text: Text)

Set Text structure.

Panics

self.dom_type is not DomType::Text

pub fn get_text(&self) -> Option<&Text>

Returns the Text structure. If it does not have a Text structure, it returns None.

pub fn set_comment(&mut self, comment: Comment)

Set Comment structure.

Panics

self.dom_type is not DomType::Comment

pub fn get_comment(&self) -> Option<&Comment>

Returns the Comment structure. If it does not have a Comment structure, it returns None.

pub fn add_child(&mut self, dom: Dom)

Add a child Dom structure.

pub fn get_children(&self) -> Option<&Vec<Box<Dom>>>

Returns child Dom structures as Vec. If it does not have children, it returns None.

pub fn p_implies_q(p: &Dom, q: &Dom) -> bool

Returns true if p is a sufficient condition for q. p => q

Examples

use parsercher::dom::DomType;
use parsercher::dom::Dom;
use parsercher::dom::Tag;

let mut p = Dom::new(DomType::Tag);
let mut tag = Tag::new("h1");
tag.set_attr("class", "target");
p.set_tag(tag);

let mut q = Dom::new(DomType::Tag);
let mut tag = Tag::new("h1");
tag.set_attr("id", "q");
tag.set_attr("class", "target");
q.set_tag(tag);

assert_eq!(Dom::p_implies_q(&p, &q), true);

let mut q = Dom::new(DomType::Tag);
let mut tag = Tag::new("h1");
tag.set_attr("id", "q");
q.set_tag(tag);

assert_eq!(Dom::p_implies_q(&p, &q), false);

pub fn p_implies_q_tree(p: &Dom, q: &Dom) -> bool

Returns true if p is a sufficient condition for q. Compare the entire tree. p => q

Examples

use parsercher;
use parsercher::dom::Dom;

// p
let p = r#"
<h1>
  <div></div>
  <ul>
    <li></li>
  </ul>
</h1>
"#;

let p_dom = parsercher::parse(&p).unwrap();
// Remove `root`dom of p_dom
let p_dom = p_dom.get_children().unwrap().get(0).unwrap();

// q
let q = r#"
<h1>
  <div id="divId"></div>
  <ul>
    <li></li>
  </ul>
  <span></span>
</h1>
"#;

let q_dom = parsercher::parse(&q).unwrap();
// Remove `root`dom of p_dom
let q_dom = q_dom.get_children().unwrap().get(0).unwrap();

assert_eq!(Dom::p_implies_q_tree(&p_dom, &q_dom), true);

Trait Implementations

impl Clone for Dom

fn clone(&self) -> Dom

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Dom

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

Formats the value using the given formatter.

impl PartialEq<Dom> for Dom

fn eq(&self, other: &Dom) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Dom) -> bool

This method tests for !=.

impl StructuralPartialEq for Dom