Trait cosworth::prelude::server::HttpHandler

pub trait HttpHandler: 'static {
    type Task: HttpHandlerTask;

    fn handle(&self, req: Request) -> Result<Self::Task, Request>;
}

Low level http request handler

Required Associated Types

type Task: HttpHandlerTask

Request handling task

Required Methods

fn handle(&self, req: Request) -> Result<Self::Task, Request>

Handle request

Trait Implementations

impl HttpHandler for Box<dyn HttpHandler<Task = Box<dyn HttpHandlerTask + 'static, Global>> + 'static, Global>

type Task = Box<dyn HttpHandlerTask + 'static, Global>

Request handling task

fn handle(
    &self,
    req: Request
) -> Result<Box<dyn HttpHandlerTask + 'static, Global>, Request>

Handle request

Implementations on Foreign Types

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

type Task = HttpHandlerTask4<A, B, C, D>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask8<A, B, C, D, E, F, G, H>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D, E, F, G, H) as HttpHandler>::Task, Request>

impl HttpHandler for Box<dyn HttpHandler<Task = Box<dyn HttpHandlerTask + 'static, Global>> + 'static, Global>

type Task = Box<dyn HttpHandlerTask + 'static, Global>

fn handle(
    &self,
    req: Request
) -> Result<Box<dyn HttpHandlerTask + 'static, Global>, Request>

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

type Task = HttpHandlerTask6<A, B, C, D, E, F>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D, E, F) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask3<A, B, C>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask1<A>

fn handle(&self, req: Request) -> Result<<(A,) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask5<A, B, C, D, E>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D, E) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask2<A, B>

fn handle(&self, req: Request) -> Result<<(A, B) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask7<A, B, C, D, E, F, G>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D, E, F, G) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask9<A, B, C, D, E, F, G, H, I>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D, E, F, G, H, I) as HttpHandler>::Task, Request>

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

type Task = HttpHandlerTask10<A, B, C, D, E, F, G, H, I, J>

fn handle(
    &self,
    req: Request
) -> Result<<(A, B, C, D, E, F, G, H, I, J) as HttpHandler>::Task, Request>

Implementors