Trait nom8::input::InputIter

pub trait InputIter {
    type Item;
    type Iter: Iterator<Item = (usize, Self::Item)>;
    type IterElem: Iterator<Item = Self::Item>;

    // Required methods
    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) -> Result<usize, Needed>;
}

Abstracts common iteration operations on the input type

Required 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

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) -> Result<usize, Needed>

Get the byte offset from the element’s position in the stream

Implementations on Foreign Types

impl<'a> InputIter for &'a str

type Item = char

type Iter = CharIndices<'a>

type IterElem = Chars<'a>

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) -> Result<usize, Needed>

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

type Item = u8

type Iter = Enumerate<<&'a [u8] as InputIter>::IterElem>

type IterElem = Copied<Iter<'a, u8>>

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) -> Result<usize, Needed>

impl<'a, const LEN: usize> InputIter for &'a [u8; LEN]

type Item = u8

type Iter = Enumerate<<&'a [u8; LEN] as InputIter>::IterElem>

type IterElem = Copied<Iter<'a, u8>>

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) -> Result<usize, Needed>

Implementors

impl<I> InputIter for Located<I>where I: InputIter,

type Item = <I as InputIter>::Item

type Iter = <I as InputIter>::Iter

type IterElem = <I as InputIter>::IterElem

impl<I> InputIter for Streaming<I>where I: InputIter,

type Item = <I as InputIter>::Item

type Iter = <I as InputIter>::Iter

type IterElem = <I as InputIter>::IterElem

impl<I, S> InputIter for Stateful<I, S>where I: InputIter,

type Item = <I as InputIter>::Item

type Iter = <I as InputIter>::Iter

type IterElem = <I as InputIter>::IterElem