Struct sfo_http::http_server::utils::After

pub struct After<F>(pub F);

Define a middleware that operates on outgoing responses.

This middleware is useful because it is not possible in Rust yet to use closures to define inline middleware.

Examples

use tide::{utils, http, Response};

let mut app = tide::new();
app.with(utils::After(|res: Response| async move {
    match res.status() {
        http::StatusCode::NotFound => Ok("Page not found".into()),
        http::StatusCode::InternalServerError => Ok("Something went wrong".into()),
        _ => Ok(res),
    }
}));

Tuple Fields

0: F

Trait Implementations

impl<F> Debug for After<F>where F: Debug,

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

Formats the value using the given formatter.

impl<State, F, Fut> Middleware<State> for After<F>where State: Clone + Send + Sync + 'static, F: Fn(Response) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Response, Error>> + Send + Sync + 'static,

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, request: Request<State>, next: Next<'life1, State> ) -> Pin<Box<dyn Future<Output = Result<Response, Error>> + Send + 'async_trait, Global>>where 'life0: 'async_trait, 'life1: 'async_trait, After<F>: 'async_trait,

Asynchronously handle the request, and return a response.

fn name(&self) -> &str

Set the middleware’s name. By default it uses the type signature.