Struct Route 

pub struct Route {
    pub path: String,
    pub name: Option<String>,
    pub namespace: Option<String>,
    pub middleware: Vec<Arc<dyn Middleware>>,
    /* private fields */
}

Available on non-WebAssembly only.

Route definition Uses composition to combine path patterns with handlers Similar to Django’s URLPattern

Fields

path: String

URL path pattern (e.g., "/users/{id}/")

name: Option<String>

Optional route name for reverse URL lookup.

namespace: Option<String>

Namespace for this route (e.g., “users”, “api”) When combined with name, forms “namespace:name”

middleware: Vec<Arc<dyn Middleware>>

Middleware stack for this route Applied in addition to router-level middleware

Implementations

impl Route

pub fn new(path: impl Into<String>, handler: Arc<dyn Handler>) -> Route

Available on crate feature test only.

Create a new route

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use std::sync::Arc;

// Create a simple route (using a dummy handler for demonstration)
let handler = Arc::new(DummyHandler);
let route = Route::new("/users/", handler);
assert_eq!(route.path, "/users/");

pub fn from_handler<H>(path: impl Into<String>, handler: H) -> Route

where H: Handler + 'static,

Available on crate feature test only.

Create a new route from a concrete handler (preferred method)

This method allows you to pass a handler directly without wrapping it in Arc. The Arc wrapping is handled internally for you.

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;

// No Arc::new() needed!
let route = Route::from_handler("/users/", DummyHandler);
assert_eq!(route.path, "/users/");

pub fn with_name(self, name: impl Into<String>) -> Route

Available on crate feature test only.

Set the name of the route

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let route = Route::new("/users/", handler)
    .with_name("user-list");
assert_eq!(route.name, Some("user-list".to_string()));

pub fn with_namespace(self, namespace: impl Into<String>) -> Route

Available on crate feature test only.

Set the namespace of the route

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let route = Route::new("/users/", handler)
    .with_namespace("api");
assert_eq!(route.namespace, Some("api".to_string()));

pub fn with_middleware(self, middleware: Arc<dyn Middleware>) -> Route

Available on crate feature test only.

Add middleware to this route

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use reinhardt_middleware::LoggingMiddleware;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let route = Route::new("/users/", handler)
    .with_middleware(Arc::new(LoggingMiddleware::new()));
assert_eq!(route.middleware.len(), 1);

pub fn full_name(&self) -> Option<String>

Available on crate feature test only.

Get the full name including namespace (e.g., “users:list”) Similar to Django’s view_name in ResolverMatch

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);

// With namespace and name
let route = Route::new("/users/", handler.clone())
    .with_namespace("api")
    .with_name("list");
assert_eq!(route.full_name(), Some("api:list".to_string()));

// With only name
let route = Route::new("/users/", handler.clone())
    .with_name("list");
assert_eq!(route.full_name(), Some("list".to_string()));

// Without name
let route = Route::new("/users/", handler);
assert_eq!(route.full_name(), None);

pub fn matches_namespace_pattern(&self, pattern: &str) -> bool

Available on crate feature test only.

Check if this route matches a namespace pattern Used for namespace-based versioning

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let route = Route::new("/v1/users/", handler)
    .with_namespace("v1");

assert!(route.matches_namespace_pattern("/v{version}/"));
assert!(!route.matches_namespace_pattern("/api/{version}/"));

pub fn extract_version_from_pattern(&self, pattern: &str) -> Option<&str>

Available on crate feature test only.

Extract version from namespace pattern Returns the version string if the route matches the pattern

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;
use std::sync::Arc;

let handler = Arc::new(DummyHandler);
let route = Route::new("/v1/users/", handler)
    .with_namespace("v1");

assert_eq!(route.extract_version_from_pattern("/v{version}/"), Some("1"));
assert_eq!(route.extract_version_from_pattern("/api/{version}/"), None);

pub fn handler(&self) -> &dyn Handler

Available on crate feature test only.

Get a reference to the route’s handler

This method provides access to the handler without exposing the Arc wrapper.

Examples

use reinhardt_urls::routers::Route;
use reinhardt_http::Handler;

let route = Route::from_handler("/users/", DummyHandler);
let handler = route.handler();
// Use handler as &dyn Handler

pub fn handler_arc(&self) -> Arc<dyn Handler>

Available on crate feature test only.

Get a cloned Arc of the handler (for cases where you need ownership)

In most cases, you should use handler() instead to get a reference.

Trait Implementations

impl Clone for Route

fn clone(&self) -> Route

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.