[−]Enum actix_web::actix::fut::Either
Combines two different futures yielding the same item and error types into a single type.
Variants
A(A)First branch of the type
B(B)Second branch of the type
Methods
impl<T, A, B> Either<(T, A), (T, B)>
impl<T, A, B> Either<(T, A), (T, B)>pub fn split(self) -> (T, Either<A, B>)
pub fn split(self) -> (T, Either<A, B>)Splits out the homogeneous type from an either of tuples.
This method is typically useful when combined with the Future::select2
combinator.
Trait Implementations
impl<A, B> Debug for Either<A, B> where
A: Debug,
B: Debug,
impl<A, B> Debug for Either<A, B> where
A: Debug,
B: 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> ActorFuture for Either<A, B> where
A: ActorFuture,
B: ActorFuture<Item = <A as ActorFuture>::Item, Error = <A as ActorFuture>::Error, Actor = <A as ActorFuture>::Actor>,
impl<A, B> ActorFuture for Either<A, B> where
A: ActorFuture,
B: ActorFuture<Item = <A as ActorFuture>::Item, Error = <A as ActorFuture>::Error, Actor = <A as ActorFuture>::Actor>, type Item = <A as ActorFuture>::Item
The type of value that this future will resolved with if it is successful. Read more
type Error = <A as ActorFuture>::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<<A as ActorFuture>::Item>, <B as ActorFuture>::Error>
fn poll(
&mut self,
act: &mut <A as ActorFuture>::Actor,
ctx: &mut <<A as ActorFuture>::Actor as Actor>::Context
) -> Result<Async<<A as ActorFuture>::Item>, <B as ActorFuture>::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> Send for Either<A, B> where
A: Send,
B: Send,
impl<A, B> Send for Either<A, B> where
A: Send,
B: Send, impl<A, B> Sync for Either<A, B> where
A: Sync,
B: Sync,
impl<A, B> Sync for Either<A, B> where
A: Sync,
B: 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.