Enum tower_util::Either[−][src]

pub enum Either<A, B> {
    A(A),
    B(B),
}

Combine two different service types into a single type.

Both services must be of the same request, response, and error types. Either is useful for handling conditional branching in service middleware to different inner service types.

Variants

A(A)

One type of backing Service.

B(B)

The other type of backing Service.

Trait Implementations

`impl<A: Clone, B: Clone> Clone for Either<A, B>`[src]

`fn clone(&self) -> Either<A, B>ⓘNotable traits for Either<A, B> impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<Box<dyn Error + Send + Sync>>, B: Future<Output = Result<T, BE>>, BE: Into<Box<dyn Error + Send + Sync>>, type Output = Result<T, Box<dyn Error + Send + Sync>>;`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<A: Debug, B: Debug> Debug for Either<A, B>`[src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<Box<dyn Error + Send + Sync>>, B: Future<Output = Result<T, BE>>, BE: Into<Box<dyn Error + Send + Sync>>,` [src]

`type Output = Result<T, Box<dyn Error + Send + Sync>>`

The type of value produced on completion.

`fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>`[src]

`impl<A, B> PinnedDrop for Either<A, B>`[src]

`unsafe fn drop(self: Pin<&mut Self>)`[src]

`impl<A, B, Request> Service<Request> for Either<A, B> where A: Service<Request>, A::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Request, Response = A::Response>, B::Error: Into<Box<dyn Error + Send + Sync>>,` [src]

`type Response = A::Response`

Responses given by the service.

`type Error = Box<dyn Error + Send + Sync>`

Errors produced by the service.

`type Future = Either<A::Future, B::Future>`

The future response value.

`fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>`[src]

`fn call(&mut self, request: Request) -> Self::Future`[src]

`impl<'pin, A, B> Unpin for Either<A, B> where __Either<'pin, A, B>: Unpin,` [src]

`impl<A, B> UnsafeUnpin for Either<A, B>`[src]

Auto Trait Implementations

`impl<A, B> RefUnwindSafe for Either<A, B> where A: RefUnwindSafe, B: RefUnwindSafe,`

`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> UnwindSafe for Either<A, B> where A: UnwindSafe, B: UnwindSafe,`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T> FutureExt for T where T: Future + ?Sized,` [src]

`pub fn map<U, F>(self, f: F) -> Map<Self, F> where F: FnOnce(Self::Output) -> U,` [src]

`pub fn map_into(self) -> MapInto<Self, U> where Self::Output: Into,` [src]

`pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnOnce(Self::Output) -> Fut, Fut: Future,` [src]

`pub fn left_future(self) -> Either<Self, B> where B: Future<Output = Self::Output>,` [src]

`pub fn right_future<A>(self) -> Either<A, Self> where A: Future<Output = Self::Output>,` [src]

`pub fn into_stream(self) -> IntoStream<Self>`[src]

`pub fn flatten(self) -> Flatten<Self> where Self::Output: Future,` [src]

`pub fn flatten_stream(self) -> FlattenStream<Self> where Self::Output: Stream,` [src]

`pub fn fuse(self) -> Fuse<Self>`[src]

`pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnOnce(&Self::Output),` [src]

`pub fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,` [src]

`pub fn shared(self) -> Shared<Self> where Self::Output: Clone,` [src]

`pub fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)`[src]

`pub fn boxed<'a>( self ) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where Self: Send + 'a,` [src]

`pub fn boxed_local<'a>( self ) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where Self: 'a,` [src]

`pub fn unit_error(self) -> UnitError<Self>`[src]

`pub fn never_error(self) -> NeverError<Self>`[src]

`pub fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where Self: Unpin,` [src]

`pub fn now_or_never(self) -> Option<Self::Output>`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<F> IntoFuture for F where F: Future,` [src]

`type Output = <F as Future>::Output`

🔬 This is a nightly-only experimental API. (into_future)

The output that the future will produce on completion.

`type Future = F`

🔬 This is a nightly-only experimental API. (into_future)

Which kind of future are we turning this into?

`pub fn into_future(self) -> <F as IntoFuture>::Future`[src]

`impl<T, Request> ServiceExt<Request> for T where T: Service<Request> + ?Sized,` [src]

`fn ready(&mut self) -> Ready<'_, Self, Request>ⓘNotable traits for Ready<'a, T, Request> impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<(), T::Error>; where Self: Sized,` [src]

`fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request>ⓘNotable traits for ReadyAnd<'a, T, Request> impl<'a, T, Request> Future for ReadyAnd<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>; where Self: Sized,` [src]

`fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘNotable traits for ReadyOneshot<T, Request> impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>; where Self: Sized,` [src]

`fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘNotable traits for Oneshot<S, Req> impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>; where Self: Sized,` [src]

`fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where Self: Sized, Self::Error: Into<Error>, S: Stream<Item = Request>,` [src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<F, T, E> TryFuture for F where F: Future<Output = Result<T, E>> + ?Sized,` [src]

`type Ok = T`

The type of successful values yielded by this future

`type Error = E`

The type of failures yielded by this future

`pub fn try_poll( self: Pin<&mut F>, cx: &mut Context<'_> ) -> Poll<<F as Future>::Output>`[src]

`impl<Fut> TryFutureExt for Fut where Fut: TryFuture + ?Sized,` [src]

`pub fn flatten_sink<Item>(self) -> FlattenSink<Self, Self::Ok> where Self::Ok: Sink<Item>, <Self::Ok as Sink<Item>>::Error == Self::Error,` [src]

`pub fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where F: FnOnce(Self::Ok) -> T,` [src]

`pub fn map_ok_or_else<T, E, F>(self, e: E, f: F) -> MapOkOrElse<Self, F, E> where E: FnOnce(Self::Error) -> T, F: FnOnce(Self::Ok) -> T,` [src]

`pub fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where F: FnOnce(Self::Error) -> E,` [src]

`pub fn err_into<E>(self) -> ErrInto<Self, E> where Self::Error: Into<E>,` [src]

`pub fn ok_into(self) -> OkInto<Self, U> where Self::Ok: Into,` [src]

`pub fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where F: FnOnce(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>,` [src]

`pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where F: FnOnce(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>,` [src]

`pub fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where F: FnOnce(&Self::Ok),` [src]

`pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where F: FnOnce(&Self::Error),` [src]

`pub fn try_flatten(self) -> TryFlatten<Self, Self::Ok> where Self::Ok: TryFuture, <Self::Ok as TryFuture>::Error == Self::Error,` [src]

`pub fn try_flatten_stream(self) -> TryFlattenStream<Self> where Self::Ok: TryStream, <Self::Ok as TryStream>::Error == Self::Error,` [src]

`pub fn unwrap_or_else<F>(self, f: F) -> UnwrapOrElse<Self, F> where F: FnOnce(Self::Error) -> Self::Ok,` [src]

`pub fn into_future(self) -> IntoFuture<Self>`[src]

`pub fn try_poll_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Result<Self::Ok, Self::Error>> where Self: Unpin,` [src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, >::Error>`[src]

Enum tower_util::Either[−][src]

Variants

Trait Implementations

impl<A: Clone, B: Clone> Clone for Either<A, B>[src]

Notable traits for Either<A, B>

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<A: Debug, B: Debug> Debug for Either<A, B>[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result[src]

impl<A, B, T, AE, BE> Future for Either<A, B> where A: Future<Output = Result<T, AE>>, AE: Into<Box<dyn Error + Send + Sync>>, B: Future<Output = Result<T, BE>>, BE: Into<Box<dyn Error + Send + Sync>>, [src]

type Output = Result<T, Box<dyn Error + Send + Sync>>

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>[src]

impl<A, B> PinnedDrop for Either<A, B>[src]

unsafe fn drop(self: Pin<&mut Self>)[src]

impl<A, B, Request> Service<Request> for Either<A, B> where A: Service<Request>, A::Error: Into<Box<dyn Error + Send + Sync>>, B: Service<Request, Response = A::Response>, B::Error: Into<Box<dyn Error + Send + Sync>>, [src]

type Response = A::Response

type Error = Box<dyn Error + Send + Sync>

type Future = Either<A::Future, B::Future>

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>[src]

fn call(&mut self, request: Request) -> Self::Future[src]

impl<'pin, A, B> Unpin for Either<A, B> where __Either<'pin, A, B>: Unpin, [src]

impl<A, B> UnsafeUnpin for Either<A, B>[src]

Auto Trait Implementations

impl<A, B> RefUnwindSafe for Either<A, B> where A: RefUnwindSafe, B: RefUnwindSafe,

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> UnwindSafe for Either<A, B> where A: UnwindSafe, B: UnwindSafe,

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T> FutureExt for T where T: Future + ?Sized, [src]

pub fn map<U, F>(self, f: F) -> Map<Self, F> where F: FnOnce(Self::Output) -> U, [src]

pub fn map_into<U>(self) -> MapInto<Self, U> where Self::Output: Into<U>, [src]

pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnOnce(Self::Output) -> Fut, Fut: Future, [src]

pub fn left_future<B>(self) -> Either<Self, B> where B: Future<Output = Self::Output>, [src]

pub fn right_future<A>(self) -> Either<A, Self> where A: Future<Output = Self::Output>, [src]

pub fn into_stream(self) -> IntoStream<Self>[src]

pub fn flatten(self) -> Flatten<Self> where Self::Output: Future, [src]

pub fn flatten_stream(self) -> FlattenStream<Self> where Self::Output: Stream, [src]

pub fn fuse(self) -> Fuse<Self>[src]

pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnOnce(&Self::Output), [src]

pub fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe, [src]

pub fn shared(self) -> Shared<Self> where Self::Output: Clone, [src]

pub fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)[src]

pub fn boxed<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where Self: Send + 'a, [src]

pub fn boxed_local<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where Self: 'a, [src]

pub fn unit_error(self) -> UnitError<Self>[src]

pub fn never_error(self) -> NeverError<Self>[src]

pub fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where Self: Unpin, [src]

pub fn now_or_never(self) -> Option<Self::Output>[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<F> IntoFuture for F where F: Future, [src]

type Output = <F as Future>::Output

type Future = F

pub fn into_future(self) -> <F as IntoFuture>::Future[src]

impl<T, Request> ServiceExt<Request> for T where T: Service<Request> + ?Sized, [src]

fn ready(&mut self) -> Ready<'_, Self, Request>ⓘNotable traits for Ready<'a, T, Request>impl<'a, T, Request> Future for Ready<'a, T, Request> where T: Service<Request>, type Output = Result<(), T::Error>; where Self: Sized, [src]

Notable traits for Ready<'a, T, Request>

fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request>ⓘNotable traits for ReadyAnd<'a, T, Request>impl<'a, T, Request> Future for ReadyAnd<'a, T, Request> where T: Service<Request>, type Output = Result<&'a mut T, T::Error>; where Self: Sized, [src]

Notable traits for ReadyAnd<'a, T, Request>

fn ready_oneshot(self) -> ReadyOneshot<Self, Request>ⓘNotable traits for ReadyOneshot<T, Request>impl<T, Request> Future for ReadyOneshot<T, Request> where T: Service<Request>, type Output = Result<T, T::Error>; where Self: Sized, [src]

Notable traits for ReadyOneshot<T, Request>

fn oneshot(self, req: Request) -> Oneshot<Self, Request>ⓘNotable traits for Oneshot<S, Req>impl<S, Req> Future for Oneshot<S, Req> where S: Service<Req>, type Output = Result<S::Response, S::Error>; where Self: Sized, [src]

Notable traits for Oneshot<S, Req>

fn call_all<S>(self, reqs: S) -> CallAll<Self, S> where Self: Sized, Self::Error: Into<Error>, S: Stream<Item = Request>, [src]

impl<T> ToOwned for T where T: Clone, [src]

type Owned = T

pub fn to_owned(&self) -> T[src]

pub fn clone_into(&self, target: &mut T)[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<F, T, E> TryFuture for F where F: Future<Output = Result<T, E>> + ?Sized, [src]

type Ok = T