Enum tower::util::Either[−][src]

pub enum Either<A, B> {
    A(A),
    B(B),
}
This is supported on crate feature util only.
Expand description

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<BoxError>,
    B: Future<Output = Result<T, BE>>,
    BE: Into<BoxError>,  type Output = Result<T, BoxError>;
[src]

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

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

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

Formats the value using the given formatter. Read more

impl<A, B, T, AE, BE> Future for Either<A, B> where
    A: Future<Output = Result<T, AE>>,
    AE: Into<BoxError>,
    B: Future<Output = Result<T, BE>>,
    BE: Into<BoxError>, [src]

type Output = Result<T, BoxError>

The type of value produced on completion.

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

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available. Read more

impl<S, A, B> Layer<S> for Either<A, B> where
    A: Layer<S>,
    B: Layer<S>, [src]

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

The wrapped service

fn layer(&self, inner: S) -> Self::Service[src]

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware. Read more

impl<A, B, Request> Service<Request> for Either<A, B> where
    A: Service<Request>,
    A::Error: Into<BoxError>,
    B: Service<Request, Response = A::Response>,
    B::Error: Into<BoxError>, [src]

type Response = A::Response

Responses given by the service.

type Error = BoxError

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]

Returns Poll::Ready(Ok(())) when the service is able to process requests. Read more

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

Process the request and return the response asynchronously. Read more

impl<'pin, A, B> Unpin for Either<A, B> where
    __Either<'pin, A, B>: Unpin, [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]

Gets the TypeId of self. Read more

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

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

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

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

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

Performs the conversion.

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

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

Map this future’s output to a different type, returning a new future of the resulting type. Read more

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

Map this future’s output to a different type, returning a new future of the resulting type. Read more

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

Chain on a computation for when a future finished, passing the result of the future to the provided closure f. Read more

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

Wrap this future in an Either future, making it the left-hand variant of that Either. Read more

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

Wrap this future in an Either future, making it the right-hand variant of that Either. Read more

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

Convert this future into a single element stream. Read more

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

Flatten the execution of this future when the output of this future is itself another future. Read more

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

Flatten the execution of this future when the successful result of this future is a stream. Read more

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

Fuse a future such that poll will never again be called once it has completed. This method can be used to turn any Future into a FusedFuture. Read more

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

Do something with the output of a future before passing it on. Read more

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

Catches unwinding panics while polling the future. Read more

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

Create a cloneable handle to this future where all handles will resolve to the same result. Read more

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

Turn this future into a future that yields () on completion and sends its output to another future on a separate task. Read more

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

Wrap the future in a Box, pinning it. Read more

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

Wrap the future in a Box, pinning it. Read more

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

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = ()>. Read more

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

Turns a Future<Output = T> into a TryFuture<Ok = T, Error = Never>. Read more

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

A convenience for calling Future::poll on Unpin future types.

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

Evaluates and consumes the future, returning the resulting output if the future is ready after the first call to Future::poll. Read more

impl<T> Instrument for T[src]

fn instrument(self, span: Span) -> Instrumented<Self>[src]

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>[src]

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

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

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

Performs the conversion.

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]

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

Creates a future from a value.

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<&'a mut T, T::Error>;
 where
    Self: Sized, [src]

This is supported on crate feature util only.

Yields a mutable reference to the service when it is ready to accept a request.

fn ready_and(&mut self) -> ReadyAnd<'_, Self, Request> where
    Self: Sized, [src]

👎 Deprecated since 0.4.6:

please use the ServiceExt::ready method instead

This is supported on crate feature util only.

Yields a mutable reference to the service when it is ready to accept a 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]

This is supported on crate feature util only.

Yields the service when it is ready to accept a 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]

This is supported on crate feature util only.

Consume this Service, calling with the providing request once it is ready.

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

This is supported on crate feature util only.

Process all requests from the given Stream, and produce a Stream of their responses. Read more

fn and_then<F>(self, f: F) -> AndThen<Self, F> where
    Self: Sized,
    F: Clone, [src]

This is supported on crate feature util only.

Executes a new future after this service’s future resolves. This does not alter the behaviour of the poll_ready method. Read more

fn map_response<F, Response>(self, f: F) -> MapResponse<Self, F> where
    Self: Sized,
    F: FnOnce(Self::Response) -> Response + Clone, [src]

This is supported on crate feature util only.

Maps this service’s response value to a different value. This does not alter the behaviour of the poll_ready method. Read more

fn map_err<F, Error>(self, f: F) -> MapErr<Self, F> where
    Self: Sized,
    F: FnOnce(Self::Error) -> Error + Clone, [src]

This is supported on crate feature util only.

Maps this service’s error value to a different value. This does not alter the behaviour of the poll_ready method. Read more

fn map_result<F, Response, Error>(self, f: F) -> MapResult<Self, F> where
    Self: Sized,
    Error: From<Self::Error>,
    F: FnOnce(Result<Self::Response, Self::Error>) -> Result<Response, Error> + Clone, [src]

This is supported on crate feature util only.

Maps this service’s result type (Result<Self::Response, Self::Error>) to a different value, regardless of whether the future succeeds or fails. Read more

fn map_request<F, NewRequest>(self, f: F) -> MapRequest<Self, F> where
    Self: Sized,
    F: FnMut(NewRequest) -> Request + Clone, [src]

This is supported on crate feature util only.

Composes a function in front of the service. Read more

fn filter<F, NewRequest>(self, filter: F) -> Filter<Self, F> where
    Self: Sized,
    F: Predicate<NewRequest>, [src]

This is supported on crate features util and filter only.

Composes this service with a Filter that conditionally accepts or rejects requests based on a predicate. Read more

fn filter_async<F, NewRequest>(self, filter: F) -> AsyncFilter<Self, F> where
    Self: Sized,
    F: AsyncPredicate<NewRequest>, [src]

This is supported on crate features util and filter only.

Composes this service with an AsyncFilter that conditionally accepts or rejects requests based on an [async predicate]. Read more

fn then<F, Response, Error, Fut>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    Error: From<Self::Error>,
    F: FnOnce(Result<Self::Response, Self::Error>) -> Fut + Clone,
    Fut: Future<Output = Result<Response, Error>>, [src]

This is supported on crate feature util only.

Composes an asynchronous function after this service. Read more

fn map_future<F, Fut, Response, Error>(self, f: F) -> MapFuture<Self, F> where
    Self: Sized,
    F: FnMut(Self::Future) -> Fut,
    Error: From<Self::Error>,
    Fut: Future<Output = Result<Response, Error>>, [src]

This is supported on crate feature util only.

Composes a function that transforms futures produced by the service. Read more

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]

Creates owned data from borrowed data, usually by cloning. Read more

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

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> 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<U>>::Error>[src]

Performs the conversion.

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]

Poll this TryFuture as if it were a Future. Read more

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

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

Flattens the execution of this future when the successful result of this future is a [Sink]. Read more

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

Maps this future’s success value to a different value. Read more

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

Maps this future’s success value to a different value, and permits for error handling resulting in the same type. Read more

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

Maps this future’s error value to a different value. Read more

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

Maps this future’s Error to a new error type using the Into trait. Read more

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

Maps this future’s Ok to a new type using the Into trait. Read more

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

Executes another future after this one resolves successfully. The success value is passed to a closure to create this subsequent future. Read more

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

Executes another future if this one resolves to an error. The error value is passed to a closure to create this subsequent future. Read more

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

Do something with the success value of a future before passing it on. Read more

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

Do something with the error value of a future before passing it on. Read more

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

Flatten the execution of this future when the successful result of this future is another future. Read more

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

Flatten the execution of this future when the successful result of this future is a stream. Read more

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

Unwraps this future’s output, producing a future with this future’s Ok type as its Output type. Read more

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

Wraps a TryFuture into a type that implements Future. Read more

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

A convenience method for calling TryFuture::try_poll on Unpin future types. Read more

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

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

pub fn vzip(self) -> V