Struct visdom::types::Elements

source · [−]

pub struct Elements<'a> { /* private fields */ }

Implementations

source

pub fn get_ref(&self) -> &Vec<BoxDynElement<'a>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,`

source

impl<'a> Elements<'a>

source

pub fn for_each<F>(&mut self, handle: F) -> &mut Self where
F: FnMut(usize, &mut BoxDynElement<'_>) -> bool,

Iterate over the element in Elements, when the handle return false, stop the iterator.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <ul>
      <li>item1</li>
      <li>item2</li>
      <li>item3</li>
    </ul>
  "##;
  let doc = Vis::load(html)?;
  let mut items = doc.find("ul > li");
  assert_eq!(items.length(), 3);
  let mut items_texts:Vec<String> = vec![];
  items.for_each(|index, ele| {
    if index < 2{
      items_texts.push(ele.text());
      return true;
    }
    false
  });
  assert_eq!(items_texts.len(), 2);
  assert_eq!(items_texts.join(","), "item1,item2");
  Ok(())
}

source

pub fn each<F>(&mut self, handle: F) -> &mut Self where
F: FnMut(usize, &mut BoxDynElement<'_>) -> bool,

A short alias for method for_each

source

pub fn map<F, T: Sized>(&self, handle: F) -> Vec<T>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,` where
F: FnMut(usize, &BoxDynElement<'_>) -> T,

Get a collection of values by iterate the each element in Elements and call the handle function.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <ul>
      <li>item1</li>
      <li>item2</li>
      <li>item3</li>
    </ul>
  "##;
  let doc = Vis::load(html)?;
  let mut items = doc.find("ul > li");
  assert_eq!(items.length(), 3);
  let items_texts: Vec<String> = items.map(|index, ele| {
    ele.text()
  });
  assert_eq!(items_texts.len(), 3);
  assert_eq!(items_texts.join(","), "item1,item2,item3");
  Ok(())
}

source

pub fn length(&self) -> usize

Return the length of the Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <ul>
      <li>item1</li>
      <li>item2</li>
      <li>item3</li>
    </ul>
  "##;
  let doc = Vis::load(html)?;
  let mut items = doc.find("ul > li:contains('item3')");
  assert_eq!(items.length(), 1);
  Ok(())
}

source

pub fn is_empty(&self) -> bool

Check if the Elements is empty, it’s a short alias for .length() == 0

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <ul>
      <li>item1</li>
      <li>item2</li>
      <li>item3</li>
    </ul>
  "##;
  let doc = Vis::load(html)?;
  let mut items = doc.find("ul > li:empty");
  assert!(items.is_empty());
  assert_eq!(items.length(), 0);
  Ok(())
}

source

pub fn document(&self) -> Option<Box<dyn IDocumentTrait + '_>>

A quick way to get the document object when the loaded html is a document.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <ul>
          <li>item1</li>
          <li>item2</li>
          <li>item3</li>
        </ul>
      </body>
    </html>
  "##;
  let root = Vis::load(html)?;
  let mut document = root.document();
  assert!(document.is_some());
  assert_eq!(document.unwrap().title(), Some("document"));
  Ok(())
}

source

impl<'a> Elements<'a>

source

pub fn find(&self, selector: &str) -> Elements<'a>

Get the descendants of each element in the Elements, filtered by the selector

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <ul>
          <li>item1</li>
          <li>item2</li>
          <li>
              <ol>
                <li>subitem1</li>
                <li>subitem2</li>
              </ol>
          </li>
        </ul>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  assert_eq!(doc.find("ul").length(), 1);
  assert_eq!(doc.find("ul li").length(), 5);
  assert_eq!(doc.find("ul > li").length(), 3);
  assert_eq!(doc.find("ul li:first-child").text(), "item1subitem1");
  Ok(())
}

source

pub fn filter(&self, selector: &str) -> Elements<'a>

Reduce the Elements to those that match the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <ul>
          <li>item1</li>
          <li class="item2">item2</li>
          <li>item3</li>
        </ul>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let items = doc.find("li");
  assert_eq!(items.length(), 3);
  assert_eq!(items.filter("[class]").length(), 1);
  assert_eq!(items.filter("[class]").text(), "item2");
  assert_eq!(items.filter("li:contains('item3')").length(), 1);
  assert_eq!(items.filter("li:contains('item3')").text(), "item3");
  Ok(())
}

source

pub fn filter_by<F>(&self, handle: F) -> Elements<'a> where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

Reduce the Elements to those that pass the handle function test.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <ul>
          <li>item1</li>
          <li class="item2">item2</li>
          <li>item3</li>
        </ul>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let items = doc.find("li");
  assert_eq!(items.length(), 3);
  let class_items = items.filter_by(|_, ele| ele.get_attribute("class").is_some());
  assert_eq!(class_items.length(), 1);
  assert_eq!(class_items.text(), "item2");
  Ok(())
}

source

pub fn filter_in(&self, search: &Elements<'_>) -> Elements<'a>

Reduce the Elements to those that also in the searched Elements.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <ul>
          <li></li>
          <li class="item2">item2</li>
          <li class="item3"></li>
        </ul>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let items = doc.find("li");
  assert_eq!(items.length(), 3);
  let empty_items = items.filter(":empty");
  let class_items = items.filter("[class]");
  assert_eq!(empty_items.length(), 2);
  assert_eq!(class_items.length(), 2);
  // has class and also empty
  let class_and_empty_items = class_items.filter_in(&empty_items);
  assert_eq!(class_and_empty_items.length(), 1);
  assert_eq!(class_and_empty_items.attr("class").unwrap().to_string(), "item3");
  Ok(())
}

source

pub fn children(&self, selector: &str) -> Elements<'a>

Get the children of each element in Elements, when the selector is not empty, will filtered by the selector

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">
              <dl>
                <dd>subitem1</dd>
                <dd>subitem2</dd>
              </dl>
          </dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let top_dl = doc.find("dl").eq(0);
  let all_dd = top_dl.find("dd");
  assert_eq!(all_dd.length(), 5);
  let child_items = top_dl.children("");
  assert_eq!(child_items.length(), 4);
  let child_dd = top_dl.children("dd");
  assert_eq!(child_dd.length(),3);
  Ok(())
}

source

pub fn prev(&self, selector: &str) -> Elements<'a>

Get the previous sibling of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item3 = dl.children(".item3");
  assert_eq!(item3.prev("").text(), "item2");
  assert_eq!(item3.prev(":not[class]").is_empty(),true);
  Ok(())
}

source

pub fn prev_all(&self, selector: &str) -> Elements<'a>

Get all preceding siblings of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item3 = dl.children(".item3");
  assert_eq!(item3.prev_all("").length(), 3);
  assert_eq!(item3.prev_all("dd").length(),2);
  assert_eq!(item3.prev_all("dt").length(),1);
  assert_eq!(item3.prev_all("dd[class]").length(),1);
  Ok(())
}

source

pub fn prev_until(
 &self,
 selector: &str,
 filter: &str,
 contains: bool
) -> Elements<'a>

Get all preceding siblings of each element in Elements, until the previous sibling element matched the selector, when contains is true, the matched previous sibling will be included, otherwise it will exclude; when the filter is not empty, will filtered by the selector;

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item3 = dl.children(".item3");
  assert_eq!(item3.prev_until("dt", "", false).length(), 2);
  assert_eq!(item3.prev_until("dt", "", false).eq(0).is("dd"), true);
  assert_eq!(item3.prev_until("dt", "", true).length(), 3);
  assert_eq!(item3.prev_until("dt", "", true).eq(0).is("dt"), true);
  assert_eq!(item3.prev_until("dt", "dd", true).length(), 2);
  assert_eq!(item3.prev_until("dt", "dd", true).eq(0).is("dd"), true);
  Ok(())
}

source

pub fn next(&self, selector: &str) -> Elements<'a>

Get the next sibling of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let dt = dl.children("dt");
  assert_eq!(dt.next("").text(), "item1");
  assert_eq!(dt.next("[class]").is_empty(), true);
  Ok(())
}

source

pub fn next_all(&self, selector: &str) -> Elements<'a>

Get all following siblings of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let dt = dl.children("dt");
  assert_eq!(dt.next_all("").length(), 3);
  assert_eq!(dt.next_all("[class]").length(), 2);
  assert_eq!(dt.next_all("[class]").text(), "item2item3");
  Ok(())
}

source

pub fn next_until(
 &self,
 selector: &str,
 filter: &str,
 contains: bool
) -> Elements<'a>

Get all following siblings of each element in Elements, until the sibling element matched the selector, when contains is true, the matched sibling will be included, otherwise it will exclude; when the filter is not empty, will filtered by the selector;

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let dt = dl.children("dt");
  assert_eq!(dt.next_until(".item3", "", false).length(), 2);
  assert_eq!(dt.next_until(".item3", "", true).length(), 3);
  assert_eq!(dt.next_until(".item3", "[class]", false).length(), 1);
  assert_eq!(dt.next_until(".item3", "[class]", true).length(), 2);
  Ok(())
}

source

pub fn siblings(&self, selector: &str) -> Elements<'a>

Get the siblings of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item2 = dl.children(".item2");
  assert_eq!(item2.siblings("").length(), 3);
  assert_eq!(item2.siblings("").first().is("dt"), true);
  assert_eq!(item2.siblings("dd").first().text(), "item1");
  Ok(())
}

source

pub fn parent(&self, selector: &str) -> Elements<'a>

Get the parent of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item2 = dl.children(".item2");
  assert_eq!(item2.parent("").length(), 1);
  assert_eq!(item2.parent("").get(0).unwrap().tag_name(), "DL");
  assert_eq!(item2.parent("ul").length(), 0);
  Ok(())
}

source

pub fn parents(&self, selector: &str) -> Elements<'a>

Get the ancestors of each element in Elements, when the selector is not empty, will filtered by the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item2 = dl.children(".item2");
  assert_eq!(item2.parents("").length(), 3);
  assert_eq!(item2.parents("").first().is("html"), true);
  assert_eq!(item2.parents("").last().is("dl"), true);
  assert_eq!(item2.parents("dl").length(), 1);
  Ok(())
}

source

pub fn parents_until(
 &self,
 selector: &str,
 filter: &str,
 contains: bool
) -> Elements<'a>

Get the ancestors of each element in Elements, until the ancestor matched the selector, when contains is true, the matched ancestor will be included, otherwise it will exclude; when the filter is not empty, will filtered by the selector;

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item2 = dl.children(".item2");
  assert_eq!(item2.parents_until("body", "", false).length(), 1);
  assert_eq!(item2.parents_until("body", "", true).length(), 2);
  assert_eq!(item2.parents_until("body", "dl", true).length(), 1);
  Ok(())
}

source

pub fn closest(&self, selector: &str) -> Elements<'a>

Get the first matched element of each element in Elements, traversing from self to it’s ancestors.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let item2 = dl.children(".item2");
  assert_eq!(item2.closest("dd").length(), 1);
  assert_eq!(item2.closest("dd").is_all_in(&item2), true);
  assert_eq!(item2.closest("dl").is_all_in(&item2.parent("")), true);
  Ok(())
}

source

pub fn cloned(&self) -> Elements<'a>

source

pub fn contains(&self, ele: &BoxDynElement<'_>, comb: &Combinator) -> bool

pub fn contains

source

pub fn is(&self, selector: &str) -> bool

Check at least one element in Elements is match the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.is("dd"), true);
  assert_eq!(items.is("dt"), true);
  assert_eq!(items.is(".item2"), true);
  assert_eq!(items.is(".item3"), true);
  assert_eq!(items.is(":contains('item2')"), true);
  Ok(())
}

source

pub fn is_by<F>(&self, handle: F) -> bool where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

Check at least one element in Elements call the handle function return true.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.is_by(|_, ele|{
    ele.tag_name() == "DT"
  }), true);
  assert_eq!(items.is_by(|_, ele|{
    ele.tag_name() == "DD"
  }), true);
  assert_eq!(items.is_by(|_, ele|{
    Vis::dom(ele).has_class("item2")
  }), true);
  Ok(())
}

source

pub fn is_in(&self, search: &Elements<'_>) -> bool

Check at least one element in Elements is also in the other Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let dd = items.filter("dd");
  let dt = items.filter("dt");
  assert_eq!(items.is_in(&dd), true);
  assert_eq!(items.is_in(&dt), true);
  Ok(())
}

source

pub fn is_all(&self, selector: &str) -> bool

Check if each element in Elements are all matched the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.is_all("dd"), false);
  assert_eq!(items.is_all("dt"), false);
  assert_eq!(items.is_all("dt,dd"), true);
  Ok(())
}

source

pub fn is_all_by<F>(&self, handle: F) -> bool where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

Check if each element in Elements call the handle function are all returned true.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.is_all_by(|_, ele|{
    ele.tag_name() == "DT"
  }), false);
  assert_eq!(items.is_all_by(|_, ele|{
    ele.tag_name() == "DD"
  }), false);
  assert_eq!(items.is_all_by(|_, ele|{
    let tag_name = ele.tag_name();
    tag_name == "DT" || tag_name == "DD"
  }), true);
  Ok(())
}

source

pub fn is_all_in(&self, search: &Elements<'_>) -> bool

Check if each element in Elements is also in the other Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let dd = items.filter("dd");
  let dt = items.filter("dt");
  assert_eq!(items.is_all_in(&dd), false);
  assert_eq!(items.is_all_in(&dt), false);
  assert_eq!(dd.is_all_in(&items), true);
  assert_eq!(dt.is_all_in(&items), true);
  Ok(())
}

source

pub fn not(&self, selector: &str) -> Elements<'a>

Remove elements those that match the selector from the Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.not("dd").is_all("dt"), true);
  assert_eq!(items.not("dt").is_all("dd"), true);
  assert_eq!(items.not("dt,dd").is_empty(), true);
  Ok(())
}

source

pub fn not_by<F>(&self, handle: F) -> Elements<'a> where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

Remove elements those that pass the handle function test from the Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.not_by(|_, ele|ele.tag_name() == "DD").is_all("dt"), true);
  assert_eq!(items.not_by(|_, ele|ele.tag_name() == "DT").is_all("dd"), true);
  assert_eq!(items.not_by(|_, ele|ele.tag_name() == "DT" || ele.tag_name() == "DD").is_empty(), true);
  Ok(())
}

source

pub fn not_in(&self, search: &Elements<'_>) -> Elements<'a>

Remove elements those that also in the elements from the Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd>item1</dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.not_in(&items.filter("dd")).is_all("dt"), true);
  assert_eq!(items.not_in(&items.filter("dt")).is_all("dd"), true);
  assert_eq!(items.not_in(&items).is_empty(), true);
  Ok(())
}

source

pub fn has(&self, selector: &str) -> Elements<'a>

Reduce Elements to those that have a descendant that matches the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>&lt;<strong>T</strong>itle&gt;</dt>
          <dd><span>item1</span></dd>
          <dd class="item2">item2</dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.filter("dt").text(), "<Title>");
  assert_eq!(items.filter("dd").text(), "item1item2item3");
  Ok(())
}

source

pub fn has_in(&self, search: &Elements<'_>) -> Elements<'a>

Reduce Elements to those that have a descendant that matches the selector.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.length(), 4);
  assert_eq!(items.has_in(&items.children("span")).length(), 2);
  assert_eq!(dl.has_in(&items).length(), 1);
  Ok(())
}

source

impl<'a> Elements<'a>

source

pub fn eq(&self, index: usize) -> Elements<'a>

Get one element from the Elements at the specified index.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.eq(0).is("dt"), true);
  assert_eq!(items.eq(2).has_class("item2"), true);
  Ok(())
}

source

pub fn first(&self) -> Elements<'a>

Get the first element of the Elements set,equal to eq(0).

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.first().is_all_in(&items.eq(0)), true);
  assert_eq!(items.first().is("dt"), true);
  Ok(())
}

source

pub fn last(&self) -> Elements<'a>

Get the last element of the set, equal to eq(length - 1).

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.last().is_all_in(&items.eq(items.length()-1)), true);
  assert_eq!(items.last().is(".item3"), true);
  Ok(())
}

source

pub fn slice<T: RangeBounds<usize>>(&self, range: T) -> Elements<'a>

Get a subset specified by a range of indices.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.slice(..).length(), 4);
  assert_eq!(items.slice(0..3).length(), 3);
  assert_eq!(items.slice(0..=3).length(), 4);
  assert_eq!(items.slice(0..10).length(), 4);
  Ok(())
}

source

pub fn add(&self, eles: Elements<'a>) -> Elements<'a>

Get a concated element set from Elements and the other parameter elements, it will generate a new element set, take the ownership of the parameter elements, but have no sence with the Elements itself.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let dt = items.filter("dt");
  let class_dd = items.filter("[class]");
  assert_eq!(dt.length(), 1);
  assert_eq!(class_dd.length(), 2);
  let add_dt_dd = dt.add(class_dd);
  assert_eq!(add_dt_dd.length(), 3);
  Ok(())
}

source

impl<'a> Elements<'a>

source

pub fn val(&self) -> IFormValue

Get the form value of input, select, option, textarea.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" value="textvalue" />
        <select name="single">
          <option value="default"></option>
          <option value="opt1">opt1</option>
          <option value="opt2">opt1</option>
        </select>
        <select multiple>
          <option value="default"></option>
          <option value="opt1" selected="selected">opt1</option>
          <option value="opt2" selected="selected">opt1</option>
        </select>
        <textarea><div>hello</div></textarea>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let input = doc.find("input[type='text']");
  assert_eq!(input.val().to_string(), "textvalue");
  let select = doc.find("select[name='single']");
  assert_eq!(select.val().to_string(), "default");
  let multi_select = doc.find("select[multiple]");
  assert_eq!(multi_select.val().to_string(), "opt1,opt2");
  let textarea = doc.find("textarea");
  assert_eq!(textarea.val().to_string(), "<div>hello</div>");
  Ok(())
}

source

pub fn text(&self) -> &str

Get the text of each element in Elements，the html entity will auto decoded.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let dt = items.filter("dt");
  let class_dd = items.filter("[class]");
  assert_eq!(dt.length(), 1);
  assert_eq!(class_dd.length(), 2);
  let add_dt_dd = dt.add(class_dd);
  assert_eq!(add_dt_dd.length(), 3);
  Ok(())
}

source

pub fn set_text(&mut self, content: &str) -> &mut Self

Set the Elements’s text, the html entity in content will auto encoded.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3">item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let mut dt = items.filter("dt");
  dt.set_text("<Title>");
  assert_eq!(dt.text(), "<Title>");
  assert_eq!(dt.html(), "&lt;Title&gt;");
  let mut item2 = items.filter(".item2");
  assert_eq!(item2.html(), "<span>item2</span>");
  item2.set_text("item2");
  assert_eq!(item2.html(), "item2");
  Ok(())
}

source

pub fn html(&self) -> String

Get the html of the first element in Elements.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let item2 = items.filter(".item2");
  assert_eq!(item2.html(), "<span>item2</span>");
  let item3 = items.filter(".item3");
  assert_eq!(item3.html(), "<!--comment-->item3");
  Ok(())
}

source

pub fn set_html(&mut self, content: &str) -> &mut Self

Set the html to content of each element in Elements.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let mut item2 = items.filter(".item2");
  assert_eq!(item2.html(), "<span>item2</span>");
  item2.set_html("set_html:<em>item2</em>");
  assert_eq!(item2.html(), "set_html:<em>item2</em>");
  Ok(())
}

source

pub fn outer_html(&self) -> String

Get the outer html of the first element in Elements.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  let mut item2 = items.filter(".item2");
  assert_eq!(item2.outer_html(), r#"<dd class="item2"><span>item2</span></dd>"#);
  Ok(())
}

source

pub fn texts(&self, limit_depth: usize) -> Texts<'a>

pub fn texts get the text node of each element

source

pub fn texts_by(
 &self,
 limit_depth: usize,
 handle: Box<dyn Fn(usize, &BoxDynText<'_>) -> bool>
) -> Texts<'a>

pub fn texts_by get the text node of each element, filter by the handle

source

impl<'a> Elements<'a>

source

pub fn attr(&self, attr_name: &str) -> Option<IAttrValue>

Get an atrribute by name from the first element in Elements.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let input = doc.find("input");
  let attr_readonly = input.attr("readonly");
  assert!(attr_readonly.is_some() && attr_readonly.unwrap().is_true());
  let attr_type = input.attr("type");
  assert!(attr_type.is_some() && attr_type.unwrap().to_string() == "text");
  let attr_class = input.attr("class");
  assert!(attr_class.is_some() && attr_class.unwrap().to_list().contains(&"inp"));
  Ok(())
}

source

pub fn has_attr(&self, attr_name: &str) -> bool

Check if has an attribute with specified name.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let input = doc.find("input");
  assert!(input.has_attr("readonly"));
  assert!(input.has_attr("class"));
  assert!(input.has_attr("type"));
  assert_eq!(input.has_attr("value"), false);
  Ok(())
}

source

pub fn set_attr(&mut self, attr_name: &str, value: Option<&str>) -> &mut Self

Set a specified name attribute with a value who’s type is an Option<&str>, when the value is None，that means the attribute does’n have a string value but a bool value of true.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut input = doc.find("input");
  assert_eq!(input.has_attr("value"), false);
  input.set_attr("value", None);
  assert!(input.attr("value").is_some() && input.attr("value").unwrap().is_true());
  input.set_attr("value", Some("myinput"));
  assert!(input.attr("value").is_some() && input.attr("value").unwrap().to_string() == "myinput");
  input.set_attr("value", Some(""));
  assert!(input.attr("value").is_some() && input.attr("value").unwrap().is_true() == false);
  Ok(())
}

source

pub fn remove_attr(&mut self, attr_name: &str) -> &mut Self

Remove a specified name attribute from the each element in the Elements.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut input = doc.find("input");
  assert_eq!(input.has_attr("value"), false);
  input.set_attr("value", None);
  assert!(input.attr("value").is_some() && input.attr("value").unwrap().is_true());
  input.remove_attr("value");
  assert!(input.attr("value").is_none());
  assert!(input.attr("readonly").is_some());
  input.remove_attr("readonly");
  assert!(input.attr("readonly").is_none());
  Ok(())
}

source

pub fn has_class(&self, class_name: &str) -> bool

Check if Elements’s ClassList contains the specified class name, multiple classes can be splitted by whitespaces.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let input = doc.find("input");
  assert_eq!(input.has_class("inp"), true);
  assert_eq!(input.has_class("inp-txt"), true);
  assert_eq!(input.has_class("inp-txt inp"), true);
  assert_eq!(input.has_class("inp-txt inp noinp"), false);
  Ok(())
}

source

pub fn add_class(&mut self, class_name: &str) -> &mut Self

Add class to Elements’s ClassList, multiple classes can be splitted by whitespaces.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut input = doc.find("input");
  assert_eq!(input.has_class("noinp"), false);
  assert_eq!(input.has_class("inp-red"), false);
  input.add_class("noinp inp-red");
  assert_eq!(input.has_class("noinp"), true);
  assert_eq!(input.has_class("inp-red"), true);
  Ok(())
}

source

pub fn remove_class(&mut self, class_name: &str) -> &mut Self

Remove class from Elements’s ClassList, multiple classes can be splitted by whitespaces.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut input = doc.find("input");
  assert_eq!(input.has_class("inp"), true);
  assert_eq!(input.has_class("inp-txt"), true);
  input.remove_class("inp inp-txt");
  assert_eq!(input.has_class("inp"), false);
  assert_eq!(input.has_class("inp-txt"), false);
  assert_eq!(input.has_attr("class"), true);
  Ok(())
}

source

pub fn toggle_class(&mut self, class_name: &str) -> &mut Self

Toggle the class name from Elements’s ClassList, multiple classes can be splitted by whitespaces.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <input type="text" class="inp inp-txt" readonly />
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut input = doc.find("input");
  assert_eq!(input.has_class("inp"), true);
  assert_eq!(input.has_class("inp-txt"), true);
  input.toggle_class("inp inp-red");
  assert_eq!(input.has_class("inp"), false);
  assert_eq!(input.has_class("inp-txt"), true);
  assert_eq!(input.has_class("inp-red"), true);
  Ok(())
}

source

impl<'a> Elements<'a>

source

pub fn remove(self)

Remove the Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.length(), 4);
  // remove the dt element
  items.filter("dt").remove();
  let now_items = dl.children("");
  assert_eq!(now_items.length(), 3);
  Ok(())
}

source

pub fn empty(&mut self) -> &mut Self

Clear all the nodes in the Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.length(), 4);
  // clear the dl
  dl.empty();
  let now_items = dl.children("");
  assert_eq!(now_items.length(), 0);
  Ok(())
}

source

pub fn append(&mut self, elements: &mut Elements<'_>) -> &mut Self

Append the parameter Elements to the child before the tag end of the current Elements set.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.length(), 4);
  assert_eq!(items.last().is(".item3"), true);
  // now append item2 to the last child
  let mut item2 = items.filter(".item2");
  dl.append(&mut item2);
  let now_items = dl.children("");
  assert_eq!(now_items.last().is(".item2"), true);
  // append a new document fragement
  let mut append_dd = Vis::load(r#"<dd class="item4">item4</dd>"#)?;
  dl.append(&mut append_dd);
  let now_items = dl.children("");
  assert_eq!(now_items.last().is(".item4"), true);
  Ok(())
}

source

pub fn append_to(&mut self, elements: &mut Elements<'_>) -> &mut Self

Same as append, but exchange the caller and the parameter target.

source

pub fn prepend(&mut self, elements: &mut Elements<'_>) -> &mut Self

Append the parameter Elements to the child after the tag start of the current Elements set.

source

pub fn prepend_to(&mut self, elements: &mut Elements<'_>) -> &mut Self

Same as prepend, but exchange the caller and the parameter target.

source

pub fn insert_before(&mut self, elements: &mut Elements<'_>) -> &mut Self

Insert the each element in the current Elements set into the other Elements’s element’s before position.

use visdom::Vis;
use visdom::types::BoxDynError;
fn main()-> Result<(), BoxDynError>{
  let html = r##"
    <html>
      <head>
        <title>document</title>
      </head>
      <body>
        <dl>
          <dt>Title</dt>
          <dd><span>item1</span></dd>
          <dd class="item2"><span>item2</span></dd>
          <dd class="item3"><!--comment-->item3</dd>
        </dl>
      </body>
    </html>
  "##;
  let doc = Vis::load(html)?;
  let mut dl = doc.find("dl");
  let items = dl.children("");
  assert_eq!(items.length(), 4);
  assert_eq!(items.last().is(".item3"), true);
  // now insert item3 before item2
  let mut item2 = items.filter(".item2");
  let mut item3 = items.filter(".item3");
  item3.insert_before(&mut item2);
  let now_items = dl.children("");
  assert_eq!(now_items.last().is(".item2"), true);
  // insert a new item0
  let mut insert_dd = Vis::load(r#"<dd class="item0">item0</dd>"#)?;
  let mut first_dd = dl.children("dd").first();
  insert_dd.insert_before(&mut first_dd);
  let now_dds = dl.children("dd");
  assert_eq!(now_dds.first().is(".item0"), true);
  Ok(())
}

source

pub fn before(&mut self, elements: &mut Elements<'_>) -> &mut Self

Same as insert_before, but exchange the caller and the parameter target.

source

pub fn insert_after(&mut self, elements: &mut Elements<'_>) -> &mut Self

Insert the each element in the current Elements set into the other Elements’s element’s after position.

source

pub fn after(&mut self, elements: &mut Elements<'_>) -> &mut Self

Same as insert_after, but exchange the caller and the parameter target.

Trait Implementations

source

impl<'a> Default for Elements<'a>

source

fn default() -> Elements<'a>

Returns the “default value” for a type. Read more

source

impl<'a> IntoIterator for Elements<'a>

type Item = BoxDynElement<'a>

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = Self::Item> + 'a>

Which kind of iterator are we turning this into?

source

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Auto Trait Implementations

impl<'a> !RefUnwindSafe for Elements<'a>

impl<'a> !Send for Elements<'a>

impl<'a> !Sync for Elements<'a>

impl<'a> Unpin for Elements<'a>

impl<'a> !UnwindSafe for Elements<'a>

Blanket Implementations

source

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

source

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

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

const: unstable · source

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

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

const: unstable · source

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

pub fn from(t: T) -> T

Returns the argument unchanged.

source

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

const: unstable · source

pub fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

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

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

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

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct visdom::types::Elements

Implementations

impl<'a> Elements<'a>

pub fn new() -> Self

pub fn with_nodes(nodes: Vec<BoxDynElement<'a>>) -> Self

pub fn with_capacity(size: usize) -> Self

pub fn get(&self, index: usize) -> Option<&BoxDynElement<'a>>

pub fn get_ref(&self) -> &Vec<BoxDynElement<'a>>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where A: Allocator,

impl<'a> Elements<'a>

pub fn for_each<F>(&mut self, handle: F) -> &mut Self where F: FnMut(usize, &mut BoxDynElement<'_>) -> bool,

pub fn each<F>(&mut self, handle: F) -> &mut Self where F: FnMut(usize, &mut BoxDynElement<'_>) -> bool,

pub fn map<F, T: Sized>(&self, handle: F) -> Vec<T>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A> where A: Allocator, where F: FnMut(usize, &BoxDynElement<'_>) -> T,

pub fn length(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn document(&self) -> Option<Box<dyn IDocumentTrait + '_>>

impl<'a> Elements<'a>

pub fn find(&self, selector: &str) -> Elements<'a>

pub fn filter(&self, selector: &str) -> Elements<'a>

pub fn filter_by<F>(&self, handle: F) -> Elements<'a> where F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn filter_in(&self, search: &Elements<'_>) -> Elements<'a>

pub fn children(&self, selector: &str) -> Elements<'a>

pub fn prev(&self, selector: &str) -> Elements<'a>

pub fn prev_all(&self, selector: &str) -> Elements<'a>

pub fn prev_until( &self, selector: &str, filter: &str, contains: bool) -> Elements<'a>

pub fn next(&self, selector: &str) -> Elements<'a>

pub fn next_all(&self, selector: &str) -> Elements<'a>

pub fn next_until( &self, selector: &str, filter: &str, contains: bool) -> Elements<'a>

pub fn siblings(&self, selector: &str) -> Elements<'a>

pub fn parent(&self, selector: &str) -> Elements<'a>

pub fn parents(&self, selector: &str) -> Elements<'a>

pub fn parents_until( &self, selector: &str, filter: &str, contains: bool) -> Elements<'a>

pub fn closest(&self, selector: &str) -> Elements<'a>

pub fn cloned(&self) -> Elements<'a>

pub fn contains(&self, ele: &BoxDynElement<'_>, comb: &Combinator) -> bool

pub fn is(&self, selector: &str) -> bool

pub fn is_by<F>(&self, handle: F) -> bool where F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn is_in(&self, search: &Elements<'_>) -> bool

pub fn is_all(&self, selector: &str) -> bool

pub fn is_all_by<F>(&self, handle: F) -> bool where F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn is_all_in(&self, search: &Elements<'_>) -> bool

pub fn not(&self, selector: &str) -> Elements<'a>

pub fn not_by<F>(&self, handle: F) -> Elements<'a> where F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn not_in(&self, search: &Elements<'_>) -> Elements<'a>

pub fn has(&self, selector: &str) -> Elements<'a>

pub fn has_in(&self, search: &Elements<'_>) -> Elements<'a>

impl<'a> Elements<'a>

pub fn eq(&self, index: usize) -> Elements<'a>

pub fn first(&self) -> Elements<'a>

pub fn last(&self) -> Elements<'a>

pub fn slice<T: RangeBounds<usize>>(&self, range: T) -> Elements<'a>

pub fn add(&self, eles: Elements<'a>) -> Elements<'a>

impl<'a> Elements<'a>

pub fn val(&self) -> IFormValue

pub fn text(&self) -> &str

pub fn set_text(&mut self, content: &str) -> &mut Self

pub fn html(&self) -> String

pub fn set_html(&mut self, content: &str) -> &mut Self

pub fn outer_html(&self) -> String

pub fn texts(&self, limit_depth: usize) -> Texts<'a>

pub fn texts_by( &self, limit_depth: usize, handle: Box<dyn Fn(usize, &BoxDynText<'_>) -> bool>) -> Texts<'a>

impl<'a> Elements<'a>

pub fn attr(&self, attr_name: &str) -> Option<IAttrValue>

pub fn has_attr(&self, attr_name: &str) -> bool

pub fn set_attr(&mut self, attr_name: &str, value: Option<&str>) -> &mut Self

pub fn remove_attr(&mut self, attr_name: &str) -> &mut Self

pub fn has_class(&self, class_name: &str) -> bool

pub fn add_class(&mut self, class_name: &str) -> &mut Self

pub fn remove_class(&mut self, class_name: &str) -> &mut Self

pub fn toggle_class(&mut self, class_name: &str) -> &mut Self

impl<'a> Elements<'a>

pub fn remove(self)

pub fn empty(&mut self) -> &mut Self

pub fn append(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn append_to(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn prepend(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn prepend_to(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn insert_before(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn before(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn insert_after(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn after(&mut self, elements: &mut Elements<'_>) -> &mut Self

pub fn get_ref(&self) -> &Vec<BoxDynElement<'a>>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,`

pub fn for_each<F>(&mut self, handle: F) -> &mut Self where
F: FnMut(usize, &mut BoxDynElement<'_>) -> bool,

pub fn each<F>(&mut self, handle: F) -> &mut Self where
F: FnMut(usize, &mut BoxDynElement<'_>) -> bool,

pub fn map<F, T: Sized>(&self, handle: F) -> Vec<T>ⓘNotable traits for Vec<u8, A>`impl<A> Write for Vec<u8, A> where A: Allocator,` where
F: FnMut(usize, &BoxDynElement<'_>) -> T,

pub fn filter_by<F>(&self, handle: F) -> Elements<'a> where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn prev_until(
&self,
selector: &str,
filter: &str,
contains: bool
) -> Elements<'a>

pub fn next_until(
&self,
selector: &str,
filter: &str,
contains: bool
) -> Elements<'a>

pub fn parents_until(
&self,
selector: &str,
filter: &str,
contains: bool
) -> Elements<'a>

pub fn is_by<F>(&self, handle: F) -> bool where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn is_all_by<F>(&self, handle: F) -> bool where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn not_by<F>(&self, handle: F) -> Elements<'a> where
F: Fn(usize, &BoxDynElement<'_>) -> bool,

pub fn texts_by(
&self,
limit_depth: usize,
handle: Box<dyn Fn(usize, &BoxDynText<'_>) -> bool>
) -> Texts<'a>

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, U> Into<U> for T where
U: From<T>,

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

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