Trait amq_protocol::frame::parsing::traits::InputIter

pub trait InputIter {
    type Item;
    type Iter: Iterator;
    type IterElem: Iterator;
    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

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

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

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

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

Loading content...

Implementations on Foreign Types

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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

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

impl<'a> InputIter for &'a str

type Item = char

type Iter = CharIndices<'a>

type IterElem = Chars<'a>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

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

impl<'a, O, T> InputIter for &'a BitSlice<O, T> where
    O: BitOrder,
    T: 'a + BitStore, 

type Item = bool

type Iter = Enumerate<<&'a BitSlice<O, T> as InputIter>::IterElem>

type IterElem = Copied<Iter<'a, O, T>>

pub fn iter_indices(&self) -> <&'a BitSlice<O, T> as InputIter>::Iter

pub fn iter_elements(&self) -> <&'a BitSlice<O, T> as InputIter>::IterElem

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

pub 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>>

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

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

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

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

Loading content...

Implementors

Loading content...