Struct feast::pass::SlicePass

pub struct SlicePass<'p, T, E> where
    T: Token,
    E: Error<'p>,  { /* fields omitted */ }

Trait Implementations

impl<'p, T, E> Pass<'p> for SlicePass<'p, T, E> where
    T: Token,
    E: Error<'p, Context = SlicePassContext<'p, T>>, 

type Error = E

type Context = SlicePassContext<'p, T>

fn context(&self) -> &Self::Context

fn into_context(self) -> Self::Context

fn commit(self, rest: PassInput<'p, Self>) -> Self

Commit the remaining input to be used, consuming the changes.

fn input<'ii>(&'ii self) -> PassInput<'i, Self>

Get the input for this pass.

fn with<O>(
    input_result: Result<O, PassInputError<'i, Self>>,
    pass: Self
) -> PassResult<'i, Self, O>

With input result, mapping the error for a pass.

fn input_error(self, err: PassInputError<'i, Self>) -> Self::Error

Create a pass error based on an input error.

fn input_error_incomplete(
    self,
    requirement: CompletionRequirement
) -> Self::Error

Create a pass error based on an incomplete input error.

fn input_error_unexpected(
    self,
    unexpected: UnexpectedToken<'i, PassToken<'i, Self>>
) -> Self::Error

Create a pass error based on an unexpected input error.

fn input_is_empty(&'i self) -> bool

Returns whether or not the input is empty.

fn split_first(
    self
) -> PassResult<'i, Self, (PassToken<'i, Self>, PassInput<'i, Self>)>

Splits the first token from the input.

fn split_pair<E, F>(
    self,
    pred: F
) -> PassResult<'i, Self, (PassSection<'i, Self>, PassInput<'i, Self>)> where
    F: FnMut(&PassToken<'i, Self>) -> bool, 

Splits an input in two, based on a predictate. Will fail if cannot split into a pair.

fn split_at<E>(
    self,
    mid: usize
) -> PassResult<'i, Self, (PassSection<'i, Self>, PassInput<'i, Self>)>

Splits an input in two, from an exact size.

impl<'p, T: PartialEq, E: PartialEq> PartialEq<SlicePass<'p, T, E>> for SlicePass<'p, T, E> where
    T: Token,
    E: Error<'p>, 

fn eq(&self, other: &SlicePass<'p, T, E>) -> bool

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

fn ne(&self, other: &SlicePass<'p, T, E>) -> bool

This method tests for !=.

impl<'p, T: Clone, E: Clone> Clone for SlicePass<'p, T, E> where
    T: Token,
    E: Error<'p>, 

fn clone(&self) -> SlicePass<'p, T, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p, T, E> From<&'p [T]> for SlicePass<'p, T, E> where
    T: Token,
    E: Error<'p, Context = SlicePassContext<'p, T>>, 

fn from(slice: &'p [T]) -> Self

Performs the conversion.

impl<'p, T: Debug, E: Debug> Debug for SlicePass<'p, T, E> where
    T: Token,
    E: Error<'p>, 

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

Formats the value using the given formatter.