[−]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> 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,
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, fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>Formats the value using the given formatter. Read more
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,
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, 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>
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>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,
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, 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,
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, Map this future's error to a different error, returning a new future.
fn drop_err(self) -> DropErr<Self>
fn drop_err(self) -> DropErr<Self>Drop this future's error, returning a new future.
fn from_err<E>(self) -> FromErr<Self, E> where
E: From<Self::Error>,
fn from_err<E>(self) -> FromErr<Self, E> where
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,
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, 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,
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, Execute another future after this one has resolved successfully.
fn timeout(self, timeout: Duration, err: Self::Error) -> Timeout<Self>
fn timeout(self, timeout: Duration, err: Self::Error) -> Timeout<Self>Add timeout to futures chain. Read more
Auto Trait Implementations
impl<A, B, F> Send for AndThen<A, B, F> where
A: Send,
F: Send,
<B as IntoActorFuture>::Future: Send,
impl<A, B, F> Send for AndThen<A, B, F> where
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,
impl<A, B, F> Sync for AndThen<A, B, F> where
A: Sync,
F: Sync,
<B as IntoActorFuture>::Future: Sync, Blanket Implementations
impl<T> From for T[src]
impl<T> From for Timpl<T, U> Into for T where
U: From<T>, [src]
impl<T, U> Into for T where
U: From<T>, impl<T, U> TryFrom for T where
T: From<U>, [src]
impl<T, U> TryFrom for T where
T: From<U>, type Error = !
try_from)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>try_from)Performs the conversion.
impl<T> Borrow for T where
T: ?Sized, [src]
impl<T> Borrow for T where
T: ?Sized, impl<T> BorrowMut for T where
T: ?Sized, [src]
impl<T> BorrowMut for T where
T: ?Sized, fn borrow_mut(&mut self) -> &mut T[src]
fn borrow_mut(&mut self) -> &mut TMutably borrows from an owned value. Read more
impl<T, U> TryInto for T where
U: TryFrom<T>, [src]
impl<T, U> TryInto for T where
U: TryFrom<T>, type Error = <U as TryFrom<T>>::Error
try_from)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>try_from)Performs the conversion.
impl<T> Any for T where
T: 'static + ?Sized, [src]
impl<T> Any for T where
T: 'static + ?Sized, fn get_type_id(&self) -> TypeId[src]
fn get_type_id(&self) -> TypeId🔬 This is a nightly-only experimental API. (get_type_id)
this method will likely be replaced by an associated static
Gets the TypeId of self. Read more
impl<T> Erased for T
impl<T> Erased for Timpl<A, T> ContextFutureSpawner for T where
A: Actor,
T: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
<A as Actor>::Context: AsyncContext<A>,
impl<A, T> ContextFutureSpawner for T where
A: Actor,
T: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
<A as Actor>::Context: AsyncContext<A>, fn spawn(self, ctx: &mut <A as Actor>::Context)
fn spawn(self, ctx: &mut <A as Actor>::Context)spawn future into Context<A>
fn wait(self, ctx: &mut <A as Actor>::Context)
fn wait(self, ctx: &mut <A as Actor>::Context)Spawn future into the context. Stop processing any of incoming events until this future resolves. Read more
impl<F> IntoActorFuture for F where
F: ActorFuture,
impl<F> IntoActorFuture for F where
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
fn into_future(self) -> F
fn into_future(self) -> FConsumes this object and produces a future.