Struct ntex::web::Route

pub struct Route<Err: ErrorRenderer = DefaultError> { /* private fields */ }

Resource route definition

Route uses builder-like pattern for configuration. If handler is not explicitly set, default 404 Not Found handler is used.

Implementations

impl<Err: ErrorRenderer> Route<Err>

pub fn new() -> Route<Err>

Create new route which matches any request.

impl<Err: ErrorRenderer> Route<Err>

pub fn method(self, method: Method) -> Self

Add method guard to the route.

App::new().service(web::resource("/path").route(
    web::route()
        .method(ntex::http::Method::CONNECT)
        .guard(guard::Header("content-type", "text/plain"))
        .to(|req: HttpRequest| async { HttpResponse::Ok() }))
);

pub fn guard<F: Guard + 'static>(self, f: F) -> Self

Add guard to the route.

App::new().service(web::resource("/path").route(
    web::route()
        .guard(guard::Get())
        .guard(guard::Header("content-type", "text/plain"))
        .to(|req: HttpRequest| async { HttpResponse::Ok() }))
);

pub fn to<F, Args>(self, handler: F) -> Self

where F: Handler<Args, Err> + 'static, Args: FromRequest<Err> + 'static, Args::Error: Into<Err::Container>,

Set handler function, use request extractors for parameters.

use ntex::web;

#[derive(serde::Deserialize)]
struct Info {
    username: String,
}

/// extract path info using serde
async fn index(info: web::types::Path<Info>) -> String {
    format!("Welcome {}!", info.username)
}

fn main() {
    let app = web::App::new().service(
        web::resource("/{username}/index.html") // <- define path parameters
            .route(web::get().to(index))        // <- register handler
    );
}

It is possible to use multiple extractors for one handler function.

use ntex::web;

#[derive(serde::Deserialize)]
struct Info {
    username: String,
}

/// extract path info using serde
async fn index(path: web::types::Path<Info>, query: web::types::Query<HashMap<String, String>>, body: web::types::Json<Info>) -> String {
    format!("Welcome {}!", path.username)
}

fn main() {
    let app = web::App::new().service(
        web::resource("/{username}/index.html") // <- define path parameters
            .route(web::get().to(index))
    );
}

Trait Implementations

impl<Err: ErrorRenderer> Debug for Route<Err>

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

Formats the value using the given formatter.

impl<Err: ErrorRenderer> IntoRoutes<Err> for Route<Err>

fn routes(self) -> Vec<Route<Err>>

impl<Err: ErrorRenderer> ServiceFactory<WebRequest<Err>> for Route<Err>

type Response = WebResponse

Responses given by the created services.

type Error = <Err as ErrorRenderer>::Container

Errors produced by the created services.

type InitError = ()

Errors potentially raised while building a service.

type Service = RouteService<Err>

The kind of Service created by this factory.

async fn create(&self, _: ()) -> Result<RouteService<Err>, ()>

Create and return a new service value asynchronously.

async fn pipeline( &self, cfg: Cfg ) -> Result<Pipeline<Self::Service>, Self::InitError>

where Self: Sized,

Create and return a new service value asynchronously and wrap into a container

fn map<F, Res>( self, f: F ) -> ServiceChainFactory<MapFactory<Self, F, Req, Res, Cfg>, Req, Cfg>

where Self: Sized, F: Fn(Self::Response) -> Res + Clone,

Map this service’s output to a different type, returning a new service of the resulting type.

fn map_err<F, E>( self, f: F ) -> ServiceChainFactory<MapErrFactory<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::Error) -> E + Clone,

Map this service’s error to a different error, returning a new service.

fn map_init_err<F, E>( self, f: F ) -> ServiceChainFactory<MapInitErr<Self, Req, Cfg, F, E>, Req, Cfg>

where Self: Sized, F: Fn(Self::InitError) -> E + Clone,

Map this factory’s init error to a different error, returning a new service.