Struct visdom::types::Elements

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

Implementations

impl<'a> Elements<'a>

pub fn new() -> Elements<'a>

pub fn with_nodes(
    nodes: Vec<Box<dyn IElementTrait + 'a, Global>, Global>
) -> Elements<'a>

pub fn with_capacity(size: usize) -> Elements<'a>

pub fn get(&self, index: usize) -> Option<&Box<dyn IElementTrait + 'a, Global>>

pub fn get_ref(&self) -> &Vec<Box<dyn IElementTrait + 'a, Global>, Global>

pub fn get_mut_ref(
    &mut self
) -> &mut Vec<Box<dyn IElementTrait + 'a, Global>, Global>

pub fn for_each<F>(&mut self, handle: F) -> &mut Elements<'a> where
    F: FnMut(usize, &mut Box<dyn IElementTrait, Global>) -> bool, 

pub fn each<F>(&mut self, handle: F) -> &mut Elements<'a> where
    F: FnMut(usize, &mut Box<dyn IElementTrait, Global>) -> bool, 

pub fn map<F, T>(&self, handle: F) -> Vec<T, Global> where
    F: Fn(usize, &Box<dyn IElementTrait, Global>) -> T, 

pub fn length(&self) -> usize

pub fn length

pub fn is_empty(&self) -> bool

pub fn is_empty

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

pub fn document, a quick way to get document

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 children(&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 find(&self, selector: &str) -> Elements<'a>

pub fn find get elements by selector, support most of css selectors

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

pub fn filter_by<F>(&self, handle: F) -> Elements<'a> where
    F: Fn(usize, &Box<dyn IElementTrait, Global>) -> bool, 

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

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

pub fn is_by<F>(&self, handle: F) -> bool where
    F: Fn(usize, &Box<dyn IElementTrait, Global>) -> 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, &Box<dyn IElementTrait, Global>) -> 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, &Box<dyn IElementTrait, Global>) -> bool, 

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

pub fn not_in remove element from Self which is also in search

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

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

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

pub fn eq get a element by index

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

pub fn first get the first element, alias for ‘eq(0)’

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

pub fn last get the last element, alias for ‘eq(len - 1)’

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

pub fn slice get elements by a range parameter slice(0..1) equal to eq(0), first

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

pub fn add concat two element set to a new set, it will take the owership of the parameter element set, but no sence to Self

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

pub fn text(&self) -> &str

pub fn text get the text of each element in the set

pub fn set_text(&mut self, content: &str) -> &mut Elements<'a>

pub fn set_text set each element’s text to content

pub fn html(&self) -> &str

pub fn html get the first element’s html

pub fn set_html(&mut self, content: &str) -> &mut Elements<'a>

pub fn set_html set each element’s html to content

pub fn outer_html(&self) -> &str

pub fn outer_html get the first element’s outer html

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

pub fn texts get the text node of each element

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

pub fn attr get the first element’s attribute value

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

pub fn set_attr set each element’s attribute to key = attr_name, value = value.

pub fn remove_attr(&mut self, attr_name: &str) -> &mut Elements<'a>

pub fn remove_attr

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

pub fn has_class

pub fn add_class(&mut self, class_name: &str) -> &mut Elements<'a>

pub fn add_class

pub fn remove_class(&mut self, class_name: &str) -> &mut Elements<'a>

pub fn remove_class

pub fn toggle_class(&mut self, class_name: &str) -> &mut Elements<'a>

pub fn toggle_class

pub fn remove(self)

pub fn remove

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

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

pub fn append

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

pub fn append_to

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

pub fn prepend

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

pub fn prepend_to

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

pub fn insert_before

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

pub fn before

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

pub fn insert_after

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

pub fn after

Trait Implementations

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

pub fn default() -> Elements<'a>

Returns the “default value” for a type.

impl<'a> From<Vec<Box<dyn IElementTrait + 'a, Global>, Global>> for Elements<'a>

pub fn from(
    nodes: Vec<Box<dyn IElementTrait + 'a, Global>, Global>
) -> Elements<'a>

Performs the conversion.

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

type Item = Box<dyn IElementTrait + 'a, Global>

The type of the elements being iterated over.

type IntoIter = Box<dyn Iterator<Item = <Elements<'a> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <Elements<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.