Struct tackt::Router

pub struct Router<R> { /* private fields */ }

The router instance.

Note that a router does not implement Route. It only implement service.

Implementations

impl<F, P> Router<Func<F, P>>

pub fn new<T, U, E, Fut>(route: F) -> Router<Func<F, P>> where
    F: FnMut(T, P) -> Fut,
    P: Param<T>,
    E: From<Error>,
    Fut: Future<Output = Result<U, E>>, 

Create a new router with the route.

impl<R> Router<R>

pub fn route<F, T, P, U, E, Fut>(self, route: F) -> Router<Or<R, Func<F, P>>> where
    R: Route<T, Response = U, Error = E>,
    F: FnMut(T, P) -> Fut,
    P: Param<T>,
    E: From<Error>,
    Fut: Future<Output = Result<U, E>>, 

Add new route to this router.

pub fn mount<S, T, U, E>(
    self,
    prefix: &'static str,
    service: S
) -> Router<Or<R, Mount<S>>> where
    R: Route<T, Response = U, Error = E>,
    S: Service<T, Response = U, Error = E>,
    T: PathReq + RemovePrefix,
    E: From<Error>, 

Mount a service at prefix.

pub fn with<F, T, Fut>(self, func: F) -> Router<With<R, F>> where
    R: Clone + Service<T>,
    F: FnMut(T) -> Fut,
    Fut: Future<Output = Result<T, R::Error>>, 

Add middleware to the router.

Trait Implementations

impl<R: Clone> Clone for Router<R>

fn clone(&self) -> Router<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for Router<R>

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

Formats the value using the given formatter.

impl<R, T> Service<T> for Router<R> where
    R: Service<T>, 

type Response = R::Response

Responses given by the service.

type Error = R::Error

Errors produced by the service.

type Future = R::Future

The future response value.

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: T) -> Self::Future

Process the request and return the response asynchronously.

impl<R: Copy> Copy for Router<R>