Struct HyperRoute 

pub struct HyperRoute { /* private fields */ }

Serves one compiled surface over hyper.

The surface does the routing and the reading; this states only how a hyper request becomes one a surface answers, and how that answer becomes a hyper response.

Implementations

impl HyperRoute

pub fn new(surface: DirectRoute) -> Self

Constructs a new HyperRoute.

impl HyperRoute

pub const fn reading(self, bytes: usize) -> Self

Reads a request body of at most bytes, answering 413 for one larger than that.

What a service accepts is the service’s to state. The default is a sane bound rather than a policy, so anything serving callers it does not control states its own.

pub async fn answer<Sent>(&self, request: Request<Sent>) -> HyperAnswer

where Sent: Body<Data = Bytes>, Sent::Error: Display,

Answers one request, whatever carried it here.

A request that cannot be read is answered rather than dropped, because a caller that sent something unreadable is still owed an answer.

Trait Implementations

impl Clone for HyperRoute

fn clone(&self) -> HyperRoute

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Sent> Service<Request<Sent>> for HyperRoute

where Sent: Body<Data = Bytes> + Send + 'static, Sent::Error: Display,

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = !

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<HyperRoute as Service<Request<Sent>>>::Response, <HyperRoute as Service<Request<Sent>>>::Error>> + Send>>

The future response value.

fn call(&self, request: Request<Sent>) -> Self::Future

Process the request and return the response asynchronously. call takes &self instead of mut &self because: