Struct Layered 

pub struct Layered<L, H, T, S> { /* private fields */ }

A handler wrapped with a Tower layer for middleware.

This type is returned by Handler::layer and implements Handler itself, allowing you to compose multiple layers or pass it to [Router::route].

Trait Implementations

impl<L, H, T, S> Clone for Layered<L, H, T, S>

where L: Clone, H: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L, H, T, S> Handler<T, S> for Layered<L, H, T, S>

where H: Handler<T, S>, L: Layer<HandlerService<H, T, S>> + Clone + Send + 'static, L::Service: Service<H::Signal, Response = (), Error = Infallible> + Clone + Send + 'static, <L::Service as Service<H::Signal>>::Future: Send + 'static, S: Clone + Send + Sync + 'static, T: Send + Sync + 'static,

type Future = Pin<Box<dyn Future<Output = ()> + Send>>

The future returned by calling this handler.

type Signal = <H as Handler<T, S>>::Signal

The specific RINF signal type this handler processes.

fn call(self, signal: Self::Signal, state: S) -> Self::Future

Call the handler with the given signal and state.

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>

where L: Layer<HandlerService<Self, T, S>> + Clone + Send + 'static, L::Service: Service<Self::Signal, Response = (), Error = Infallible> + Clone + Send + 'static, S: Clone + Send + Sync + 'static,

Apply a Tower layer to this handler, creating a new layered handler.

fn with_state(self, state: S) -> HandlerService<Self, T, S>

where S: Clone + Send + Sync + 'static,

Convert this handler into a Tower Service with state. This creates a HandlerService wrapper around the handler.