Struct cron_clock::types::Input

pub struct Input<T> {
    pub inner: T,
    pub at_eof: bool,
}

Fields

inner: T

at_eof: bool

Trait Implementations

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

fn as_bytes(&self) -> &[u8]

impl<T> AtEof for Input<T>

fn at_eof(&self) -> bool

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

fn clone(&self) -> Input<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'b, T> Compare<&'b str> for Input<T> where
    T: Compare<&'b str>, 

fn compare(&self, t: &'b str) -> CompareResult

compares self to another value for equality

fn compare_no_case(&self, t: &'b str) -> CompareResult

compares self to another value for equality independently of the case.

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

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

fn fmt(&self, f: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<'b, T> FindSubstring<&'b str> for Input<T> where
    T: FindSubstring<&'b str>, 

fn find_substring(&self, substr: &'b str) -> Option<usize>

impl<'a, T> FindToken<&'a u8> for Input<T> where
    T: FindToken<&'a u8>, 

fn find_token(&self, token: &'a u8) -> bool

impl<T> FindToken<char> for Input<T> where
    T: FindToken<char>, 

fn find_token(&self, token: char) -> bool

impl<T> FindToken<u8> for Input<T> where
    T: FindToken<u8>, 

fn find_token(&self, token: u8) -> bool

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

fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

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

returns an iterator over the elements and their byte offsets

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

returns an iterator over the elements

fn position<P>(&self, predicate: P) -> Option<usize> where
    P: Fn(<Input<T> as InputIter>::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

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

fn input_len(&self) -> usize

calculates the input length, as indicated by its name, and the name of the trait itself

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

fn take(&self, count: usize) -> Input<T>

returns a slice of count bytes. panics if count > length

fn take_split(&self, count: usize) -> (Input<T>, Input<T>)

split the stream at the count byte offset. panics if count > length

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

fn offset(&self, second: &Input<T>) -> usize

offset between the first byte of self and the first byte of the argument

impl<'a, R, T> ParseTo<R> for Input<T> where
    R: FromStr,
    T: ParseTo<R>, 

fn parse_to(&self) -> Option<R>

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

fn eq(&self, other: &Input<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Input<T>) -> bool

This method tests for !=.

impl<T> Slice<Range<usize>> for Input<T> where
    T: Slice<Range<usize>>, 

fn slice(&self, range: Range<usize>) -> Input<T>

impl<T> Slice<RangeFrom<usize>> for Input<T> where
    T: Slice<RangeFrom<usize>>, 

fn slice(&self, range: RangeFrom<usize>) -> Input<T>

impl<T> Slice<RangeFull> for Input<T> where
    T: Slice<RangeFull>, 

fn slice(&self, range: RangeFull) -> Input<T>

impl<T> Slice<RangeTo<usize>> for Input<T> where
    T: Slice<RangeTo<usize>>, 

fn slice(&self, range: RangeTo<usize>) -> Input<T>

impl<T> StructuralPartialEq for Input<T>