Struct gotham::router::tree::node::Node

pub struct Node { /* private fields */ }

A recursive member of Tree, representative of segment(s) in a request path.

Each node includes 0..n Route instances, which can be further evaluated by the Router based on a match. Every node may also have 0..n children to provide the recursive tree representation.

Implementations

impl Node

pub fn new(segment: &str, segment_type: SegmentType) -> Self

Creates new Node for the given segment and type.

pub fn add_child(&mut self, node: Node) -> &mut Self

Adds a new child Node instance to this Node.

pub fn add_route(
    &mut self,
    route: Box<dyn Route<ResBody = Body> + Send + Sync>
) -> &mut Self

Adds a Route to this Node, to be potentially evaluated by the Router.

pub fn borrow_child(
    &self,
    segment: &str,
    segment_type: SegmentType
) -> Option<&Node>

Borrows a child Node based on the defined segment bounds.

pub fn borrow_child_mut(
    &mut self,
    segment: &str,
    segment_type: SegmentType
) -> Option<&mut Node>

Borrows a mutable child Node based on the defined segment bounds.

pub fn has_child(&self, segment: &str, segment_type: SegmentType) -> bool

Determines if a child exists based on the defined segment bounds.

pub fn is_routable(&self) -> bool

Determines if this Node has any valid Route values attached.

pub fn match_node<'a>(
    &'a self,
    segments: &'a [PercentDecoded]
) -> Option<(&'a Node, SegmentMapping<'a>, usize)>

Traverses this Node and its children, attempting to a locate a path of Node instances which match all segments of the provided Request path. The final Node must have at least a single Route attached in order to be returned.

Only the first matching path is returned from this method, and the value is wrapped in an Option as there may be no matching node.

Children are searched in a most to least specific order of segments, based on the node SegmentType value:

1. Static
2. Constrained
3. Dynamic
4. Glob

This method is a wrapping of an internal recursive implementation to mask the required types needed for the recursion.

pub fn segment<'a>(&'a self) -> &'a str

Retrieves a reference to the contained segment value.

This is required for lifetime related annotations.

pub fn select_route(
    &self,
    state: &State
) -> Result<&Box<dyn Route<ResBody = Body> + Send + Sync>, RouteNonMatch>

Determines if a Route instance associated with this Node is willing to Handle the request.

Where multiple Route instances could possibly handle the Request only the first, ordered per creation, is invoked.

Where no Route instances will accept the Request the resulting Error will be the union of the RouteNonMatch values returned from each Route.

In the situation where all these avenues are exhausted an InternalServerError will be provided.

Trait Implementations

impl Ord for Node

fn cmp(&self, other: &Node) -> Ordering

Compares two Node values to determine an appropriate Ordering.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Node> for Node

fn eq(&self, other: &Node) -> bool

Compares two Node values for equality based on the segments they represent.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Node> for Node

fn partial_cmp(&self, other: &Node) -> Option<Ordering>

Compares two Node values to determine an appropriate Ordering.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Node