Trait Responder

pub trait Responder<Err = DefaultError> {
    // Required method
    fn respond_to(self, req: &HttpRequest) -> impl Future<Output = Response>;

    // Provided methods
    fn with_status(self, status: StatusCode) -> CustomResponder<Self, Err>
       where Self: Sized { ... }
    fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self, Err>
       where Self: Sized,
             HeaderName: TryFrom<K>,
             HeaderValue: TryFrom<V>,
             <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
             <HeaderValue as TryFrom<V>>::Error: Into<HttpError> { ... }
}

Trait implemented by types that can be converted to a http response.

Types that implement this trait can be used as the return type of a handler.

Required Methods

fn respond_to(self, req: &HttpRequest) -> impl Future<Output = Response>

Convert itself to http response.

Provided Methods

fn with_status(self, status: StatusCode) -> CustomResponder<Self, Err>

where Self: Sized,

Override a status code for a Responder.

use ntex::http::StatusCode;
use ntex::web::{HttpRequest, Responder};

fn index(req: HttpRequest) -> impl Responder {
    "Welcome!".with_status(StatusCode::OK)
}

fn with_header<K, V>(self, key: K, value: V) -> CustomResponder<Self, Err>

where Self: Sized, HeaderName: TryFrom<K>, HeaderValue: TryFrom<V>, <HeaderName as TryFrom<K>>::Error: Into<HttpError>, <HeaderValue as TryFrom<V>>::Error: Into<HttpError>,

Add header to the Responder’s response.

use ntex::web::{self, HttpRequest, Responder};
use serde::Serialize;

#[derive(Serialize)]
struct MyObj {
    name: String,
}

async fn index(req: HttpRequest) -> impl Responder {
    web::types::Json(
        MyObj { name: "Name".to_string() }
    )
    .with_header("x-version", "1.2.3")
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<Err: ErrorRenderer> Responder<Err> for &'static str

async fn respond_to(self, _: &HttpRequest) -> Response

impl<Err: ErrorRenderer> Responder<Err> for &'static [u8]

async fn respond_to(self, _: &HttpRequest) -> Response

impl<Err: ErrorRenderer> Responder<Err> for &String

async fn respond_to(self, _: &HttpRequest) -> Response

impl<Err: ErrorRenderer> Responder<Err> for String

async fn respond_to(self, _: &HttpRequest) -> Response

impl<T, E, Err> Responder<Err> for Result<T, E>

where T: Responder<Err>, E: Into<Err::Container>, Err: ErrorRenderer,

async fn respond_to(self, req: &HttpRequest) -> Response

impl<T, Err> Responder<Err> for (T, StatusCode)

where T: Responder<Err>, Err: ErrorRenderer,

async fn respond_to(self, req: &HttpRequest) -> Response

impl<T, Err> Responder<Err> for Option<T>

where T: Responder<Err>, Err: ErrorRenderer,

async fn respond_to(self, req: &HttpRequest) -> Response

Implementors

impl<A, B, Err> Responder<Err> for Either<A, B>

where A: Responder<Err>, B: Responder<Err>, Err: ErrorRenderer,

Combines two different responder types into a single type

use ntex::{web::HttpResponse, util::Either};

fn index() -> Either<HttpResponse, &'static str> {
    if is_a_variant() {
        // <- choose left variant
        Either::Left(HttpResponse::BadRequest().body("Bad data"))
    } else {
        // <- Right variant
        Either::Right("Hello!")
    }
}

impl<Err: ErrorRenderer> Responder<Err> for Response

impl<Err: ErrorRenderer> Responder<Err> for ResponseBuilder

impl<Err: ErrorRenderer> Responder<Err> for Bytes

impl<Err: ErrorRenderer> Responder<Err> for BytesMut

impl<T, Err> Responder<Err> for InternalError<T, Err>

where T: Debug + Display + 'static, Err: ErrorRenderer,

impl<T: Serialize, Err: ErrorRenderer> Responder<Err> for Form<T>

where Err::Container: From<Error>,

impl<T: Serialize, Err: ErrorRenderer> Responder<Err> for Json<T>

where Err::Container: From<JsonError>,