Struct ucglib::tokenizer::TokenIter

pub struct TokenIter<'a> {
    pub source: &'a [Token],
}

TokenIter wraps a slice of Tokens and implements the various necessary nom traits to use it as an input to nom parsers.

Fields

source: &'a [Token]

Methods

impl<'a> TokenIter<'a>

pub fn len(&self) -> usize

Trait Implementations

impl<'a> Clone for TokenIter<'a>

fn clone(&self) -> TokenIter<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TokenIter<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for TokenIter<'a>

fn eq(&self, other: &TokenIter<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TokenIter<'a>) -> bool

This method tests for !=.

impl<'a> InputLength for TokenIter<'a>

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

impl<'a> Slice<Range<usize>> for TokenIter<'a>

fn slice(&self, range: Range<usize>) -> Self

impl<'a> Slice<RangeTo<usize>> for TokenIter<'a>

fn slice(&self, range: RangeTo<usize>) -> Self

impl<'a> Slice<RangeFrom<usize>> for TokenIter<'a>

fn slice(&self, range: RangeFrom<usize>) -> Self

impl<'a> Slice<RangeFull> for TokenIter<'a>

fn slice(&self, range: RangeFull) -> Self

impl<'a> Index<usize> for TokenIter<'a>

type Output = Token

The returned type after indexing.

fn index(&self, i: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> InputIter for TokenIter<'a>

type Item = &'a Token

type RawItem = Token

type Iter = Enumerate<Iter<'a, Self::RawItem>>

type IterElem = Iter<'a, Self::RawItem>

fn iter_indices(&self) -> Self::Iter

returns an iterator over the elements and their byte offsets

fn iter_elements(&self) -> Self::IterElem

returns an iterator over the elements

fn position<P>(&self, predicate: P) -> Option<usize> where     P: Fn(Self::RawItem) -> bool,

finds the byte position of the element

fn slice_index(&self, count: usize) -> Option<usize>

get the byte offset from the element's position in the stream