Struct actix_web::middleware::Compat

pub struct Compat<T> { /* fields omitted */ }

Middleware for enabling any middleware to be used in Resource::wrap, Scope::wrap and Condition.

Examples

use actix_web::middleware::{Logger, Compat};
use actix_web::{App, web};

let logger = Logger::default();

// this would not compile because of incompatible body types
// let app = App::new()
//     .service(web::scope("scoped").wrap(logger));

// by using this middleware we can use the logger on a scope
let app = App::new()
    .service(web::scope("scoped").wrap(Compat::new(logger)));

Implementations

impl<T> Compat<T>

pub fn new(middleware: T) -> Self

Wrap a middleware to give it broader compatibility.

Trait Implementations

impl<S, T, Req> Transform<S, Req> for Compat<T> where
    S: Service<Req>,
    T: Transform<S, Req>,
    T::Future: 'static,
    T::Response: MapServiceResponseBody,
    Error: From<T::Error>, 

type Response = ServiceResponse

Responses given by the service.

type Error = Error

Errors produced by the service.

type Transform = CompatMiddleware<T::Transform>

The TransformService value created by this factory

type InitError = T::InitError

Errors produced while building a transform service.

type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously

pub fn map_init_err<F, E>(self, f: F) -> TransformMapInitErr<Self, S, Req, F, E> where
    F: Fn(Self::InitError) -> E + Clone, 

Map this transform's factory error to a different error, returning a new transform service factory.