Trait Handler 

pub trait Handler:
    Send
    + Sync
    + 'static {
    // Required method
    fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
        &'life0 self,
        req: &'life1 mut Request,
        depot: &'life2 mut Depot,
        res: &'life3 mut Response,
        ctrl: &'life4 mut FlowCtrl,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where 'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait,
             'life4: 'async_trait,
             Self: 'async_trait;

    // Provided methods
    fn arc(self) -> ArcHandler
       where Self: Sized { ... }
    fn hooped<H>(self) -> HoopedHandler
       where H: Handler,
             Self: Sized { ... }
    fn hoop<H>(self, hoop: H) -> HoopedHandler
       where H: Handler,
             Self: Sized { ... }
    fn hoop_when<H, F>(self, hoop: H, filter: F) -> HoopedHandler
       where Self: Sized,
             H: Handler,
             F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static { ... }
}

Handler is used for handle Request.

View module level documentation for more details.

Required Methods

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Self: 'async_trait,

Handle http request.

Provided Methods

fn arc(self) -> ArcHandler

where Self: Sized,

Wrap to ArcHandler.

fn hooped<H>(self) -> HoopedHandler

where H: Handler, Self: Sized,

Wrap to HoopedHandler.

fn hoop<H>(self, hoop: H) -> HoopedHandler

where H: Handler, Self: Sized,

Hoop this handler with middleware.

fn hoop_when<H, F>(self, hoop: H, filter: F) -> HoopedHandler

where Self: Sized, H: Handler, F: Fn(&Request, &Depot) -> bool + Send + Sync + 'static,

Hoop this handler with middleware.

This middleware is only effective when the filter returns true..

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Handler for AffixList

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, __macro_gen_req: &'life1 mut Request, __macro_gen_depot: &'life2 mut Depot, __macro_gen_res: &'life3 mut Response, __macro_gen_ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, AffixList: 'async_trait,

impl Handler for CachingHeaders

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, CachingHeaders: 'async_trait,

impl Handler for CatchPanic

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, CatchPanic: 'async_trait,

impl Handler for CorsHandler

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, CorsHandler: 'async_trait,

impl Handler for ETag

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, ETag: 'async_trait,

impl Handler for ForceHttps

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, ForceHttps: 'async_trait,

impl Handler for MaxConcurrency

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, MaxConcurrency: 'async_trait,

impl Handler for MaxSize

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, MaxSize: 'async_trait,

impl Handler for Modified

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Modified: 'async_trait,

impl Handler for RequestId

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, RequestId: 'async_trait,

impl Handler for Timeout

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Timeout: 'async_trait,

impl Handler for TrailingSlash

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, TrailingSlash: 'async_trait,

impl<A, B, C, D, E, F, G, H> Handler for (A, B, C, D, E, F, G, H)

where A: Handler, B: Handler, C: Handler, D: Handler, E: Handler, F: Handler, G: Handler, H: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B, C, D, E, F, G, H): 'async_trait,

impl<A, B, C, D, E, F, G> Handler for (A, B, C, D, E, F, G)

where A: Handler, B: Handler, C: Handler, D: Handler, E: Handler, F: Handler, G: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B, C, D, E, F, G): 'async_trait,

impl<A, B, C, D, E, F> Handler for (A, B, C, D, E, F)

where A: Handler, B: Handler, C: Handler, D: Handler, E: Handler, F: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B, C, D, E, F): 'async_trait,

impl<A, B, C, D, E> Handler for (A, B, C, D, E)

where A: Handler, B: Handler, C: Handler, D: Handler, E: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B, C, D, E): 'async_trait,

impl<A, B, C, D> Handler for (A, B, C, D)

where A: Handler, B: Handler, C: Handler, D: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B, C, D): 'async_trait,

impl<A, B, C> Handler for (A, B, C)

where A: Handler, B: Handler, C: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B, C): 'async_trait,

impl<A, B> Handler for (A, B)

where A: Handler, B: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A, B): 'async_trait,

impl<A> Handler for (A,)

where A: Handler,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, (A,): 'async_trait,

impl<S, I> Handler for Cache<S, I>

where S: CacheStore<Key = <I as CacheIssuer>::Key>, I: CacheIssuer,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, Cache<S, I>: 'async_trait,

impl<Svc, QB, SB, E, Fut> Handler for TowerServiceHandler<Svc, QB>

where QB: TryFrom<ReqBody> + Body + Send + Sync + 'static, <QB as TryFrom<ReqBody>>::Error: Error + Send + Sync + 'static, SB: Body + Send + Sync + 'static, <SB as Body>::Data: Into<Bytes> + Send + Debug + 'static, <SB as Body>::Error: Error + Send + Sync + 'static, E: Error + Send + Sync + 'static, Svc: Service<Request<QB>, Response = Response<SB>, Future = Fut> + Send + Sync + Clone + 'static, <Svc as Service<Request<QB>>>::Error: Error + Send + Sync + 'static, Fut: Future<Output = Result<Response<SB>, E>> + Send + 'static,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, _depot: &'life2 mut Depot, res: &'life3 mut Response, _ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, TowerServiceHandler<Svc, QB>: 'async_trait,

impl<Svc, QB, SB, E> Handler for TowerLayerHandler<Svc, QB>

where QB: TryFrom<ReqBody> + Body + Send + Sync + 'static, <QB as TryFrom<ReqBody>>::Error: Error + Send + Sync + 'static, SB: Body + Send + Sync + 'static, <SB as Body>::Data: Into<Bytes> + Send + Debug + 'static, <SB as Body>::Error: Error + Send + Sync + 'static, E: Error + Send + Sync + 'static, Svc: Service<Request<QB>, Response = Response<SB>> + Send + 'static, <Svc as Service<Request<QB>>>::Future: Future<Output = Result<Response<SB>, E>> + Send + 'static, <Svc as Service<Request<QB>>>::Error: Error + Send + Sync,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, TowerLayerHandler<Svc, QB>: 'async_trait,

impl<V> Handler for BasicAuth<V>

where V: BasicAuthValidator + 'static,

fn handle<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, req: &'life1 mut Request, depot: &'life2 mut Depot, res: &'life3 mut Response, ctrl: &'life4 mut FlowCtrl, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, BasicAuth<V>: 'async_trait,

Implementors

impl Handler for ArcHandler

impl Handler for AuthorityMiddleware

impl Handler for DefaultGoal

impl Handler for ExceptionFilter

impl Handler for HoopedHandler

impl Handler for Logger

impl Handler for OpenApi

impl Handler for RapiDoc

impl Handler for ReDoc

impl Handler for RequestLogMiddleware

impl Handler for Scalar

impl Handler for SecureMaxSize

impl Handler for SwaggerUi

impl Handler for handle_add

impl Handler for handle_delete

impl Handler for handle_info

impl Handler for handle_list

impl Handler for handle_page

impl Handler for handle_update

impl<C, D> Handler for JwtAuth<C, D>

where C: DeserializeOwned + Clone + Send + Sync + 'static, D: JwtAuthDecoder + Send + Sync + 'static,