Trait FromPath 

pub trait FromPath: Sized {
    const ARITY: usize;
    const NAMES: &'static [&'static str] = _;

    // Required method
    fn from_path(params: &PathParams, names: &[&str]) -> Result<Self, String>;
}

A type Path can build from route parameters.

Implemented for the standard scalars (one parameter), tuples of up to six FromStr values (one parameter each, in order), and structs with #[derive(FromPath)] (one parameter per field, by name). A type of your own with FromStr works as a one-tuple: Path((slug,)): Path<(Slug,)>.

Required Associated Constants

const ARITY: usize

How many parameters this type takes.

Provided Associated Constants

const NAMES: &'static [&'static str] = _

The parameters by name (a struct’s fields), or empty when they are taken in order. The route macros check these against the pattern.

Required Methods

fn from_path(params: &PathParams, names: &[&str]) -> Result<Self, String>

Build the value. names are the route parameters to take, in order (ARITY of them); an error is the rejection’s detail.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl FromPath for IpAddr

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<IpAddr, String>

impl FromPath for Ipv4Addr

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<Ipv4Addr, String>

impl FromPath for Ipv6Addr

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<Ipv6Addr, String>

impl FromPath for String

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<String, String>

impl FromPath for bool

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<bool, String>

impl FromPath for char

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<char, String>

impl FromPath for f32

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<f32, String>

impl FromPath for f64

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<f64, String>

impl FromPath for i8

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<i8, String>

impl FromPath for i16

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<i16, String>

impl FromPath for i32

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<i32, String>

impl FromPath for i64

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<i64, String>

impl FromPath for i128

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<i128, String>

impl FromPath for isize

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<isize, String>

impl FromPath for u8

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<u8, String>

impl FromPath for u16

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<u16, String>

impl FromPath for u32

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<u32, String>

impl FromPath for u64

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<u64, String>

impl FromPath for u128

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<u128, String>

impl FromPath for usize

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<usize, String>

impl<A, B, C, D, E, F> FromPath for (A, B, C, D, E, F)

where A: FromStr, <A as FromStr>::Err: Display, B: FromStr, <B as FromStr>::Err: Display, C: FromStr, <C as FromStr>::Err: Display, D: FromStr, <D as FromStr>::Err: Display, E: FromStr, <E as FromStr>::Err: Display, F: FromStr, <F as FromStr>::Err: Display,

const ARITY: usize = 6

fn from_path( params: &PathParams, names: &[&str], ) -> Result<(A, B, C, D, E, F), String>

impl<A, B, C, D, E> FromPath for (A, B, C, D, E)

where A: FromStr, <A as FromStr>::Err: Display, B: FromStr, <B as FromStr>::Err: Display, C: FromStr, <C as FromStr>::Err: Display, D: FromStr, <D as FromStr>::Err: Display, E: FromStr, <E as FromStr>::Err: Display,

const ARITY: usize = 5

fn from_path( params: &PathParams, names: &[&str], ) -> Result<(A, B, C, D, E), String>

impl<A, B, C, D> FromPath for (A, B, C, D)

where A: FromStr, <A as FromStr>::Err: Display, B: FromStr, <B as FromStr>::Err: Display, C: FromStr, <C as FromStr>::Err: Display, D: FromStr, <D as FromStr>::Err: Display,

const ARITY: usize = 4

fn from_path( params: &PathParams, names: &[&str], ) -> Result<(A, B, C, D), String>

impl<A, B, C> FromPath for (A, B, C)

where A: FromStr, <A as FromStr>::Err: Display, B: FromStr, <B as FromStr>::Err: Display, C: FromStr, <C as FromStr>::Err: Display,

const ARITY: usize = 3

fn from_path(params: &PathParams, names: &[&str]) -> Result<(A, B, C), String>

impl<A, B> FromPath for (A, B)

where A: FromStr, <A as FromStr>::Err: Display, B: FromStr, <B as FromStr>::Err: Display,

const ARITY: usize = 2

fn from_path(params: &PathParams, names: &[&str]) -> Result<(A, B), String>

impl<A> FromPath for (A,)

where A: FromStr, <A as FromStr>::Err: Display,

const ARITY: usize = 1

fn from_path(params: &PathParams, names: &[&str]) -> Result<(A,), String>

Implementors