Struct trout::node::Node

pub struct Node<P, R: Request, T, C> { /* private fields */ }

The building block of a routing tree.

Each node can contain handlers, which will be used when this is the node reached at the end of the path, as well as children, which will be traversed otherwise.

Implementations

impl<P: 'static, R: Request + 'static, T: 'static, C: 'static> Node<P, R, T, C>

pub fn new() -> Self

Construct a new Node

pub fn with_handler(
    self,
    method: R::Method,
    handler: impl Fn(P, C, R) -> T + 'static + Send + Sync
) -> Self

Add a method handler to this node. For use with async, you may wish to use [with_handler_async] instead.

pub fn with_child(self, path: &'static str, child: Node<P, R, T, C>) -> Self

Add a child node with a constant path. The path argument must end at the end of a path segment, but can contain slashes in order to skip levels

Example

trout::Node::new()
    .with_child("items", other_node);

pub fn with_child_str<P2: TupleAdd<P, String> + 'static>(
    self,
    child: Node<P2, R, T, C>
) -> Self

Add a child node with a dynamic path segment (string form)

Example

trout::Node::new()
    .with_child_str(other_node)

pub fn with_child_parse<A: FromStr + Send + Sync + 'static, P2: TupleAdd<P, A> + 'static>(
    self,
    child: Node<P2, R, T, C>
) -> Self

Add a child node with a dynamic path segment (parsing form)

Example

trout::Node::new()
    .with_child_parse::<i32, _>(other_node)

impl<P: 'static, R: Request + 'static, TR: 'static, C: 'static> Node<P, R, Pin<Box<dyn Future<Output = TR> + Send>>, C>

pub fn with_handler_async<F: Future<Output = TR> + Send + 'static>(
    self,
    method: R::Method,
    handler: impl Fn(P, C, R) -> F + Send + Sync + 'static
) -> Self

Convenience method for handlers returning Pin<Box<Future>>s

impl<R: Request + 'static, T: 'static, C: 'static> Node<(), R, T, C>

pub fn route(&self, req: R, ctx: C) -> Result<T, RoutingFailure>

Perform routing for a request

Trait Implementations

impl<P, R: Request, T, C> Default for Node<P, R, T, C>

fn default() -> Self

Returns the “default value” for a type.