Struct MapResult

pub struct MapResult<S, F> { /* private fields */ }

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

This is similar to the MapResponse and MapErr combinators, except that the same function is invoked when the service’s future completes, whether it completes successfully or fails. This function takes the Result returned by the service’s future, and returns a Result.

Like the standard library’s Result::and_then, this method can be used to implement control flow based on Result values. For example, it may be used to implement error recovery, by turning some Err responses from the service into Ok responses. Similarly, some successful responses from the service could be rejected, by returning an Err conditionally, depending on the value inside the [Ok.] Finally, this method can also be used to implement behaviors that must run when a service’s future completes, regardless of whether it succeeded or failed.

This method can be used to change the Response type of the service into a different type. It can also be used to change the Error type of the service.

Implementations

impl<S, F> MapResult<S, F>

pub const fn new(inner: S, f: F) -> MapResult<S, F>

Creates a new MapResult service.

pub fn get_ref(&self) -> &S

Gets a reference to the underlying service.

pub fn into_inner(self) -> S

Consumes self, returning the underlying service.

Trait Implementations

impl<S, F> Clone for MapResult<S, F>

where S: Clone, F: Clone,

fn clone(&self) -> MapResult<S, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S, F> Debug for MapResult<S, F>

where S: Debug,

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

Formats the value using the given formatter.

impl<S, F, State, Request, Response, Error> Service<State, Request> for MapResult<S, F>

where S: Service<State, Request>, F: Fn(Result<<S as Service<State, Request>>::Response, <S as Service<State, Request>>::Error>) -> Result<Response, Error> + Send + Sync + 'static, State: Clone + Send + Sync + 'static, Request: Send + 'static, Response: Send + 'static, Error: Send + 'static,

type Response = Response

The type of response returned by the service.

type Error = Error

The type of error returned by the service.

async fn serve( &self, ctx: Context<State>, req: Request, ) -> Result<<MapResult<S, F> as Service<State, Request>>::Response, <MapResult<S, F> as Service<State, Request>>::Error>

Serve a response or error for the given request, using the given context.

fn boxed(self) -> BoxService<S, Request, Self::Response, Self::Error>

Box this service to allow for dynamic dispatch.