Trait ntex::web::Handler

pub trait Handler<T, Err>: Clone + 'static where
    Err: ErrorRenderer, {
    type Output: Responder<Err>;
    type Future: Future<Output = Self::Output> + 'static;
    pub fn call(&self, param: T) -> Self::Future;
}

Async fn handler

Associated Types

type Output: Responder<Err>

type Future: Future<Output = Self::Output> + 'static

Loading content...

Required methods

pub fn call(&self, param: T) -> Self::Future

Loading content...

Implementors

impl<F, R, Err> Handler<(), Err> for F where
    F: Fn() -> R + Clone + 'static,
    R: Future + 'static,
    R::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = R

type Output = R::Output

pub fn call(&self, _: ()) -> R

impl<Func, A, B, C, D, E, F, G, H, I, J, Res, Err> Handler<(A, B, C, D, E, F, G, H, I, J), Err> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I, J) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D, E, F, G, H, I, J)) -> Res

impl<Func, A, B, C, D, E, F, G, H, I, Res, Err> Handler<(A, B, C, D, E, F, G, H, I), Err> for Func where
    Func: Fn(A, B, C, D, E, F, G, H, I) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D, E, F, G, H, I)) -> Res

impl<Func, A, B, C, D, E, F, G, H, Res, Err> Handler<(A, B, C, D, E, F, G, H), Err> for Func where
    Func: Fn(A, B, C, D, E, F, G, H) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D, E, F, G, H)) -> Res

impl<Func, A, B, C, D, E, F, G, Res, Err> Handler<(A, B, C, D, E, F, G), Err> for Func where
    Func: Fn(A, B, C, D, E, F, G) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D, E, F, G)) -> Res

impl<Func, A, B, C, D, E, F, Res, Err> Handler<(A, B, C, D, E, F), Err> for Func where
    Func: Fn(A, B, C, D, E, F) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D, E, F)) -> Res

impl<Func, A, B, C, D, E, Res, Err> Handler<(A, B, C, D, E), Err> for Func where
    Func: Fn(A, B, C, D, E) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D, E)) -> Res

impl<Func, A, B, C, D, Res, Err> Handler<(A, B, C, D), Err> for Func where
    Func: Fn(A, B, C, D) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C, D)) -> Res

impl<Func, A, B, C, Res, Err> Handler<(A, B, C), Err> for Func where
    Func: Fn(A, B, C) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B, C)) -> Res

impl<Func, A, B, Res, Err> Handler<(A, B), Err> for Func where
    Func: Fn(A, B) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A, B)) -> Res

impl<Func, A, Res, Err> Handler<(A,), Err> for Func where
    Func: Fn(A) -> Res + Clone + 'static,
    Res: Future + 'static,
    Res::Output: Responder<Err>,
    Err: ErrorRenderer, 

type Future = Res

type Output = Res::Output

pub fn call(&self, param: (A,)) -> Res

Loading content...