Struct actix_web::middleware::DefaultHeaders

pub struct DefaultHeaders { /* private fields */ }

Middleware for setting default response headers.

Headers with the same key that are already set in a response will not be overwritten.

Examples

use actix_web::{web, http, middleware, App, HttpResponse};

let app = App::new()
    .wrap(middleware::DefaultHeaders::new().add(("X-Version", "0.2")))
    .service(
        web::resource("/test")
            .route(web::get().to(|| HttpResponse::Ok()))
            .route(web::method(http::Method::HEAD).to(|| HttpResponse::MethodNotAllowed()))
    );

Implementations

impl DefaultHeaders

pub fn new() -> DefaultHeaders

Constructs an empty DefaultHeaders middleware.

pub fn add(self, header: impl TryIntoHeaderPair) -> Self

Adds a header to the default set.

Panics

Panics when resolved header name or value is invalid.

pub fn add_content_type(self) -> Self

Adds a default Content-Type header if response does not contain one.

Default is application/octet-stream.

Trait Implementations

impl Clone for DefaultHeaders

fn clone(&self) -> DefaultHeaders

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DefaultHeaders

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

Formats the value using the given formatter.

impl Default for DefaultHeaders

fn default() -> DefaultHeaders

Returns the “default value” for a type.

impl<S, B> Transform<S, ServiceRequest> for DefaultHeaders where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static, 

type Response = ServiceResponse<B>

Responses produced by the service.

type Error = Error

Errors produced by the service.

type Transform = DefaultHeadersMiddleware<S>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = Ready<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