Trait salvo::Handler

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

Required methods

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

Implementations on Foreign Types

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F): 'async_trait, 

impl<A> Handler for (A,) where
    A: Handler, 

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

impl<A, B, C, D, E, F, G, H, I, J, K, L> Handler for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: Handler,
    E: Handler,
    B: Handler,
    H: Handler,
    L: Handler,
    A: Handler,
    D: Handler,
    F: Handler,
    G: Handler,
    K: Handler,
    I: Handler,
    J: Handler, 

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J, K, L): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I): 'async_trait, 

impl<A, B, C, D, E, F, G, H, I, J, K> Handler for (A, B, C, D, E, F, G, H, I, J, K) where
    C: Handler,
    E: Handler,
    B: Handler,
    H: Handler,
    A: Handler,
    D: Handler,
    F: Handler,
    G: Handler,
    K: Handler,
    I: Handler,
    J: Handler, 

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J, K): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E): 'async_trait, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> Handler for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    C: Handler,
    E: Handler,
    B: Handler,
    H: Handler,
    L: Handler,
    A: Handler,
    D: Handler,
    F: Handler,
    G: Handler,
    K: Handler,
    I: Handler,
    M: Handler,
    J: Handler, 

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J, K, L, M): 'async_trait, 

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

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

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Handler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    C: Handler,
    N: Handler,
    E: Handler,
    B: Handler,
    H: Handler,
    L: Handler,
    P: Handler,
    A: Handler,
    D: Handler,
    F: Handler,
    G: Handler,
    K: Handler,
    O: Handler,
    I: Handler,
    M: Handler,
    J: Handler, 

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C): 'async_trait, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Handler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    C: Handler,
    N: Handler,
    E: Handler,
    B: Handler,
    H: Handler,
    L: Handler,
    A: Handler,
    D: Handler,
    F: Handler,
    G: Handler,
    K: Handler,
    O: Handler,
    I: Handler,
    M: Handler,
    J: Handler, 

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G): 'async_trait, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Handler for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    C: Handler,
    N: Handler,
    E: Handler,
    B: Handler,
    H: Handler,
    L: Handler,
    A: Handler,
    D: Handler,
    F: Handler,
    G: Handler,
    K: Handler,
    I: Handler,
    M: Handler,
    J: Handler, 

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J, K, L, M, N): 'async_trait, 

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

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    req: &'life1 mut Request,
    depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    (A, B, C, D, E, F, G, H, I, J): 'async_trait, 

impl<C> Handler for JwtHandler<C> where
    C: DeserializeOwned + Sync + Send + 'static, 

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

impl Handler for ProxyHandler

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

impl Handler for StaticDir

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

impl Handler for CompressionHandler

pub fn handle<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 self,
    _req: &'life1 mut Request,
    _depot: &'life2 mut Depot,
    res: &'life3 mut Response
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    CompressionHandler: 'async_trait, 

impl Handler for CorsHandler

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

impl Handler for StaticFile

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

impl Handler for BasicAuthHandler

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

Implementors