Trait cron_clock::InputIter

pub trait InputIter where
    <Self::Iter as Iterator>::Item == (usize, Self::Item),
    <Self::IterElem as Iterator>::Item == Self::Item, {
    type Item;
    type RawItem;
    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::RawItem) -> bool;
    fn slice_index(&self, count: usize) -> Option<usize>;
}

abstracts common iteration operations on the input type

it needs a distinction between Item and RawItem because &[T] iterates on references

Associated Types

type Item

type RawItem

type Iter: Iterator

type IterElem: Iterator

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

Loading content...

Implementations on Foreign Types

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

type Item = u8

type RawItem = u8

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

type IterElem = Map<Iter<'a, <&'a [u8] as InputIter>::Item>, fn(&u8) -> 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) -> Option<usize>

impl<'a> InputIter for &'a str

type Item = char

type RawItem = 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>::RawItem) -> bool, 

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

Loading content...

Implementors

impl<'a> InputIter for CompleteByteSlice<'a>

type Item = u8

type RawItem = u8

type Iter = Enumerate<<CompleteByteSlice<'a> as InputIter>::IterElem>

type IterElem = Map<Iter<'a, <CompleteByteSlice<'a> as InputIter>::Item>, fn(&u8) -> u8>

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

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

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

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

impl<'a> InputIter for CompleteStr<'a>

type Item = char

type RawItem = char

type Iter = CharIndices<'a>

type IterElem = Chars<'a>

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

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

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

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

impl<T> InputIter for Input<T> where
    T: InputIter, 

type Item = <T as InputIter>::Item

type RawItem = <T as InputIter>::RawItem

type Iter = <T as InputIter>::Iter

type IterElem = <T as InputIter>::IterElem

fn iter_indices(&self) -> <Input<T> as InputIter>::Iter

fn iter_elements(&self) -> <Input<T> as InputIter>::IterElem

fn position<P>(&self, predicate: P) -> Option<usize> where
    P: Fn(<Input<T> as InputIter>::RawItem) -> bool, 

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

Loading content...