Struct futures_await_syn::delimited::Delimited

pub struct Delimited<T, D> { /* fields omitted */ }

Methods

impl<T, D> Delimited<T, D>

fn new() -> Delimited<T, D>

fn is_empty(&self) -> bool

fn len(&self) -> usize

fn get(&self, idx: usize) -> Element<&T, &D>

fn get_mut(&mut self, idx: usize) -> Element<&mut T, &mut D>

fn first(&self) -> Option<Element<&T, &D>>

fn first_mut(&mut self) -> Option<Element<&mut T, &mut D>>

fn last(&self) -> Option<Element<&T, &D>>

fn last_mut(&mut self) -> Option<Element<&mut T, &mut D>>

fn iter(&self) -> Iter<T, D>

fn iter_mut(&mut self) -> IterMut<T, D>

fn items(&self) -> Items<T, D>

fn push(&mut self, token: Element<T, D>)

fn push_first(&mut self, token: T)

fn push_next(&mut self, token: T, delimiter: D)

fn push_trailing(&mut self, delimiter: D)

fn push_default(&mut self, token: T) where
    D: Default, 

fn pop(&mut self) -> Option<Element<T, D>>

fn into_vec(self) -> Vec<T>

fn trailing_delim(&self) -> bool

impl<T, D> Delimited<T, D> where
    D: Synom,
    T: Synom, 

fn parse_separated(
    input: Cursor
) -> Result<(Cursor, Delimited<T, D>), ParseError>

fn parse_separated_nonempty(
    input: Cursor
) -> Result<(Cursor, Delimited<T, D>), ParseError>

fn parse_terminated(
    input: Cursor
) -> Result<(Cursor, Delimited<T, D>), ParseError>

impl<T, D> Delimited<T, D> where
    D: Synom, 

fn parse_separated_nonempty_with(
    input: Cursor,
    parse: fn(Cursor) -> Result<(Cursor, T), ParseError>
) -> Result<(Cursor, Delimited<T, D>), ParseError>

fn parse_terminated_with(
    input: Cursor,
    parse: fn(Cursor) -> Result<(Cursor, T), ParseError>
) -> Result<(Cursor, Delimited<T, D>), ParseError>

Trait Implementations

impl<T, D> Clone for Delimited<T, D> where
    D: Clone,
    T: Clone, 

fn clone(&self) -> Delimited<T, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, D> From<Vec<(T, Option<D>)>> for Delimited<T, D>

fn from(v: Vec<(T, Option<D>)>) -> Delimited<T, D>

Performs the conversion.

impl<T, D> From<Vec<T>> for Delimited<T, D> where
    D: Default, 

fn from(v: Vec<T>) -> Delimited<T, D>

Performs the conversion.

impl<T, D> IntoIterator for Delimited<T, D>

type Item = Element<T, D>

The type of the elements being iterated over.

type IntoIter = IntoIter<T, D>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T, D>

Creates an iterator from a value.

impl<'a, T, D> IntoIterator for &'a Delimited<T, D>

type Item = Element<&'a T, &'a D>

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, D>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T, D>

Creates an iterator from a value.

impl<T, D> Extend<Element<T, D>> for Delimited<T, D>

fn extend<I>(&mut self, i: I) where
    I: IntoIterator<Item = Element<T, D>>, 

impl<T, D> Extend<T> for Delimited<T, D> where
    D: Default, 

fn extend<I>(&mut self, i: I) where
    I: IntoIterator<Item = T>, 

impl<T, D> FromIterator<T> for Delimited<T, D> where
    D: Default, 

fn from_iter<I>(i: I) -> Delimited<T, D> where
    I: IntoIterator<Item = T>, 

impl<T, D> FromIterator<Element<T, D>> for Delimited<T, D>

fn from_iter<I>(i: I) -> Delimited<T, D> where
    I: IntoIterator<Item = Element<T, D>>, 

impl<T, D> Default for Delimited<T, D>

fn default() -> Delimited<T, D>

Returns the "default value" for a type.

impl<T, D> ToTokens for Delimited<T, D> where
    D: ToTokens,
    T: ToTokens, 

fn to_tokens(&self, tokens: &mut Tokens)

Write self to the given Tokens.

fn into_tokens(self) -> Tokens

Convert self directly into a Tokens object.