Struct soupy::query::Query

pub struct Query<'a, P: Parser<'a>, F: Filter<P::Node>> {
    pub filter: F,
    pub soup: &'a Soup<'a, P>,
}

A query for elements in Soup matching the Filter F

Fields

filter: F

soup: &'a Soup<'a, P>

Trait Implementations

impl<'a, P: Parser<'a>, F: Filter<P::Node>> IntoIterator for Query<'a, P, F>

where &'a P::Node: IntoIterator<Item = &'a P::Node>,

type Item = &'a <P as Parser<'a>>::Node

The type of the elements being iterated over.

type IntoIter = QueryIter<'a, Flatten<Iter<'a, <P as Parser<'a>>::Node>>, P, F>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, P: Parser<'a>, F: Filter<P::Node>> QueryExt<'a, P, F> for Query<'a, P, F>

fn tag<T: Pattern>(self, tag: T) -> Query<'a, P, And<F, Tag<T>>>

where Tag<T>: Filter<P::Node>,

Specifies a tag for which to search

fn attr<N: Pattern, V: Pattern>( self, name: N, value: V ) -> Query<'a, P, And<F, Attr<N, V>>>

where Attr<N, V>: Filter<P::Node>,

Specifies an attribute name/value pair for which to search

fn attr_name<N: Pattern>(self, name: N) -> Query<'a, P, And<F, Attr<N, bool>>>

where Attr<N, bool>: Filter<P::Node>,

Searches for a tag that has an attribute with the specified name

fn attr_value<V: Pattern>(self, value: V) -> Query<'a, P, And<F, Attr<bool, V>>>

where Attr<bool, V>: Filter<P::Node>,

Search for a node with any attribute with a value that matches the specified value

fn class<C: Pattern>( self, class: C ) -> Query<'a, P, And<F, Attr<&'static str, C>>>

where Attr<&'static str, C>: Filter<P::Node>,

Specifies a class name for which to search