Trait Handler

pub trait Handler: Send + Sync {
    type RespBody: Body;
    type Error: Into<Box<dyn Error + Send + Sync>>;
    type Fut<'fut>: Future<Output = Result<Response<Self::RespBody>, Self::Error>>
       where Self: 'fut;

    // Required method
    fn call(&self, req: Request<ReqBody>) -> Self::Fut<'_>;
}

A trait for handling HTTP requests

This trait defines the core interface for processing HTTP requests and generating responses. Implementors of this trait can be used to handle requests in the HTTP server.

Type Parameters

• RespBody: The response body type that implements Body
• Error: The error type that can be converted into a boxed error
• Fut: The future type returned by the handler

Required Associated Types

type RespBody: Body

The type of the response body

type Error: Into<Box<dyn Error + Send + Sync>>

The error type returned by the handler

type Fut<'fut>: Future<Output = Result<Response<Self::RespBody>, Self::Error>> where Self: 'fut

The future type returned by the handler

Required Methods

fn call(&self, req: Request<ReqBody>) -> Self::Fut<'_>

Process an HTTP request and return a future that resolves to a response

Arguments

• req - The HTTP Request to process

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<RespBody, Err, F, Fut> Handler for HandlerFn<F>

where RespBody: Body, F: Fn(Request<ReqBody>) -> Fut + Send + Sync, Err: Into<Box<dyn Error + Send + Sync>>, Fut: Future<Output = Result<Response<RespBody>, Err>> + Send,

type RespBody = RespBody

type Error = Err

type Fut<'fut> = Fut where Self: 'fut