Trait actix_web::actix::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

type Item

The type of item this stream will yield on success.

type Error

The type of error this stream may generate.

type Actor: Actor

The actor within which this stream runs.

Loading content...

Required methods

fn poll(
    &mut self,
    srv: &mut Self::Actor,
    ctx: &mut <Self::Actor as Actor>::Context
) -> Result<Async<Option<Self::Item>>, Self::Error>

Loading content...

Provided methods

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, 

Converts a stream of type T to a stream of type 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, 

Converts a stream of error type T to a stream of error type 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>, 

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

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>, 

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

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>, 

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

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

Add timeout to stream.

err value get returned as a timeout error.

fn finish(self) -> StreamFinish<Self>

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

Loading content...

Implementors

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

type Item = ()

type Error = ()

type Actor = A

fn poll(
    &mut self,
    act: &mut <IntervalFunc<A> as ActorStream>::Actor,
    ctx: &mut <<IntervalFunc<A> as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<<IntervalFunc<A> as ActorStream>::Item>>, <IntervalFunc<A> as ActorStream>::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>

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

type Item = <S as ActorStream>::Item

type Error = <S as ActorStream>::Error

type Actor = <S as ActorStream>::Actor

fn poll(
    &mut self,
    act: &mut <S as ActorStream>::Actor,
    ctx: &mut <<S as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<<S as ActorStream>::Item>>, <S as ActorStream>::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>

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

type Item = <S as Stream>::Item

type Error = <S as Stream>::Error

type Actor = A

fn poll(
    &mut self,
    &mut <StreamWrap<S, A> as ActorStream>::Actor,
    &mut <<StreamWrap<S, A> as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<<StreamWrap<S, A> as ActorStream>::Item>>, <StreamWrap<S, A> as ActorStream>::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>

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>, 

type Item = <U as IntoActorFuture>::Item

type Error = <S as ActorStream>::Error

type Actor = <S as ActorStream>::Actor

fn poll(
    &mut self,
    act: &mut <S as ActorStream>::Actor,
    ctx: &mut <<S as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<<U as IntoActorFuture>::Item>>, <S as ActorStream>::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>

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, 

type Item = U

type Error = <S as ActorStream>::Error

type Actor = <S as ActorStream>::Actor

fn poll(
    &mut self,
    act: &mut <StreamMap<S, F> as ActorStream>::Actor,
    ctx: &mut <<S as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<U>>, <S as ActorStream>::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>

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, 

type Item = <S as ActorStream>::Item

type Error = U

type Actor = <S as ActorStream>::Actor

fn poll(
    &mut self,
    act: &mut <StreamMapErr<S, F> as ActorStream>::Actor,
    ctx: &mut <<S as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<<S as ActorStream>::Item>>, U>

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>

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>, 

type Item = <U as IntoActorFuture>::Item

type Error = <U as IntoActorFuture>::Error

type Actor = <S as ActorStream>::Actor

fn poll(
    &mut self,
    act: &mut <S as ActorStream>::Actor,
    ctx: &mut <<S as ActorStream>::Actor as Actor>::Context
) -> Result<Async<Option<<U as IntoActorFuture>::Item>>, <U as IntoActorFuture>::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>

Loading content...