Struct TowerHandler 

pub struct TowerHandler<Req, State, Res> {
    pub service: BoxCloneService<Bundle<Req, State, Res>, Bundle<Req, State, Res>, Infallible>,
    pub priority: u8,
    pub name: &'static str,
    pub module_name: &'static str,
}

A type-erased handler backed by a tower Service.

The most feature-complete and the slowest wrapper: it inserts a tower Service layer (HandlerService), a boxed future (HandlerServiceFuture), and a BoxCloneService, so every call pays for several layers of boxing and a oneshot dispatch.

Fields

service: BoxCloneService<Bundle<Req, State, Res>, Bundle<Req, State, Res>, Infallible>

The boxed tower service.

priority: u8

The handler’s priority.

name: &'static str

The handler’s name.

module_name: &'static str

The module the handler was registered from.

Implementations

impl<Req, State, Res> TowerHandler<Req, State, Res>

where Req: Send + 'static, State: Send + 'static, Res: Send + Mul<Output = Res> + 'static,

pub fn new<T: 'static>( priority: u8, name: &'static str, module_name: &'static str, handler: impl Handler<T, Req, State, Res>, ) -> Self

Create a tower-backed handler.

Trait Implementations

impl<Req, State, Res> Call<Req, State, Res> for TowerHandler<Req, State, Res>

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

fn call( &self, bundle: Bundle<Req, State, Res>, ) -> Pin<Box<dyn Future<Output = Bundle<Req, State, Res>> + Send>>

Call the handler, returning the updated bundle.

fn priority(&self) -> u8

The handler’s priority, used to sort the chain.

impl<Req, State, Res> Clone for TowerHandler<Req, State, Res>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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.

impl<Req, State, Res> Sync for TowerHandler<Req, State, Res>