[]Trait actix_web::actix::fut::ActorStream

pub trait ActorStream {
    type Item;
    type Error;
    type Actor: Actor;
    fn poll(
        &mut self,
        srv: &mut Self::Actor,
        ctx: &mut <Self::Actor as Actor>::Context
    ) -> Result<Async<Option<Self::Item>>, Self::Error>; fn map<U, F>(self, f: F) -> StreamMap<Self, F>
    where
        F: FnMut(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U
, { ... }
fn map_err<E, F>(self, f: F) -> StreamMapErr<Self, F>
    where
        F: FnMut(Self::Error, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> E
, { ... }
fn then<F, U>(self, f: F) -> StreamThen<Self, F, U>
    where
        F: FnMut(Result<Self::Item, Self::Error>, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
        U: IntoActorFuture<Actor = Self::Actor>
, { ... }
fn and_then<F, U>(self, f: F) -> StreamAndThen<Self, F, U>
    where
        F: FnMut(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
        U: IntoActorFuture<Error = Self::Error, Actor = Self::Actor>
, { ... }
fn fold<F, T, Fut>(self, init: T, f: F) -> StreamFold<Self, F, Fut, T>
    where
        F: FnMut(T, Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> Fut,
        Fut: IntoActorFuture<Actor = Self::Actor, Item = T>,
        Self::Error: From<<Fut as IntoActorFuture>::Error>
, { ... }
fn timeout(self, timeout: Duration, err: Self::Error) -> StreamTimeout<Self>
    where
        Self::Error: Clone
, { ... }
fn finish(self) -> StreamFinish<Self> { ... } }

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

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

Associated Types

The type of item this stream will yield on success.

The type of error this stream may generate.

The actor within which this stream runs.

Required Methods

Provided Methods

Converts a stream of type T to a stream of type U.

Converts a stream of error type T to a stream of error type E.

Chain on a computation for when a value is ready, passing the resulting item to the provided closure f.

Chain on a computation for when a value is ready, passing the successful results to the provided closure f.

Execute an accumulating computation over a stream, collecting all the values into one final result.

Add timeout to stream.

err value get returned as a timeout error.

Converts a stream to a future that resolves when stream finishes.

Implementors

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

impl<S> ActorStream for StreamTimeout<S> where
    S: ActorStream,
    <S as ActorStream>::Error: Clone

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

impl<S, F, U> ActorStream for StreamAndThen<S, F, U> where
    F: FnMut(<S as ActorStream>::Item, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U,
    S: ActorStream,
    U: IntoActorFuture<Actor = <S as ActorStream>::Actor, Error = <S as ActorStream>::Error>, 

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

impl<S, F, U> ActorStream for StreamMapErr<S, F> where
    F: FnMut(<S as ActorStream>::Error, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U,
    S: ActorStream

impl<S, F, U> ActorStream for StreamThen<S, F, U> where
    F: FnMut(Result<<S as ActorStream>::Item, <S as ActorStream>::Error>, &mut <S as ActorStream>::Actor, &mut <<S as ActorStream>::Actor as Actor>::Context) -> U,
    S: ActorStream,
    U: IntoActorFuture<Actor = <S as ActorStream>::Actor>,