Struct pipe_chain::pipe::RepeatPipe

pub struct RepeatPipe<P, O> { /* private fields */ }

Expand description

Trait Implementations§

Produces a Result from an input Read more

Auto Trait Implementations§

Blanket Implementations§

Chains 2 Pipes one after another Read more

Chains 2 Pipes one after another Read more

Chains 2 Pipes one after another Read more

Applies the given closure on the output of the pipe Read more

Applies the given closure on the output of a pipe Read more

Applies the given closure to the output and remaining input of a pipe Read more

Applies the pipes consecutively Read more

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Wraps the current Pipe into a Box Read more

Combine 2 Pipes with the same input and remaining but differents outputs Read more

Combine 2 Pipes with the same input and differents outputs and remaining Read more

Makes non fatal errors fatal

makes fatal errors non fatal

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Maps the output of a pipe O to O2 by applying a function to it. Read more

Maps the output of a pipe O to O2 by applying a function to it. The result is mapped into a tuple Read more

Maps the output of a pipe O to O2 by applying a function to it. The result is mapped into a tuple Read more

Maps an error FatalError<E> to FatalError<E2> by applying a function to the error. Read more

Fails if the given pipe succeeds

Makes a Pipe optional if it returns a non fatal error Read more

Apply the second Pipe if the first fails Read more

Apply the second Pipe if the first fails discarding the output of the second pipe Read more

Apply the second Pipe if the first fails discarding the output of the first pipe Read more

Makes a Pipe optional if it returns a non fatal error Read more

Repeats this pipe. Read more

Discards the output of the pipe Read more

Chains 2 Pipes one after another both output are discarded Read more

Apply the second Pipe if the first fails discarding both output Read more

§

The type returned in the event of a conversion error.

Performs the conversion.

§

The type returned in the event of a conversion error.

Performs the conversion.

Unpacks the output of a pipe Read more

Applies a Pipe until the 2nd succeeds

Applies self until p succeeds, self is applied 0 or more times

repeats self with the given repetition then applies p

wraps self into a function Read more

Struct pipe_chain::pipe::RepeatPipe

Trait Implementations§

impl<I, O, E, P> Pipe<I, (Vec<<O as Unpack>::Output>,), E> for RepeatPipe<P, O>where I: Clone, O: Unpack, P: Pipe<I, O, E> + Sized,

fn apply(&mut self, input: I) -> PResult<I, (Vec<O::Output>,), E>

Auto Trait Implementations§

impl<P, O> RefUnwindSafe for RepeatPipe<P, O>where O: RefUnwindSafe, P: RefUnwindSafe,

impl<P, O> Send for RepeatPipe<P, O>where O: Send, P: Send,

impl<P, O> Sync for RepeatPipe<P, O>where O: Sync, P: Sync,

impl<P, O> Unpin for RepeatPipe<P, O>where O: Unpin, P: Unpin,

impl<P, O> UnwindSafe for RepeatPipe<P, O>where O: UnwindSafe, P: UnwindSafe,

Blanket Implementations§

impl<I, O, E, R, P> AndExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn and<O2, R2, P>(self, p: P) -> And<Self, P, O, O2, R>where Self: Sized, O: Extend<O2>, O2: HList, P: Pipe<R, O2, E, R2>,

fn and_other<O2, R2, P>(self, p: P) -> AndOther<Self, P, O, R>where Self: Sized, P: Pipe<R, O2, E, R2>,

fn and_self<O2, R2, P>(self, other: P) -> AndSelf<Self, P, R, O2>where Self: Sized, P: Pipe<R, O2, E, R2>,

impl<I, O, E, R, P> AndThenExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn and_then<O2, F>(self, f: F) -> AndThen<O, Self, F>where Self: Sized, F: FunMut<O, Output = Result<O2, FatalError<E>>>, O: HList, O2: HList,

fn and_thenf<O2, F>(self, f: F) -> AndThenF<O, Self, F>where Self: Sized, F: FnMut(O) -> Result<O2, FatalError<E>>,

fn ok_and_then<O2, R2, F>(self, other: F) -> OkAndThen<O, R, Self, F>where Self: Sized, F: FunMut<(R, O), Output = Result<(R2, O2), FatalError<E>>>,

fn ok_then<O2, R2, P>(self, other: P) -> OkThen<O, R, Self, P>where Self: Pipe<I, O, E, R> + Sized, P: Pipe<(R, O), O2, E, R2> + Sized,

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<I, O, E, R, P> BoxedExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn boxed<'a>(self) -> BoxedPipe<'a, I, O, E, R>where Self: Pipe<I, O, E, R> + Sized + 'a,

impl<I, O, E, R, P> EitherExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn either<O2, P>(self, p: P) -> EitherPipe<O, O2, Self, P>where I: Clone, Self: Pipe<I, O, E, R> + Sized, P: Pipe<I, O2, E, R>,

fn either_full<O2, R2, P>(self, p: P) -> EitherPipeFull<O, O2, Self, P>where I: Clone, Self: Pipe<I, O, E, R> + Sized, P: Pipe<I, O2, E, R2>,

impl<I, O, E, R, P> ErrExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn escalate(self) -> Escalate<Self>where Self: Sized,

fn deescalate(self) -> Deescalate<Self>where Self: Sized,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<I, O, E, R, P> MapExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn map<F>(self, f: F) -> Map<Self, F, O>where Self: Sized, O: HList, F: FunMut<O>,

fn map1<F>(self, f: F) -> Map1<Self, F, O>where Self: Sized, O: HList, F: FunMut<O>,

fn mapf<O2, F>(self, f: F) -> MapF<Self, F, O>where Self: Sized, F: FnMut(O) -> O2,

fn map_err<E2, F>(self, f: F) -> MapErr<Self, F, E>where Self: Sized, F: FnMut(FatalError<E>) -> FatalError<E2>,

impl<I, O, E, R, P> NotExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn not(self) -> Not<O, R, Self>where I: Clone, O: Debug, Self: Sized,

impl<I, O, E, P> OptExt<I, O, E> for Pwhere P: Pipe<I, O, E>,

fn opt(self) -> Opt<Self, O>where Self: Sized, I: Clone, O: Unpack,

impl<I, O, E, R, P> OrExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn or<P>(self, p: P) -> Or<Self, P>where Self: Sized, I: Clone, P: Pipe<I, O, E, R>,

fn or_self<O2, P>(self, p: P) -> OrSelf<O, O2, Self, P>where Self: Sized, O: Unpack, I: Clone, P: Pipe<I, O2, E, R>,

fn or_other<O2, P>(self, p: P) -> OrOther<O, O2, Self, P>where Self: Sized, I: Clone, O2: Unpack, P: Pipe<I, O2, E, R>,

impl<I, O, E, R, P> PeekExt<I, O, E, R> for Pwhere I: Clone, P: Pipe<I, O, E, R>,

fn peek(self) -> Peek<Self, R>where Self: Sized, I: Clone,

impl<I, O, E, P> RepeatExt<I, O, E> for Pwhere P: Pipe<I, O, E>,

fn repeat<R>(self, r: R) -> RepeatPipe<Self, O>where R: TryInto<Repetition>, R::Error: Error, Self: Pipe<I, O, E> + Sized,

impl<I, O, E, R, P> SkipExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn skip(self) -> Skip<Self, O>where Self: Sized,

fn and_skip<O2, R2, P>(self, other: P) -> AndSkip<Self, P, O, O2, R>where Self: Sized, P: Pipe<R, O2, E, R2>,

fn or_skip<O2, P>(self, p: P) -> OrSkip<O, O2, Self, P>where Self: Sized, I: Clone, P: Pipe<I, O2, E, R>,

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<I, O, E, R, P> UnpackExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn unpack(self) -> UnpackPipe<Self, O>where O: Unpack, Self: Sized,

impl<I, O, E, P> UntilExt<I, O, E> for Pwhere P: Pipe<I, O, E>,

fn until<O2, P>(self, p: P) -> Until<Self, P, O, O2>where I: Clone, O: Unpack, O2: HList, (Vec<O::Output>,): Extend<O2>, Self: Sized, P: Pipe<I, O2, E>,

fn no_more_until<O2, P>(self, p: P) -> NoMoreUntil<Self, P, O, O2>where I: Clone, O: Unpack, O2: HList, (Vec<O::Output>,): Extend<O2>, Self: Sized, P: Pipe<I, O2, E>,

fn repeat_until<O2, R, P>(self, r: R, p: P) -> RepeatUntil<Self, P, O, O2>where I: Clone, O: Unpack, O2: HList, R: TryInto<Repetition>, R::Error: Error, (Vec<O::Output>,): Extend<O2>, Self: Sized, P: Pipe<I, O2, E>,

impl<I, O, E, R, P> WrapExt<I, O, E, R> for Pwhere P: Pipe<I, O, E, R>,

fn wrap<I2, O2, R2, F>(self, f: F) -> Wrap<I, O, R, Self, F>where Self: Pipe<I, O, E, R> + Sized, F: FnMut(&mut Self, I2) -> Result<R2, O2, E>,