/// Add a new route at the given `path`, relative to root.
///
/// Routing means mapping an HTTP request to an endpoint. Here Tide applies
/// a "table of contents" approach, which makes it easy to see the overall
/// app structure. Endpoints are selected solely by the path and HTTP method
/// of a request: the path determines the resource and the HTTP verb the
/// respective endpoint of the selected resource. Example:
///
/// ```rust,no_run
/// # let mut app = tide::Server::new();
/// app.at("/").get(|_| async { Ok("Hello, world!") });
/// ```
///
/// A path is comprised of zero or many segments, i.e. non-empty strings
/// separated by '/'. There are two kinds of segments: concrete and
/// wildcard. A concrete segment is used to exactly match the respective
/// part of the path of the incoming request. A wildcard segment on the
/// other hand extracts and parses the respective part of the path of the
/// incoming request to pass it along to the endpoint as an argument. A
/// wildcard segment is written as `:name`, which creates an endpoint
/// parameter called `name`. It is not possible to define wildcard segments
/// with different names for otherwise identical paths.
///
/// Alternatively a wildcard definitions can start with a `*`, for example
/// `*path`, which means that the wildcard will match to the end of given
/// path, no matter how many segments are left, even nothing.
///
/// The name of the parameter can be omitted to define a path that matches
/// the required structure, but where the parameters are not required.
/// `:` will match a segment, and `*` will match an entire path.
///
/// Here are some examples omitting the HTTP verb based endpoint selection:
///
/// ```rust,no_run
/// # let mut app = tide::Server::new();
/// app.at("/");
/// app.at("/hello");
/// app.at("add_two/:num");
/// app.at("files/:user/*");
/// app.at("static/*path");
/// app.at("static/:context/:");
/// ```
///
/// There is no fallback route matching, i.e. either a resource is a full
/// match or not, which means that the order of adding resources has no
/// effect.
Add a new route at the given `path`, relative to root.
Routing means mapping an HTTP request to an endpoint. Here Tide applies
a "table of contents" approach, which makes it easy to see the overall
app structure. Endpoints are selected solely by the path and HTTP method
of a request: the path determines the resource and the HTTP verb the
respective endpoint of the selected resource. Example.


Add a new route at the given ` path ` relative to root . Routing means mapping an HTTP request to an endpoint . Here Tide applies a " table of contents " approach which makes it easy to see the overall app structure . Endpoints are selected solely by the path and HTTP method of a request : the path determines the resource and the HTTP verb the respective endpoint of the selected resource . Example .
pub fn at<'a>(&'a mut self, path: &str) -> Route<'a, State> {
        let router = Arc::get_mut(&mut self.router)
            .expect("Registering routes is not possible after the Server has started");
        Route::new(router, path.to_owned())
    }
pub fn at < ' a > ( & ' a mut self , path : & str ) -> Route < ' a , State > { let router = Arc :: get_mut ( & mut self . router ) . expect ( " " ) ; Route :: new ( router , path . to_owned ( ) ) }
Add a new route at the given `path`, relative to root.
Add a new route at the given ` path ` relative to root .
&'a mut self
path
&str
let mut app = tide::server::new();


A path is comprised of zero or many segments, i.e. non-empty strings
separated by '/'. There are two kinds of segments: concrete and
wildcard. A concrete segment is used to exactly match the respective
part of the path of the incoming request. A wildcard segment on the
other hand extracts and parses the respective part of the path of the
incoming request to pass it along to the endpoint as an argument. A
wildcard segment is written as `:name`, which creates an endpoint
parameter called `name`. It is not possible to define wildcard segments
with different names for otherwise identical paths.

Alternatively a wildcard definitions can start with a `*`, for example
`*path`, which means that the wildcard will match to the end of given
path, no matter how many segments are left, even nothing.

The name of the parameter can be omitted to define a path that matches
the required structure, but where the parameters are not required.
`:` will match a segment, and `*` will match an entire path.

Here are some examples omitting the HTTP verb based endpoint selection.


A path is comprised of zero or many segments i . e . non - empty strings separated by ' / ' . There are two kinds of segments : concrete and wildcard . A concrete segment is used to exactly match the respective part of the path of the incoming request . A wildcard segment on the other hand extracts and parses the respective part of the path of the incoming request to pass it along to the endpoint as an argument . A wildcard segment is written as ` : name ` which creates an endpoint parameter called ` name ` . It is not possible to define wildcard segments with different names for otherwise identical paths . Alternatively a wildcard definitions can start with a ` * ` for example ` * path ` which means that the wildcard will match to the end of given path no matter how many segments are left even nothing . The name of the parameter can be omitted to define a path that matches the required structure but where the parameters are not required . ` : ` will match a segment and ` * ` will match an entire path . Here are some examples omitting the HTTP verb based endpoint selection .
let mut app = tide::server::new();


There is no fallback route matching, i.e. either a resource is a full
match or not, which means that the order of adding resources has no
effect.
There is no fallback route matching i . e . either a resource is a full match or not which means that the order of adding resources has no effect .