Trait amadeus_core::pipe::Sink

pub trait Sink<Source> {
    fn poll_pipe(
        self: Pin<&mut Self>, 
        cx: &mut Context, 
        stream: Pin<&mut impl Stream<Item = Source>>
    ) -> Poll<()>;
}

Required methods

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

Returns Poll::Ready when a) it can't accept any more elements from stream and b) all accepted elements have been fully processed. By convention, stream yielding None typically triggers (a).

Loading content...

Implementations on Foreign Types

impl<P, Source> Sink<Source> for Pin<P> where
    P: DerefMut + Unpin,
    P::Target: Sink<Source>, 

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

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

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

Loading content...

Implementors

impl Sink<Sum0> for ReduceA0Async

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

impl Sink<bool> for BoolAndReducerAsync

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

impl Sink<bool> for BoolOrReducerAsync

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

impl Sink<()> for ReduceC0Async

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

impl<A, C> Sink<A> for FolderSyncReducerAsync<A, C, C::Output> where
    C: FolderSync<A>, 

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

impl<A, F> Sink<A> for AllReducerAsync<A, F> where
    F: FnMut(A) -> bool, 

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

impl<A, F> Sink<A> for AnyReducerAsync<A, F> where
    F: FnMut(A) -> bool, 

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

impl<A, F> Sink<A> for ForEachReducer<A, F> where
    F: FnMut(A) + Clone, 

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

impl<A, T: Extend<A>> Sink<A> for PushReducerAsync<A, T>

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

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, F: ReducerAsync<S5>, G: ReducerAsync<S6>, H: ReducerAsync<S7>, S0, S1, S2, S3, S4, S5, S6, S7> Sink<Sum8<S0, S1, S2, S3, S4, S5, S6, S7>> for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum8<S0, S1, S2, S3, S4, S5, S6, S7>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, F: ReducerAsync<S5>, G: ReducerAsync<S6>, H: ReducerAsync<S7>, S0, S1, S2, S3, S4, S5, S6, S7> Sink<(S0, S1, S2, S3, S4, S5, S6, S7)> for ReduceC8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1, S2, S3, S4, S5, S6, S7)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, F: ReducerAsync<S5>, G: ReducerAsync<S6>, S0, S1, S2, S3, S4, S5, S6> Sink<Sum7<S0, S1, S2, S3, S4, S5, S6>> for ReduceA7Async<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum7<S0, S1, S2, S3, S4, S5, S6>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, F: ReducerAsync<S5>, G: ReducerAsync<S6>, S0, S1, S2, S3, S4, S5, S6> Sink<(S0, S1, S2, S3, S4, S5, S6)> for ReduceC7Async<A, B, C, D, E, F, G, S0, S1, S2, S3, S4, S5, S6>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1, S2, S3, S4, S5, S6)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, F: ReducerAsync<S5>, S0, S1, S2, S3, S4, S5> Sink<Sum6<S0, S1, S2, S3, S4, S5>> for ReduceA6Async<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum6<S0, S1, S2, S3, S4, S5>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, F: ReducerAsync<S5>, S0, S1, S2, S3, S4, S5> Sink<(S0, S1, S2, S3, S4, S5)> for ReduceC6Async<A, B, C, D, E, F, S0, S1, S2, S3, S4, S5>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1, S2, S3, S4, S5)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, S0, S1, S2, S3, S4> Sink<Sum5<S0, S1, S2, S3, S4>> for ReduceA5Async<A, B, C, D, E, S0, S1, S2, S3, S4>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum5<S0, S1, S2, S3, S4>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, E: ReducerAsync<S4>, S0, S1, S2, S3, S4> Sink<(S0, S1, S2, S3, S4)> for ReduceC5Async<A, B, C, D, E, S0, S1, S2, S3, S4>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1, S2, S3, S4)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, S0, S1, S2, S3> Sink<Sum4<S0, S1, S2, S3>> for ReduceA4Async<A, B, C, D, S0, S1, S2, S3>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum4<S0, S1, S2, S3>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, D: ReducerAsync<S3>, S0, S1, S2, S3> Sink<(S0, S1, S2, S3)> for ReduceC4Async<A, B, C, D, S0, S1, S2, S3>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1, S2, S3)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, S0, S1, S2> Sink<Sum3<S0, S1, S2>> for ReduceA3Async<A, B, C, S0, S1, S2>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum3<S0, S1, S2>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, C: ReducerAsync<S2>, S0, S1, S2> Sink<(S0, S1, S2)> for ReduceC3Async<A, B, C, S0, S1, S2>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1, S2)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, S0, S1> Sink<Sum2<S0, S1>> for ReduceA2Async<A, B, S0, S1>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum2<S0, S1>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, B: ReducerAsync<S1>, S0, S1> Sink<(S0, S1)> for ReduceC2Async<A, B, S0, S1>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (S0, S1)>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, S0> Sink<Sum1<S0>> for ReduceA1Async<A, S0>

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = Sum1<S0>>>
) -> Poll<()>

impl<A: ReducerAsync<S0>, S0> Sink<(S0,)> for ReduceC1Async<A, S0>

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

impl<A: IntoIterator<Item = B>, T: Extend<B>, B> Sink<A> for ExtendReducerAsync<A, T>

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

impl<P, R, T, U> Sink<(T, U)> for GroupByReducerAAsync<P, R, R::Async, T, U> where
    P: Pipe<U>,
    R: Reducer<P::Item> + Clone,
    T: Eq + Hash, 

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = (T, U)>>
) -> Poll<()>

impl<P, S, Source> Sink<Source> for PipeSink<P, S> where
    P: Pipe<Source>,
    S: Sink<P::Item>, 

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

impl<R, T, U> Sink<HashMap<T, U, RandomState>> for GroupByReducerBAsync<R, R::Async, T, U> where
    R: Reducer<U> + Clone,
    T: Eq + Hash, 

fn poll_pipe(
    self: Pin<&mut Self>,
    cx: &mut Context,
    stream: Pin<&mut impl Stream<Item = HashMap<T, U>>>
) -> Poll<()>

impl<R: ReducerAsync<Item>, E, Item> Sink<Result<Item, E>> for ResultReducerAsync<R, E>

fn poll_pipe(
    self: Pin<&mut Self>,
    _cx: &mut Context,
    _stream: Pin<&mut impl Stream<Item = Result<Item, E>>>
) -> Poll<()>

impl<R: ReducerAsync<Item>, Item> Sink<Option<Item>> for OptionReducerAsync<R>

fn poll_pipe(
    self: Pin<&mut Self>,
    _cx: &mut Context,
    _stream: Pin<&mut impl Stream<Item = Option<Item>>>
) -> Poll<()>

impl<R: ReducerAsync<Item>, T, Item> Sink<Item> for IntoReducerAsync<R, T> where
    R::Output: Into<T>, 

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

Loading content...