Struct actix_web::middleware::Condition

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

Middleware for conditionally enabling other middleware.

The controlled middleware must not change the Service interfaces. This means you cannot control such middlewares like Logger or Compress directly. See the Compat middleware for a workaround.

Examples

use actix_web::middleware::{Condition, NormalizePath};
use actix_web::App;

let enable_normalize = std::env::var("NORMALIZE_PATH").is_ok();
let app = App::new()
    .wrap(Condition::new(enable_normalize, NormalizePath::default()));

Implementations

impl<T> Condition<T>

pub fn new(enable: bool, transformer: T) -> Self

Trait Implementations

impl<S, T, Req> Transform<S, Req> for Condition<T> where
    S: Service<Req> + 'static,
    T: Transform<S, Req, Response = S::Response, Error = S::Error>,
    T::Future: 'static,
    T::InitError: 'static,
    T::Transform: 'static, 

type Response = S::Response

Responses given by the service.

type Error = S::Error

Errors produced by the service.

type Transform = ConditionMiddleware<T::Transform, S>

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.