Struct salvo_core::Router

pub struct Router {
    pub children: Vec<Router>,
    pub filter: Option<Box<dyn Filter>>,
    pub handler: Option<Arc<dyn Handler>>,
    pub befores: Vec<Arc<dyn Handler>>,
    pub afters: Vec<Arc<dyn Handler>>,
}

Fields

children: Vec<Router>

filter: Option<Box<dyn Filter>>

handler: Option<Arc<dyn Handler>>

befores: Vec<Arc<dyn Handler>>

afters: Vec<Arc<dyn Handler>>

Implementations

impl Router

pub fn new() -> Router

pub fn detect(
    &self,
    request: &mut Request,
    path: &mut PathState
) -> Option<DetectMatched>

pub fn visit<F>(self, func: F) -> Self where
    F: Fn(Router) -> Router, 

pub fn push(mut self: Self, router: Router) -> Self

pub fn push_when<F>(mut self: Self, func: F) -> Self where
    F: Fn(&Router) -> Option<Router>, 

pub fn before<H: Handler>(mut self: Self, handler: H) -> Self

pub fn after<H: Handler>(mut self: Self, handler: H) -> Self

pub fn path(self, path: impl Into<String>) -> Self

pub fn filter(mut self: Self, filter: impl Filter) -> Self

pub fn handle<H: Handler>(mut self: Self, handler: H) -> Self

pub fn handle_when<H, F>(mut self: Self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn get<H: Handler>(self, handler: H) -> Self

pub fn get_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn post<H: Handler>(self, handler: H) -> Self

pub fn post_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn put<H: Handler, I: AsRef<str>>(self, handler: H) -> Self

pub fn put_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn delete<H: Handler>(self, handler: H) -> Self

pub fn delete_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn head<H: Handler>(self, handler: H) -> Self

pub fn head_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn patch<H: Handler>(self, handler: H) -> Self

pub fn patch_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>, 

pub fn options<H: Handler>(self, handler: H) -> Self

pub fn options_when<H, F>(self, func: F) -> Self where
    H: Handler,
    F: Fn(&Router) -> Option<H>,