Struct FnLayer 

pub struct FnLayer<M> { /* private fields */ }

A functional layer

This is an example of how to create a layer that adds a header to the response:

let layer = FnLayer::new_closure(move |req, inner| {
   async move {
       let mut resp = inner.call(req).await;
       resp.headers_mut().insert("server", HeaderValue::from_static("potato"));
       resp
   }
});

Or you can use a struct that implements FnLayerMethod:

struct MyPlugin;
impl FnLayerMethod for MyPlugin {
   async fn call(&self, req: SgRequest, inner: Inner) -> SgResponse {
      let mut resp = inner.call(req).await;
      resp.headers_mut().insert("server", HeaderValue::from_static("potato"));
      resp
   }
}
let layer = FnLayer::new(MyPlugin);

Implementations

impl<M> FnLayer<M>

pub const fn new(method: M) -> Self

impl<F, Fut> FnLayer<Closure<F, Fut>>

where F: Fn(Request<SgBody>, Inner) -> Fut + Send + Sync + Clone + 'static, Fut: Future<Output = Response<SgBody>> + Send + 'static,

pub const fn new_closure(f: F) -> Self

impl<H, F, Fut> FnLayer<Handler<H, F, Fut>>

where Handler<H, F, Fut>: FnLayerMethod,

pub const fn new_handler(h: H) -> Self

Trait Implementations

impl<M: Clone> Clone for FnLayer<M>

fn clone(&self) -> FnLayer<M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for FnLayer<M>

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

Formats the value using the given formatter.

impl<M, S> Layer<S> for FnLayer<M>

where M: FnLayerMethod + Clone, S: Service<Request<SgBody>, Error = Infallible, Response = Response<SgBody>> + Send + Sync + Clone + 'static, <S as Service<Request<SgBody>>>::Future: Future<Output = Result<Response<SgBody>, Infallible>> + 'static + Send,

type Service = FnService<M>

The wrapped service

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.