Struct Bundle 

#[repr(C)]
pub struct Bundle<Req, State = State, Res = ()> {
    pub request: Req,
    pub response: Res,
    pub stop_flag: StopFlag,
    pub state: State,
}

The container passed through the handler chain, carrying the request, response, state, and a stop flag.

Fields

request: Req

The request being processed.

response: Res

The response being built.

stop_flag: StopFlag

A flag to stop the chain.

state: State

The state shared across handlers.

Implementations

impl<Req, State, Res> Bundle<Req, State, Res>

pub fn new(request: Req, state: State, response: Res) -> Self

Create a bundle from a request, state, and response.

Trait Implementations

impl<Req: Debug, State: Debug, Res: Debug> Debug for Bundle<Req, State, Res>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Req, State, Res> FromRequest<Req, State, Res> for &mut Bundle<Req, State, Res>

where Req: Send, State: Send, Res: Send,

fn from_request(bundle: &mut Bundle<Req, State, Res>) -> Option<Self>

Extract this value from the bundle.

impl<Req, State, Res> Service<Bundle<Req, State, Res>> for TowerHandler<Req, State, Res>

where Req: Send + 'static, State: Send + 'static, Res: Send + 'static,

type Response = Bundle<Req, State, Res>

Responses given by the service.

type Error = !

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Bundle<Req, State, Res>, !>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, bundle: Bundle<Req, State, Res>) -> Self::Future

Process the request and return the response asynchronously.