Struct tide::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::{After, Response, http};

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

Trait Implementations

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

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

Formats the value using the given formatter.

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

fn handle<'a>(
    &'a self,
    request: Request<State>,
    next: Next<'a, State>
) -> Pin<Box<dyn Future<Output = Result> + Send + 'a>>

Asynchronously handle the request, and return a response.

fn name(&self) -> &str

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