Struct poem::Route

pub struct Route { /* private fields */ }

Routing object

You can match the full path or wildcard path, and use the Path extractor to get the path parameters.

Errors

• NotFoundError

Example

use poem::{
    get, handler,
    http::{StatusCode, Uri},
    test::TestClient,
    web::Path,
    Endpoint, Request, Route,
};

#[handler]
async fn a() {}

#[handler]
async fn b(Path((group, name)): Path<(String, String)>) {
    assert_eq!(group, "foo");
    assert_eq!(name, "bar");
}

#[handler]
async fn c(Path(path): Path<String>) {
    assert_eq!(path, "d/e");
}

let app = Route::new()
    // full path
    .at("/a/b", get(a))
    // capture parameters
    .at("/b/:group/:name", get(b))
    // capture tail path
    .at("/c/*path", get(c))
    // match regex
    .at("/d/<\\d+>", get(a))
    // capture with regex
    .at("/e/:name<\\d+>", get(a));

let cli = TestClient::new(app);

// /a/b
cli.get("/a/b").send().await.assert_status_is_ok();

// /b/:group/:name
cli.get("/b/foo/bar").send().await.assert_status_is_ok();

// /c/*path
cli.get("/c/d/e").send().await.assert_status_is_ok();

// /d/<\\d>
cli.get("/d/123").send().await.assert_status_is_ok();

// /e/:name<\\d>
cli.get("/e/123").send().await.assert_status_is_ok();

Nested

use poem::{
    handler,
    http::{StatusCode, Uri},
    test::TestClient,
    Endpoint, Request, Route,
};

#[handler]
fn index() -> &'static str {
    "hello"
}

let app = Route::new().nest("/foo", Route::new().at("/bar", index));
let cli = TestClient::new(app);

let resp = cli.get("/foo/bar").send().await;
resp.assert_status_is_ok();
resp.assert_text("hello").await;

Nested no strip

use poem::{
    handler,
    http::{StatusCode, Uri},
    test::TestClient,
    Endpoint, Request, Route,
};

#[handler]
fn index() -> &'static str {
    "hello"
}

let app = Route::new().nest_no_strip("/foo", Route::new().at("/foo/bar", index));
let cli = TestClient::new(app);

let resp = cli.get("/foo/bar").send().await;
resp.assert_status_is_ok();
resp.assert_text("hello").await;

Implementations

impl Route

pub fn new() -> Route

Create a new routing object.

pub fn at<E>(self, path: impl AsRef<str>, ep: E) -> Self

where E: IntoEndpoint, E::Endpoint: 'static,

Add an Endpoint to the specified path.

Panics

Panic when there are duplicates in the routing table.

pub fn try_at<E>(self, path: impl AsRef<str>, ep: E) -> Result<Self, RouteError>

where E: IntoEndpoint, E::Endpoint: 'static,

Attempts to add an Endpoint to the specified path.

pub fn just_at<E>(self, ep: E) -> Self

where E: IntoEndpoint, E::Endpoint: 'static,

Add an Endpoint to the / path.

Same as self.at("/", ep).

See Route::at for more details.

pub fn nest<E>(self, path: impl AsRef<str>, ep: E) -> Self

where E: IntoEndpoint, E::Endpoint: 'static,

Nest a Endpoint to the specified path and strip the prefix.

Panics

Panic when there are duplicates in the routing table.

pub fn try_nest<E>( self, path: impl AsRef<str>, ep: E ) -> Result<Self, RouteError>

where E: IntoEndpoint, E::Endpoint: 'static,

Attempts to nest a Endpoint to the specified path and strip the prefix.

pub fn nest_no_strip<E>(self, path: impl AsRef<str>, ep: E) -> Self

where E: IntoEndpoint, E::Endpoint: 'static,

Nest a Endpoint to the specified path, but do not strip the prefix.

Panics

Panic when there are duplicates in the routing table.

pub fn try_nest_no_strip<E>( self, path: impl AsRef<str>, ep: E ) -> Result<Self, RouteError>

where E: IntoEndpoint, E::Endpoint: 'static,

Attempts to nest a Endpoint to the specified path, but do not strip the prefix.

Trait Implementations

impl Default for Route

fn default() -> Route

Returns the “default value” for a type.

impl Endpoint for Route

type Output = Response

Represents the response of the endpoint.

async fn call(&self, req: Request) -> Result<Self::Output>

Get the response to the request.

fn get_response(&self, req: Request) -> impl Future<Output = Response> + Send

Get the response to the request and return a Response.