[−][src]Struct actix_web::actix::fut::AndThen
Future for the and_then combinator, chaining a computation onto the end of
another future which completes successfully.
This is created by the Future::and_then method.
Trait Implementations
impl<A, B, F> ActorFuture for AndThen<A, B, F> where
A: ActorFuture,
B: IntoActorFuture<Actor = <A as ActorFuture>::Actor, Error = <A as ActorFuture>::Error>,
F: FnOnce(<A as ActorFuture>::Item, &mut <A as ActorFuture>::Actor, &mut <<A as ActorFuture>::Actor as Actor>::Context) -> B, [src]
A: ActorFuture,
B: IntoActorFuture<Actor = <A as ActorFuture>::Actor, Error = <A as ActorFuture>::Error>,
F: FnOnce(<A as ActorFuture>::Item, &mut <A as ActorFuture>::Actor, &mut <<A as ActorFuture>::Actor as Actor>::Context) -> B,
type Item = <B as IntoActorFuture>::Item
The type of value that this future will resolved with if it is successful. Read more
type Error = <B as IntoActorFuture>::Error
The type of error that this future will resolve with if it fails in a normal fashion. Read more
type Actor = <A as ActorFuture>::Actor
The actor within which this future runs
fn poll(
&mut self,
act: &mut <A as ActorFuture>::Actor,
ctx: &mut <<A as ActorFuture>::Actor as Actor>::Context
) -> Result<Async<<B as IntoActorFuture>::Item>, <B as IntoActorFuture>::Error>[src]
&mut self,
act: &mut <A as ActorFuture>::Actor,
ctx: &mut <<A as ActorFuture>::Actor as Actor>::Context
) -> Result<Async<<B as IntoActorFuture>::Item>, <B as IntoActorFuture>::Error>
fn map<F, U>(self, f: F) -> Map<Self, F> where
F: FnOnce(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U, [src]
F: FnOnce(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> U,
Map this future's result to a different type, returning a new future of the resulting type. Read more
fn map_err<F, E>(self, f: F) -> MapErr<Self, F> where
F: FnOnce(Self::Error, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> E, [src]
F: FnOnce(Self::Error, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> E,
Map this future's error to a different error, returning a new future.
fn drop_err(self) -> DropErr<Self>[src]
Drop this future's error, returning a new future.
fn from_err<E>(self) -> FromErr<Self, E> where
E: From<Self::Error>, [src]
E: From<Self::Error>,
Map this future's error to any error implementing From for this future's Error, returning a new future. Read more
fn then<F, B>(self, f: F) -> Then<Self, B, F> where
B: IntoActorFuture<Actor = Self::Actor>,
F: FnOnce(Result<Self::Item, Self::Error>, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B, [src]
B: IntoActorFuture<Actor = Self::Actor>,
F: FnOnce(Result<Self::Item, Self::Error>, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B,
Chain on a computation for when a future finished, passing the result of the future to the provided closure f. Read more
fn and_then<F, B>(self, f: F) -> AndThen<Self, B, F> where
B: IntoActorFuture<Error = Self::Error, Actor = Self::Actor>,
F: FnOnce(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B, [src]
B: IntoActorFuture<Error = Self::Error, Actor = Self::Actor>,
F: FnOnce(Self::Item, &mut Self::Actor, &mut <Self::Actor as Actor>::Context) -> B,
Execute another future after this one has resolved successfully.
fn timeout(self, timeout: Duration, err: Self::Error) -> Timeout<Self>[src]
Add timeout to futures chain. Read more
impl<A, B, F> Debug for AndThen<A, B, F> where
A: Debug + ActorFuture,
B: Debug + IntoActorFuture<Actor = <A as ActorFuture>::Actor>,
F: Debug,
<B as IntoActorFuture>::Future: Debug, [src]
A: Debug + ActorFuture,
B: Debug + IntoActorFuture<Actor = <A as ActorFuture>::Actor>,
F: Debug,
<B as IntoActorFuture>::Future: Debug,
Auto Trait Implementations
impl<A, B, F> Send for AndThen<A, B, F> where
A: Send,
F: Send,
<B as IntoActorFuture>::Future: Send,
A: Send,
F: Send,
<B as IntoActorFuture>::Future: Send,
impl<A, B, F> Sync for AndThen<A, B, F> where
A: Sync,
F: Sync,
<B as IntoActorFuture>::Future: Sync,
A: Sync,
F: Sync,
<B as IntoActorFuture>::Future: Sync,
Blanket Implementations
impl<T, U> Into for T where
U: From<T>, [src]
U: From<T>,
impl<T> From for T[src]
impl<T, U> TryFrom for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T> Borrow for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<T, U> TryInto for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<T> Erased for T
impl<A, T> ContextFutureSpawner for T where
A: Actor,
T: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
<A as Actor>::Context: AsyncContext<A>, [src]
A: Actor,
T: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
<A as Actor>::Context: AsyncContext<A>,
fn spawn(self, ctx: &mut <A as Actor>::Context)[src]
fn wait(self, ctx: &mut <A as Actor>::Context)[src]
impl<F> IntoActorFuture for F where
F: ActorFuture, [src]
F: ActorFuture,
type Future = F
The future that this type can be converted into.
type Item = <F as ActorFuture>::Item
The item that the future may resolve with.
type Error = <F as ActorFuture>::Error
The error that the future may resolve with.
type Actor = <F as ActorFuture>::Actor
The actor within which this future runs