Trait 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>;
}
Expand description

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

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<'a> InputIter for &'a str

§

type Item = char

§

type Iter = CharIndices<'a>

§

type IterElem = Chars<'a>

§

fn iter_indices(&self) -> <&'a str as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a str as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a str as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 0] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 0] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 0] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 1] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 1] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 1] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 2] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 2] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 2] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 3] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 3] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 3] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 4] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 4] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 4] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 5] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 5] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 5] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 6] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 6] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 6] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 7] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 7] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 7] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 8] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 8] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 8] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 9] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 9] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 9] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 10] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 10] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 10] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 11] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 11] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 11] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 12] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 12] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 12] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 13] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 13] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 13] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 14] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 14] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 14] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 15] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 15] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 15] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 16] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 16] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 16] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 17] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 17] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 17] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 18] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 18] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 18] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 19] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 19] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 19] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 20] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 20] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 20] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 21] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 21] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 21] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 22] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 22] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 22] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 23] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 23] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 23] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 24] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 24] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 24] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 25] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 25] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 25] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 26] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 26] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 26] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 27] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 27] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 27] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 28] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 28] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 28] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 29] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 29] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 29] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 30] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 30] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 30] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 31] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 31] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 31] as InputIter>::Item) -> bool,

§

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

§

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

§

type Item = u8

§

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

§

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

§

fn iter_indices(&self) -> <&'a [u8; 32] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8; 32] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8; 32] as InputIter>::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) -> <&'a [u8] as InputIter>::Iter

§

fn iter_elements(&self) -> <&'a [u8] as InputIter>::IterElem

§

fn position<P>(&self, predicate: P) -> Option<usize>
where P: Fn(<&'a [u8] as InputIter>::Item) -> bool,

§

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

Implementors§