Trait amadeus_core::pipe::Pipe

pub trait Pipe<Input> {
    type Output;
    fn poll_next(
        self: Pin<&mut Self>, 
        cx: &mut Context, 
        stream: Pin<&mut impl Stream<Item = Input>>
    ) -> Poll<Option<Self::Output>>;

    fn pipe<P>(self, pipe: P) -> PipePipe<Self, P>
    where
        P: Pipe<Self::Output>,
        Self: Sized,
    { ... }
    fn sink<S>(self, sink: S) -> PipeSink<Self, S>
    where
        S: Sink<Self::Output>,
        Self: Sized,
    { ... }
    fn filter<F>(self, f: F) -> Filter<Self, F>
    where
        F: FnMut(&Self::Output) -> bool,
        Self: Sized,
    { ... }
    fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R>
    where
        F: FnMut(Self::Output) -> R,
        R: Stream,
        Self: Sized,
    { ... }
    fn flatten(self) -> Flatten<Self, Self::Output>
    where
        Self::Output: Stream,
        Self: Sized,
    { ... }
    fn map<F, R>(self, f: F) -> Map<Self, F>
    where
        F: FnMut(Self::Output) -> R,
        Self: Sized,
    { ... }
}

Associated Types

type Output

Loading content...

Required methods

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

Loading content...

Provided methods

fn pipe<P>(self, pipe: P) -> PipePipe<Self, P> where
    P: Pipe<Self::Output>,
    Self: Sized, 

fn sink<S>(self, sink: S) -> PipeSink<Self, S> where
    S: Sink<Self::Output>,
    Self: Sized, 

fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Output) -> bool,
    Self: Sized, 

fn flat_map<F, R>(self, f: F) -> FlatMap<Self, F, R> where
    F: FnMut(Self::Output) -> R,
    R: Stream,
    Self: Sized, 

fn flatten(self) -> Flatten<Self, Self::Output> where
    Self::Output: Stream,
    Self: Sized, 

fn map<F, R>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Output) -> R,
    Self: Sized, 

Loading content...

Implementations on Foreign Types

impl<A: Pipe<Input>, B: Pipe<Input, Output = A::Output>, Input> Pipe<Input> for Sum2<A, B>

type Output = A::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<P, Input> Pipe<Input> for Pin<P> where
    P: DerefMut + Unpin,
    P::Target: Pipe<Input>, 

type Output = <P::Target as Pipe<Input>>::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<T: ?Sized, Input, '_> Pipe<Input> for &'_ mut T where
    T: Pipe<Input> + Unpin, 

type Output = T::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

Loading content...

Implementors

impl<'a, C, Input: 'a, T: 'a> Pipe<&'a Input> for ClonedTask<C> where
    C: Pipe<&'a Input, Output = &'a T>,
    T: Clone, 

type Output = T

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = &'a Input>>
) -> Poll<Option<Self::Output>>

impl<A, B, C, Input, RefAItem> Pipe<Input> for JoinStreamTaskAsync<A, B, C, RefAItem, A::Output> where
    A: Pipe<Input>,
    B: Pipe<A::Output>,
    C: Pipe<RefAItem>, 

type Output = Sum2<B::Output, C::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<A, B, Input> Pipe<Input> for PipePipe<A, B> where
    A: Pipe<Input>,
    B: Pipe<A::Output>, 

type Output = B::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<C: Pipe<Input>, F, Input> Pipe<Input> for InspectTask<C, F> where
    F: for<'a> FnMut<(&'a C::Output,), Output = ()> + Clone, 

type Output = C::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<C: Pipe<Input>, F, Input> Pipe<Input> for UpdateTask<C, F> where
    F: for<'a> FnMut<(&'a mut C::Output,), Output = ()> + Clone, 

type Output = C::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input> Pipe<Input> for AsyncTuple0<Input> where
    Input: , 

type Output = Sum0

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>> Pipe<Input> for AsyncTuple1<Input, C0> where
    Input: , 

type Output = Sum1<C0::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>> Pipe<Input> for AsyncTuple2<Input, C0, C1> where
    Input: Copy, 

type Output = Sum2<C0::Output, C1::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>> Pipe<Input> for AsyncTuple3<Input, C0, C1, C2> where
    Input: Copy, 

type Output = Sum3<C0::Output, C1::Output, C2::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>> Pipe<Input> for AsyncTuple4<Input, C0, C1, C2, C3> where
    Input: Copy, 

type Output = Sum4<C0::Output, C1::Output, C2::Output, C3::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>> Pipe<Input> for AsyncTuple5<Input, C0, C1, C2, C3, C4> where
    Input: Copy, 

type Output = Sum5<C0::Output, C1::Output, C2::Output, C3::Output, C4::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>, C5: Pipe<Input>> Pipe<Input> for AsyncTuple6<Input, C0, C1, C2, C3, C4, C5> where
    Input: Copy, 

type Output = Sum6<C0::Output, C1::Output, C2::Output, C3::Output, C4::Output, C5::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>, C5: Pipe<Input>, C6: Pipe<Input>> Pipe<Input> for AsyncTuple7<Input, C0, C1, C2, C3, C4, C5, C6> where
    Input: Copy, 

type Output = Sum7<C0::Output, C1::Output, C2::Output, C3::Output, C4::Output, C5::Output, C6::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Input, C0: Pipe<Input>, C1: Pipe<Input>, C2: Pipe<Input>, C3: Pipe<Input>, C4: Pipe<Input>, C5: Pipe<Input>, C6: Pipe<Input>, C7: Pipe<Input>> Pipe<Input> for AsyncTuple8<Input, C0, C1, C2, C3, C4, C5, C6, C7> where
    Input: Copy, 

type Output = Sum8<C0::Output, C1::Output, C2::Output, C3::Output, C4::Output, C5::Output, C6::Output, C7::Output>

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<Item> Pipe<Item> for IdentityTask

type Output = Item

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Item>>
) -> Poll<Option<Self::Output>>

impl<P: Pipe<Input>, F, Input> Pipe<Input> for Filter<P, F> where
    F: for<'a> FnMut<(&'a P::Output,), Output = bool>, 

type Output = P::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<P: Pipe<Input>, F, Input> Pipe<Input> for Map<P, F> where
    F: FnMut<(P::Output,)>, 

type Output = F::Output

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<P: Pipe<Input>, F, R, Input> Pipe<Input> for FlatMap<P, F, R> where
    F: FnMut<(P::Output,), Output = R>,
    R: Stream, 

type Output = R::Item

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

impl<P: Pipe<Input>, Input> Pipe<Input> for Flatten<P, P::Output> where
    P::Output: Stream, 

type Output = <P::Output as Stream>::Item

fn poll_next(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Input>>
) -> Poll<Option<Self::Output>>

Loading content...