Struct TypeEraser

pub struct TypeEraser<M>(/* private fields */);

Type eraser middleware is for erasing “unwanted” complex types produced by service tree and expose well known concrete types xitca-web can handle.

Example

// a handler function expect xitca_web::body::RequestBody as body type.
async fn handler(_: &WebContext<'_>) -> &'static str {
    "hello,world!"
}

// a limit middleware that limit request body to max size of 1MB.
// this middleware would produce a new type of request body that
// handler function don't know of.
let limit = Limit::new().set_request_body_max_size(1024 * 1024);

// an eraser middleware that transform any request body to xitca_web::body::RequestBody.
let eraser = TypeEraser::request_body();

App::new()
    .at("/", handler_service(handler))
    // introduce eraser middleware between handler and limit middleware
    // to resolve the type difference between them.
    // without it this piece of code would simply refuse to compile.
    .enclosed(eraser.clone())
    .enclosed(limit.clone());

// group middleware is suggested way of handling of use case like this.
let group = Group::new()
    .enclosed(eraser)
    .enclosed(limit);

// it's also suggested to group multiple type mutation middlewares together and apply
// eraser on them once if possible. the reason being TypeErase has a cost and by
// grouping you only pay the cost once.

App::new()
    .at("/", handler_service(handler))
    .enclosed(group);

Implementations

impl TypeEraser<EraseReqBody>

pub const fn request_body() -> Self

Erase generic request body type. making downstream middlewares observe RequestBody.

impl TypeEraser<EraseResBody>

pub const fn response_body() -> Self

Erase generic response body type. making downstream middlewares observe ResponseBody.

impl TypeEraser<EraseErr>

pub const fn error() -> Self

Erase generic E type from Service<Error = E>. making downstream middlewares observe Error.

Trait Implementations

impl<M> Clone for TypeEraser<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, S, E> Service<Result<S, E>> for TypeEraser<M>

type Response = EraserService<M, S>

The Ok part of output future.

type Error = E

The Err part of output future.

async fn call(&self, res: Result<S, E>) -> Result<Self::Response, Self::Error>