regex

Structs

CapturesErrorFindCapturesFindMatchesNoExpandRegexSplitsRegexSplitsNSubCapturesSubCapturesPos

Traits

Replacer

Functions

is_matchquote

Struct regex::FindMatches[src]

pub struct FindMatches<'r, 't> {
    // some fields omitted
}

An iterator over all non-overlapping matches for a particular string.

The iterator yields a tuple of integers corresponding to the start and end of the match. The indices are byte offsets. The iterator stops when no more matches can be found.

'r is the lifetime of the compiled expression and 't is the lifetime of the matched string.

Trait Implementations

impl<'r, 't> Iterator<(uint, uint)> for FindMatches<'r, 't>

fn next(&mut self) -> Option<(uint, uint)>

fn size_hint<A>(&self) -> (uint, Option<uint>)

fn chain<U: Iterator<A>>(self, other: U) -> Chain<Self, U>

fn zip<B, U: Iterator<B>>(self, other: U) -> Zip<Self, U>

fn map<B>(self, f: |A|: 'r -> B) -> Map<'r, A, B, Self>

fn filter<A>(self, predicate: |&A|: 'r -> bool) -> Filter<'r, A, Self>

fn filter_map<B>(self, f: |A|: 'r -> Option<B>) -> FilterMap<'r, A, B, Self>

fn enumerate<A>(self) -> Enumerate<Self>

fn peekable<A>(self) -> Peekable<A, Self>

fn skip_while<A>(self, predicate: |&A|: 'r -> bool) -> SkipWhile<'r, A, Self>

fn take_while<A>(self, predicate: |&A|: 'r -> bool) -> TakeWhile<'r, A, Self>

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

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

fn scan<St, B>(self, initial_state: St, f: |&mut St, A|: 'r -> Option<B>) -> Scan<'r, A, B, Self, St>

fn flat_map<B, U: Iterator<B>>(self, f: |A|: 'r -> U) -> FlatMap<'r, A, Self, U>

fn fuse<A>(self) -> Fuse<Self>

fn inspect<A>(self, f: |&A|: 'r) -> Inspect<'r, A, Self>

fn by_ref<A>(&'r mut self) -> ByRef<'r, Self>

fn advance<A>(&mut self, f: |A| -> bool) -> bool

fn collect<B: FromIterator<A>>(&mut self) -> B

fn nth<A>(&mut self, n: uint) -> Option<A>

fn last<A>(&mut self) -> Option<A>

fn fold<B>(&mut self, init: B, f: |B, A| -> B) -> B

fn count<A>(&mut self) -> uint

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

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

fn find<A>(&mut self, predicate: |&A| -> bool) -> Option<A>

fn position<A>(&mut self, predicate: |A| -> bool) -> Option<uint>

fn max_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A>

fn min_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A>