Trait RangedRepeats

pub trait RangedRepeats: Sized {
    // Required method
    fn parse_repeats(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
        min: usize,
        max: usize,
    ) -> Result<Self, Error>;

    // Provided methods
    fn parse_any(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
    ) -> Result<Self, Error> { ... }
    fn parse_many(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
    ) -> Result<Self, Error> { ... }
    fn parse_optional(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
    ) -> Result<Self, Error> { ... }
    fn parse_exactly(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
        n: usize,
    ) -> Result<Self, Error> { ... }
    fn parse_at_most(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
        n: usize,
    ) -> Result<Self, Error> { ... }
    fn parse_at_least(
        tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>,
        n: usize,
    ) -> Result<Self, Error> { ... }
}

A trait for parsing a repeating T with a minimum and maximum limit. Sometimes the number of elements to be parsed is determined at runtime eg. a number of header items needs a matching number of values.

Example

Parse at table with a number of headers followed by values.

let mut token_iter = "
    foo:       bar:
    foo_value  bar_value
".to_token_iter();

let headers = Vec::<Cons<Ident,Colon>>::parse(&mut token_iter).unwrap();
let values = Vec::<Ident>::parse_exactly(&mut token_iter, headers.len()).unwrap();

Required Methods

fn parse_repeats( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, min: usize, max: usize, ) -> Result<Self, Error>

Parse at least min and up to max (inclusive) elements.

Provided Methods

fn parse_any( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, ) -> Result<Self, Error>

Parse any number of elements.

fn parse_many( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, ) -> Result<Self, Error>

Parse at least one element.

fn parse_optional( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, ) -> Result<Self, Error>

Parse zero or one element.

fn parse_exactly( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, n: usize, ) -> Result<Self, Error>

Parse exactly n elements.

fn parse_at_most( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, n: usize, ) -> Result<Self, Error>

Parse at most n elements.

fn parse_at_least( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, n: usize, ) -> Result<Self, Error>

Parse at least n elements.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<T> RangedRepeats for Vec<T>

where T: Parse,

fn parse_repeats( tokens: &mut ShadowCountedIter<'_, <TokenStream as IntoIterator>::IntoIter>, min: usize, max: usize, ) -> Result<Vec<T>, Error>

Implementors

impl<T, D> RangedRepeats for DelimitedVec<T, D>

where T: Parse, D: Parse,

impl<T, S> RangedRepeats for LazyVec<T, S>

where T: Parse, S: Parse,