Trait ntex::web::Responder

pub trait Responder<Err = DefaultError> {
    type Error;
    type Future: Future<Output = Response>;
    pub fn respond_to(self, req: &HttpRequest) -> Self::Future;

    pub fn with_status(self, status: StatusCode) -> CustomResponder<Self, Err>
    where
        Self: Sized,
    { ... }
    pub 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.

Associated Types

type Error

The associated error which can be returned.

type Future: Future<Output = Response>

The future response value.

Loading content...

Required methods

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

Convert itself to AsyncResult or Error.

Loading content...

Provided methods

pub 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)
}

pub 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")
}

Loading content...

Implementations on Foreign Types

impl<T, Err> Responder<Err> for Option<T> where
    T: Responder<Err>,
    Err: ErrorRenderer, 

type Error = T::Error

type Future = EitherFuture<T::Future, Ready<Response>>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

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

type Error = T::Error

type Future = EitherFuture<T::Future, Ready<Response>>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

impl<T, Err> Responder<Err> for (T, StatusCode) where
    T: Responder<Err>,
    Err: ErrorRenderer, 

type Error = T::Error

type Future = CustomResponderFut<T, Err>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

impl<'a, Err: ErrorRenderer> Responder<Err> for &'a String

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

Loading content...

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::{Either, HttpResponse};

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!")
    }
}

type Error = Err::Container

type Future = EitherFuture<A::Future, B::Future>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, _: &HttpRequest) -> Self::Future

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

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(mut self: Self, _: &HttpRequest) -> Self::Future

impl<T, Err> Responder<Err> for InternalError<T, Err> where
    T: Debug + Display + 'static,
    Err: ErrorRenderer, 

type Error = Err::Container

type Future = Ready<Response>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

impl<T: Serialize, Err: ErrorRenderer> Responder<Err> for Form<T> where
    Err::Container: From<Error>, 

type Error = Error

type Future = Ready<Response>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

impl<T: Serialize, Err: ErrorRenderer> Responder<Err> for Json<T> where
    Err::Container: From<JsonError>, 

type Error = JsonError

type Future = Ready<Response>

pub fn respond_to(self, req: &HttpRequest) -> Self::Future

Loading content...