Struct hyper_middleware::middleware::Chain

pub struct Chain { /* 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 Chain

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

Construct a new Chain from a Handler.

pub fn link<B, A>(&mut self, link: (B, A)) -> &mut Chainwhere
    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 Chainwhere
    B: BeforeMiddleware,

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

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

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

pub fn link_around<A>(&mut self, around: A) -> &mut Chainwhere
    A: AroundMiddleware,

Apply an AroundMiddleware to the Handler in this Chain.

Trait Implementations

impl Handler for Chain

fn handle(&self, req: &mut Request) -> Result<Response>

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