Struct QuantifierNOrMore 

pub struct QuantifierNOrMore<I: HaystackItem, A: Matcher<I>, const N: usize>(pub PhantomData<I>, pub PhantomData<A>);

Tuple Fields

0: PhantomData<I>

1: PhantomData<A>

Trait Implementations

impl<I: Clone + HaystackItem, A: Clone + Matcher<I>, const N: usize> Clone for QuantifierNOrMore<I, A, N>

fn clone(&self) -> QuantifierNOrMore<I, A, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: HaystackItem, A: Matcher<I>, const N: usize> Debug for QuantifierNOrMore<I, A, N>

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

Formats the value using the given formatter.

impl<I: Default + HaystackItem, A: Default + Matcher<I>, const N: usize> Default for QuantifierNOrMore<I, A, N>

fn default() -> QuantifierNOrMore<I, A, N>

Returns the “default value” for a type.

impl<I: HaystackItem, A: Matcher<I>, const N: usize> LazyMatcher<I> for QuantifierNOrMore<I, A, N>

type LazyAllMatches<'a, H: HaystackOf<'a, I>> = Chain<IntoIter<usize>, LazyAllMatchesNOrMore<'a, I, H, A, N>>

type LazyAllCaptures<'a, H: HaystackOf<'a, I>> = Chain<IntoIter<(usize, IndexedCaptures)>, LazyAllCapturesNOrMore<'a, I, H, A, N>>

fn lazy_matches<'a, H: HaystackOf<'a, I>>(hay: &mut H) -> bool

Functions exactly the same as Matcher::matches, except that the haystack’s index is left at the first location where the match is considered successful.

fn lazy_all_matches<'a, H: HaystackOf<'a, I>>( hay: &mut H, ) -> Self::LazyAllMatches<'a, H>

Functions exactly the same as Matcher::all_matches, except that the indices are produced in the opposite order. The first value returned by the iterator is the one first encountered in the haystack, not the one that produces the longest match.

fn lazy_captures<'a, H: HaystackOf<'a, I>>( hay: &mut H, caps: &mut IndexedCaptures, ) -> bool

Functions exactly the same as Matcher::captures, except that the haystack’s index and captures represent the first location where the match is considered successful.

fn lazy_all_captures<'a, H: HaystackOf<'a, I>>( hay: &mut H, caps: &mut IndexedCaptures, ) -> Self::LazyAllCaptures<'a, H>

Functions exactly the same as Matcher::all_captures, except that the indices and captures are produced in the opposite order. The first value returned by the iterator is the one first encountered in the haystack, not the one that produces the longest match.

impl<I: HaystackItem, A: Matcher<I>, const N: usize> Matcher<I> for QuantifierNOrMore<I, A, N>

type AllMatches<'a, H: HaystackOf<'a, I>> = Rev<IntoIter<usize>>

type AllCaptures<'a, H: HaystackOf<'a, I>> = Rev<IntoIter<(usize, IndexedCaptures)>>

fn matches<'a, H: HaystackOf<'a, I>>(hay: &mut H) -> bool

Checks if the start of the haystack contains a match for this Matcher. If this method successfully matches the start of the haystack, hay is progressed so that hay.item() hasn’t been matched yet. On a fail, the state of hay is undefined.

fn all_matches<'a, H: HaystackOf<'a, I>>(hay: &mut H) -> Self::AllMatches<'a, H>

Produces a Vec of all valid haystack states produced as the result of a valid match at the start of hay, used to implement backtracking. The Vec is produced in reverse priority order, so the last match has the highest priority. After calling all_matches, the state of hay itself is undefined.

fn captures<'a, H: HaystackOf<'a, I>>( hay: &mut H, caps: &mut IndexedCaptures, ) -> bool

Checks if the start of the haystack contains a match for this Matcher, writing any groups to caps. Similar to matches, this method progresses hay and caps on a success. On a fail, they have undefined states.

fn all_captures<'a, H: HaystackOf<'a, I>>( hay: &mut H, caps: &mut IndexedCaptures, ) -> Self::AllCaptures<'a, H>

Produces a Vec of all valid captures (and accompanying haystack states) present at the start of hay. Used to implement backtracking for capturing methods. As with all_matches, the resulting Vec is produced in reverse priority order. After calling all_captures, the state of hay and caps are undefined.

impl<I: Copy + HaystackItem, A: Copy + Matcher<I>, const N: usize> Copy for QuantifierNOrMore<I, A, N>