Trait actix::fut::stream::ActorStream

pub trait ActorStream<A: Actor> {
    type Item;
    fn poll_next(
        self: Pin<&mut Self>, 
        srv: &mut A, 
        ctx: &mut A::Context, 
        task: &mut Context<'_>
    ) -> Poll<Option<Self::Item>>;
}

A stream of values, not all of which may have been produced yet.

This is similar to futures_util::stream::Stream trait, except it works with Actor

Associated Types

type Item

The type of item this stream will yield on success.

Required methods

fn poll_next(
    self: Pin<&mut Self>,
    srv: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>

Implementors

impl<A: Actor> ActorStream<A> for IntervalFunc<A>

type Item = ()

fn poll_next(
    self: Pin<&mut Self>,
    act: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>

impl<S, A> ActorStream<A> for StreamWrap<S, A> where
    S: Stream,
    A: Actor, 

type Item = S::Item

fn poll_next(
    self: Pin<&mut Self>,
    _: &mut A,
    _: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>

impl<S, A> ActorStream<A> for Timeout<S> where
    S: ActorStream<A>,
    A: Actor, 

type Item = Result<S::Item, ()>

fn poll_next(
    self: Pin<&mut Self>,
    act: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Result<S::Item, ()>>>

impl<S, A, F, Fut> ActorStream<A> for SkipWhile<S, S::Item, F, Fut> where
    S: ActorStream<A>,
    A: Actor,
    F: FnMut(&S::Item, &mut A, &mut A::Context) -> Fut,
    Fut: ActorFuture<A, Output = bool>, 

type Item = S::Item

fn poll_next(
    self: Pin<&mut Self>,
    act: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>

impl<S, A, F, Fut> ActorStream<A> for TakeWhile<S, S::Item, F, Fut> where
    S: ActorStream<A>,
    A: Actor,
    F: FnMut(&S::Item, &mut A, &mut A::Context) -> Fut,
    Fut: ActorFuture<A, Output = bool>, 

type Item = S::Item

fn poll_next(
    self: Pin<&mut Self>,
    act: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>

impl<S, A, F, Fut> ActorStream<A> for Then<S, F, Fut> where
    S: ActorStream<A>,
    A: Actor,
    F: FnMut(S::Item, &mut A, &mut A::Context) -> Fut,
    Fut: ActorFuture<A>, 

type Item = Fut::Output

fn poll_next(
    self: Pin<&mut Self>,
    act: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>

impl<S, A, F, U> ActorStream<A> for Map<S, F> where
    S: ActorStream<A>,
    A: Actor,
    F: FnMut(S::Item, &mut A, &mut A::Context) -> U, 

type Item = U

fn poll_next(
    self: Pin<&mut Self>,
    act: &mut A,
    ctx: &mut A::Context,
    task: &mut Context<'_>
) -> Poll<Option<Self::Item>>