Struct yak_sitter::QueryMatches

pub struct QueryMatches<'query, 'tree: 'query, Custom = ()> { /* private fields */ }

Wrapper around tree_sitter::QueryMatches

tree_sitter::QueryMatches is NOT a real iterator, it’s a StreamingIterator (see https://github.com/tree-sitter/tree-sitter/issues/608). Therefore this doesn’t implement Iterator

Implementations

impl<'query, 'tree: 'query, Custom> QueryMatches<'query, 'tree, Custom>

pub fn as_inner( &self ) -> &QueryMatches<'query, 'tree, &'query Tree<Custom>, &'query str>

Get the underlying tree_sitter::QueryMatches

pub fn as_inner_mut( &mut self ) -> &mut QueryMatches<'query, 'tree, &'query Tree<Custom>, &'query str>

Get the underlying tree_sitter::QueryMatches

pub fn into_inner( self ) -> (QueryMatches<'query, 'tree, &'query Tree<Custom>, &'query str>, &'query Query, &'tree Tree<Custom>)

Destruct into the underlying tree_sitter::QueryMatches, query, and tree

Trait Implementations

impl<'query, 'tree: 'query, Custom> StreamingIterator for QueryMatches<'query, 'tree, Custom>

type Item = QueryMatch<'query, 'tree, Custom>

The type of the elements being iterated over.

fn advance(&mut self)

Advances the iterator to the next element.

fn get(&self) -> Option<&Self::Item>

Returns a reference to the current element of the iterator.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn next(&mut self) -> Option<&Self::Item>

Advances the iterator and returns the next value.

fn is_done(&self) -> bool

Checks if get() will return None.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Determines if all elements of the iterator satisfy a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Determines if any elements of the iterator satisfy a predicate.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Borrows an iterator, rather than consuming it.

fn chain<I>(self, other: I) -> Chain<Self, I>

where Self: Sized, I: StreamingIterator<Item = Self::Item>,

Consumes two iterators and returns a new iterator that iterates over both in sequence.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of remaining elements and returning it.

fn filter<F>(self, f: F) -> Filter<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, B, F>

where Self: Sized, F: FnMut(&Self::Item) -> Option<B>,

Creates an iterator which both filters and maps by applying a closure to elements.

fn flat_map<J, F>(self, f: F) -> FlatMap<Self, J, F>

where Self: Sized, J: StreamingIterator, F: FnMut(&Self::Item) -> J,

Creates an iterator which flattens iterators obtained by applying a closure to elements. Note that the returned iterators must be streaming iterators.

fn filter_map_deref<B, F>(self, f: F) -> FilterMapDeref<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> Option<B>,

Creates a regular, non-streaming iterator which both filters and maps by applying a closure to elements.

fn find<F>(&mut self, f: F) -> Option<&Self::Item>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Returns the first element of the iterator that satisfies the predicate.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which is “well behaved” at the beginning and end of iteration.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where F: FnMut(&Self::Item), Self: Sized,

Call a closure on each element, passing the element on. The closure is called upon calls to advance or advance_back, and exactly once per element regardless of how many times (if any) get is called.

fn map<B, F>(self, f: F) -> Map<Self, B, F>

where Self: Sized, F: FnMut(&Self::Item) -> B,

Creates an iterator which transforms elements of this iterator by passing them to a closure.

fn map_deref<B, F>(self, f: F) -> MapDeref<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> B,

Creates a regular, non-streaming iterator which transforms elements of this iterator by passing them to a closure.

fn map_ref<B, F>(self, f: F) -> MapRef<Self, F>

where Self: Sized, F: Fn(&Self::Item) -> &B, B: ?Sized,

Creates an iterator which transforms elements of this iterator by passing them to a closure.

fn nth(&mut self, n: usize) -> Option<&Self::Item>

Consumes the first n elements of the iterator, returning the next one.

fn position<F>(&mut self, f: F) -> Option<usize>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Returns the index of the first element of the iterator matching a predicate.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator which skips the first n elements.

fn skip_while<F>(self, f: F) -> SkipWhile<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates an iterator that skips initial elements matching a predicate.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator which only returns the first n elements.

fn take_while<F>(self, f: F) -> TakeWhile<Self, F>

where Self: Sized, F: FnMut(&Self::Item) -> bool,

Creates an iterator which only returns initial elements matching a predicate.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, &Self::Item) -> B,

Reduces the iterator’s elements to a single, final value.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(&Self::Item),

Calls a closure on each element of an iterator.

impl<'query, 'tree: 'query, Custom> StreamingIteratorMut for QueryMatches<'query, 'tree, Custom>

fn get_mut(&mut self) -> Option<&mut Self::Item>

Returns a mutable reference to the current element of the iterator.

fn next_mut(&mut self) -> Option<&mut Self::Item>

Advances the iterator and returns the next mutable value.

fn fold_mut<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, &mut Self::Item) -> B,

Reduces the iterator’s mutable elements to a single, final value.

fn for_each_mut<F>(self, f: F)

where Self: Sized, F: FnMut(&mut Self::Item),

Calls a closure on each mutable element of an iterator.

fn map_deref_mut<B, F>(self, f: F) -> MapDerefMut<Self, F>

where Self: Sized, F: FnMut(&mut Self::Item) -> B,

Creates a regular, non-streaming iterator which transforms mutable elements of this iterator by passing them to a closure.