Trait actix::fut::ActorStream[−][src]

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
    ) -> Poll<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,
        Self: Sized,
    { ... }

    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,
        Self: Sized,
    { ... }

    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>,
        Self: Sized,
    { ... }

    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>,
        Self: Sized,
    { ... }

    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::Error>,
        Self: Sized,
    { ... }

    fn timeout(self, timeout: Duration, err: Self::Error) -> StreamTimeout<Self>
    where
        Self: Sized,
        Self::Error: Clone,
    { ... }

    fn finish(self) -> StreamFinish<Self>
    where
        Self: Sized,
    { ... }
}

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