Struct fast_scraper::element_ref::ElementRef

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

Wrapper around a reference to an element node.

This wrapper implements the Element trait from the selectors crate, which allows it to be matched against CSS selectors.

Implementations

impl<'a> ElementRef<'a>

pub fn wrap(node: NodeRef<'a, Node>) -> Option<Self>

Wraps a NodeRef only if it references a Node::Element.

pub fn value(&self) -> &'a Element

Returns the Element referenced by self.

Examples found in repository

examples/document.rs (line 26)

fn main() {
    let mut stdout = io::stdout();
    let mut input = String::new();
    let stdin = io::stdin();

    write!(stdout, "CSS selector: ").unwrap();
    stdout.flush().unwrap();
    stdin.read_line(&mut input).unwrap();
    let selector = Selector::parse(&input).unwrap();

    write!(stdout, "HTML document:\n").unwrap();
    stdout.flush().unwrap();
    input.clear();
    stdin.read_line(&mut input).unwrap();
    let document = Html::parse_document(&input);

    println!("{:#?}", document);

    for node in document.select(&selector) {
        println!("{:?}", node.value());
    }
}

examples/fragment.rs (line 27)

fn main() {
    let mut stdout = io::stdout();
    let mut input = String::new();
    let stdin = io::stdin();

    write!(stdout, "CSS selector: ").unwrap();
    stdout.flush().unwrap();
    stdin.read_line(&mut input).unwrap();
    let selector = Selector::parse(&input).unwrap();

    write!(stdout, "HTML fragment:\n").unwrap();
    stdout.flush().unwrap();
    input.clear();

    stdin.read_line(&mut input).unwrap();

    let fragment = Html::parse_fragment(&input);

    println!("{:#?}", fragment);

    for node in fragment.select(&selector) {
        println!("{:?}", node.value());
    }
}

pub fn select<'b>(&self, selector: &'b Selector) -> Select<'a, 'b>

Returns an iterator over descendent elements matching a selector.

pub fn html(&self) -> String

Returns the HTML of this element.

pub fn inner_html(&self) -> String

Returns the inner HTML of this element.

pub fn text(&self) -> Text<'a>

Returns an iterator over descendent text nodes.

Methods from Deref<Target = NodeRef<'a, Node>>

pub fn id(&self) -> NodeId

Returns the ID of this node.

pub fn tree(&self) -> &'a Tree<T>

Returns the tree owning this node.

pub fn value(&self) -> &'a T

Returns the value of this node.

pub fn parent(&self) -> Option<NodeRef<'a, T>>

Returns the parent of this node.

pub fn prev_sibling(&self) -> Option<NodeRef<'a, T>>

Returns the previous sibling of this node.

pub fn next_sibling(&self) -> Option<NodeRef<'a, T>>

Returns the next sibling of this node.

pub fn first_child(&self) -> Option<NodeRef<'a, T>>

Returns the first child of this node.

pub fn last_child(&self) -> Option<NodeRef<'a, T>>

Returns the last child of this node.

pub fn has_siblings(&self) -> bool

Returns true if this node has siblings.

pub fn has_children(&self) -> bool

Returns true if this node has children.

pub fn ancestors(&self) -> Ancestors<'a, T>

Returns an iterator over ancestors.

pub fn prev_siblings(&self) -> PrevSiblings<'a, T>

Returns an iterator over previous siblings.

pub fn next_siblings(&self) -> NextSiblings<'a, T>

Returns an iterator over next siblings.

pub fn first_children(&self) -> FirstChildren<'a, T>

Returns an iterator over first children.

pub fn last_children(&self) -> LastChildren<'a, T>

Returns an iterator over last children.

pub fn children(&self) -> Children<'a, T>

Returns an iterator over children.

pub fn traverse(&self) -> Traverse<'a, T>

Returns an iterator which traverses the subtree starting at this node.

pub fn descendants(&self) -> Descendants<'a, T>

Returns an iterator over this node and its descendants.

Trait Implementations

impl<'a> Clone for ElementRef<'a>

fn clone(&self) -> ElementRef<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ElementRef<'a>

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

Formats the value using the given formatter.

impl<'a> Deref for ElementRef<'a>

type Target = NodeRef<'a, Node>

The resulting type after dereferencing.

fn deref(&self) -> &NodeRef<'a, Node>

Dereferences the value.

impl<'a> Element for ElementRef<'a>

Note: will never match against non-tree-structure pseudo-classes.

type Impl = Simple

fn opaque(&self) -> OpaqueElement

Converts self into an opaque representation.

fn parent_element(&self) -> Option<Self>

fn parent_node_is_shadow_root(&self) -> bool

Whether the parent node of this element is a shadow root.

fn containing_shadow_host(&self) -> Option<Self>

The host of the containing shadow root, if any.

fn is_pseudo_element(&self) -> bool

Whether we’re matching on a pseudo-element.

fn is_part(&self, _name: &CssLocalName) -> bool

fn is_same_type(&self, other: &Self) -> bool

Whether this element and the other element have the same local name and namespace.

fn imported_part(&self, _: &CssLocalName) -> Option<CssLocalName>

Returns the mapping from the exportparts attribute in the reverse direction, that is, in an outer-tree -> inner-tree direction.

fn prev_sibling_element(&self) -> Option<Self>

Skips non-element nodes

fn next_sibling_element(&self) -> Option<Self>

Skips non-element nodes

fn is_html_element_in_html_document(&self) -> bool

fn has_local_name(&self, name: &CssLocalName) -> bool

fn has_namespace(&self, namespace: &Namespace) -> bool

Empty string for no namespace

fn attr_matches( &self, ns: &NamespaceConstraint<&Namespace>, local_name: &CssLocalName, operation: &AttrSelectorOperation<&CssString> ) -> bool

fn match_non_ts_pseudo_class<F>( &self, _pc: &NonTSPseudoClass, _context: &mut MatchingContext<'_, Self::Impl>, _flags_setter: &mut F ) -> bool

fn match_pseudo_element( &self, _pe: &PseudoElement, _context: &mut MatchingContext<'_, Self::Impl> ) -> bool

fn is_link(&self) -> bool

Whether this element is a link.

fn is_html_slot_element(&self) -> bool

Returns whether the element is an HTML element.

fn has_id(&self, id: &CssLocalName, case_sensitivity: CaseSensitivity) -> bool

fn has_class( &self, name: &CssLocalName, case_sensitivity: CaseSensitivity ) -> bool

fn is_empty(&self) -> bool

Returns whether this element matches :empty.

fn is_root(&self) -> bool

Returns whether this element matches :root, i.e. whether it is the root element of a document.

fn pseudo_element_originating_element(&self) -> Option<Self>

The parent of a given pseudo-element, after matching a pseudo-element selector.

fn assigned_slot(&self) -> Option<Self>

Returns the assigned element this element is assigned to.

fn ignores_nth_child_selectors(&self) -> bool

Returns whether this element should ignore matching nth child selector.

impl<'a> PartialEq<ElementRef<'a>> for ElementRef<'a>

fn eq(&self, other: &ElementRef<'a>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for ElementRef<'a>

fn serialize<S: Serializer>( &self, serializer: &mut S, traversal_scope: TraversalScope ) -> Result<(), Error>

Take the serializer and call its methods to serialize this type. The type will dictate which methods are called and with what parameters.

impl<'a> Copy for ElementRef<'a>

impl<'a> Eq for ElementRef<'a>

impl<'a> StructuralEq for ElementRef<'a>

impl<'a> StructuralPartialEq for ElementRef<'a>