Struct regex::RegexSplitsN [] [src]

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

Yields at most N substrings delimited by a regular expression match.

The last substring will be whatever remains after splitting.

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

Trait Implementations

impl<'r, 't> Iterator for RegexSplitsN<'r, 't>

type Item = &'t str

fn next(&mut self) -> Option<&'t str>

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

1.0.0fn count(self) -> usize

1.0.0fn last(self) -> Option<Self::Item>

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

1.0.0fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>

1.0.0fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator

1.0.0fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B

1.0.0fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool

1.0.0fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>

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

1.0.0fn peekable(self) -> Peekable<Self>

1.0.0fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool

1.0.0fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool

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

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

1.0.0fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>

1.0.0fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where U: IntoIterator, F: FnMut(Self::Item) -> U

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

1.0.0fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()

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

1.0.0fn collect<B>(self) -> B where B: FromIterator<Self::Item>

1.0.0fn partition<B, F>(self, f: F) -> (B, B) where F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>

1.0.0fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B

1.0.0fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

1.0.0fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

1.0.0fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool

1.0.0fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool

1.0.0fn rposition<P>(&mut self, predicate: P) -> Option<usize> where Self: ExactSizeIterator + DoubleEndedIterator, P: FnMut(Self::Item) -> bool

1.0.0fn max(self) -> Option<Self::Item> where Self::Item: Ord

1.0.0fn min(self) -> Option<Self::Item> where Self::Item: Ord

fn max_by<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

1.6.0fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

fn min_by<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

1.6.0fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord

1.0.0fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator

1.0.0fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromB: Default + Extend<B>, Self: Iterator<Item=(A, B)>, FromA: Default + Extend<A>

1.0.0fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone

1.0.0fn cycle(self) -> Cycle<Self> where Self: Clone

fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One

1.5.0fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord

1.5.0fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>

1.5.0fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>

1.5.0fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

1.5.0fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>