[−][src]Trait nom::InputIter

pub trait InputIter {
    type Item;
    type Iter: Iterator<Item = (usize, Self::Item)>;
    type IterElem: Iterator<Item = Self::Item>;
    fn iter_indices(&self) -> Self::Iter;
    fn iter_elements(&self) -> Self::IterElem;
    fn position<P>(&self, predicate: P) -> Option<usize>
    where
        P: Fn(Self::Item) -> bool;
    fn slice_index(&self, count: usize) -> Option<usize>;
}

abstracts common iteration operations on the input type

Associated Types

`type Item`

the current input type is a sequence of that Item type.

example: u8 for &[u8] or char for &str`

`type Iter: Iterator<Item = (usize, Self::Item)>`

an iterator over the input type, producing the item and its position for use with Slice. If we're iterating over &str, the position corresponds to the byte index of the character

`type IterElem: Iterator<Item = Self::Item>`

an iterator over the input type, producing the item

Loading content...

Required methods

`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::Item) -> 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

Loading content...

Implementations on Foreign Types

`impl<'a> InputIter for &'a [u8]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a str`[src]

`type Item = char`

`type Iter = CharIndices<'a>`

`type IterElem = Chars<'a>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 0]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 1]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 2]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 3]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 4]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 5]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 6]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 7]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 8]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 9]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 10]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 11]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 12]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 13]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 14]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 15]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 16]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 17]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 18]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 19]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 20]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 21]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 22]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 23]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 24]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 25]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 26]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 27]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 28]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 29]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 30]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 31]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

`impl<'a> InputIter for &'a [u8; 32]`[src]

`type Item = u8`

`type Iter = Enumerate<Self::IterElem>`

`type IterElem = Map<Iter<'a, Self::Item>, fn(_: &u8) -> u8>`

`fn iter_indices(&self) -> Self::Iter`[src]

`fn iter_elements(&self) -> Self::IterElem`[src]

`fn position<P>(&self, predicate: P) -> Option<usize> where P: Fn(Self::Item) -> bool,` [src]

`fn slice_index(&self, count: usize) -> Option<usize>`[src]

Loading content...

Implementors

Loading content...