Struct Middlewares

pub struct Middlewares { /* private fields */ }

The middleware chain which can append other middlewares.

This is a canonical implementation of Iron’s middleware system, but Iron’s infrastructure is flexible enough to allow alternate systems.

Implementations

impl Middlewares

pub fn new<H>(handler: H) -> Self

where H: Handler,

Construct a new middleware chain from a Handler.

pub fn link<B, A>(&mut self, link: (B, A)) -> &mut Middlewares

where A: AfterMiddleware, B: BeforeMiddleware,

Link both a before and after middleware to the chain at once.

Middleware that have a Before and After piece should have a constructor which returns both as a tuple, so it can be passed directly to link.

pub fn link_before<B>(&mut self, before: B) -> &mut Middlewares

where B: BeforeMiddleware,

Link a BeforeMiddleware to the Middlewares chain, after all previously linked BeforeMiddlewares.

pub fn link_after<A>(&mut self, after: A) -> &mut Middlewares

where A: AfterMiddleware,

Link a AfterMiddleware to the Middlewares chain, after all previously linked AfterMiddlewares.

pub async fn link_around<A>(&mut self, around: A) -> &mut Middlewares

where A: AroundMiddleware,

Apply an AroundMiddleware to the Handler in this Middlewares chain.

Trait Implementations

impl Handler for Middlewares

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, req: &'life1 mut Request, ) -> Pin<Box<dyn Future<Output = Result<Response>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Produce a Response from a Request, with the possibility of error.