Struct axum::handler::Layered

pub struct Layered<S, T> { /* fields omitted */ }

A Service created from a Handler by applying a Tower middleware.

Created with Handler::layer. See that method for more details.

Implementations

impl<S, T> Layered<S, T>

pub fn handle_error<F, ReqBody, ResBody, Res, E>(
    self,
    f: F
) -> Layered<HandleError<S, F, ReqBody>, T> where
    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
    F: FnOnce(S::Error) -> Result<Res, E>,
    Res: IntoResponse, 

Create a new Layered handler where errors will be handled using the given closure.

This is used to convert errors to responses rather than simply terminating the connection.

It works similarly to routing::Layered::handle_error. See that for more details.

Trait Implementations

impl<S, T> Clone for Layered<S, T> where
    S: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, T> Debug for Layered<S, T> where
    S: Debug, 

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

Formats the value using the given formatter.

impl<S, T, ReqBody, ResBody> Handler<ReqBody, T> for Layered<S, T> where
    S: Service<Request<ReqBody>, Response = Response<ResBody>> + Send,
    S::Error: IntoResponse,
    S::Future: Send,
    ReqBody: Send + 'static,
    ResBody: Body<Data = Bytes> + Send + Sync + 'static,
    ResBody::Error: Into<BoxError> + Send + Sync + 'static, 

type Sealed = Hidden

fn call<'async_trait>(
    self,
    req: Request<ReqBody>
) -> Pin<Box<dyn Future<Output = Response<BoxBody>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Call the handler with the given request.

fn layer<L>(self, layer: L) -> Layered<L::Service, In> where
    L: Layer<IntoService<Self, B, In>>, 

Apply a tower::Layer to the handler.

fn into_service(self) -> IntoService<Self, B, In>

Convert the handler into a Service.