Trait validators::prelude::validators_prelude::FromParam [−][src]
pub trait FromParam<'a> { type Error: Debug; pub fn from_param(param: &'a RawStr) -> Result<Self, Self::Error>; }
Trait to convert a dynamic path segment string to a concrete value.
This trait is used by Rocket’s code generation facilities to parse dynamic
path segment string values into a given type. That is, when a path contains
a dynamic segment <param>
where param
has some type T
that implements
FromParam
, T::from_param
will be called.
Forwarding
If the conversion fails, the incoming request will be forwarded to the next
matching route, if any. For instance, consider the following route and
handler for the dynamic "/<id>"
path:
#[get("/<id>")] fn hello(id: usize) -> String { ... }
If usize::from_param
returns an Ok(usize)
variant, the encapsulated
value is used as the id
function parameter. If not, the request is
forwarded to the next matching route. Since there are no additional matching
routes, this example will result in a 404 error for requests with invalid
id
values.
Catching Errors
Sometimes, a forward is not desired, and instead, we simply want to know
that the dynamic path segment could not be parsed into some desired type
T
. In these cases, types of Option<T>
or Result<T, T::Error>
can be
used. These types implement FromParam
themselves. Their implementations
always return successfully, so they never forward. They can be used to
determine if the FromParam
call failed and to retrieve the error value
from the failed from_param
call.
For instance, imagine you’ve asked for an <id>
as a usize
. To determine
when the <id>
was not a valid usize
and retrieve the string that failed
to parse, you can use a Result<usize, &RawStr>
type for the <id>
parameter as follows:
#[get("/<id>")] fn hello(id: Result<usize, &RawStr>) -> String { match id { Ok(id_num) => format!("usize: {}", id_num), Err(string) => format!("Not a usize: {}", string) } }
Provided Implementations
Rocket implements FromParam
for several standard library types. Their
behavior is documented here.
-
- Primitive types: f32, f64, isize, i8, i16, i32, i64, i128, usize, u8, u16, u32, u64, u128, bool
IpAddr
andSocketAddr
types: IpAddr, Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6, SocketAddrNonZero*
types: NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, NonZeroIsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128, NonZeroUsize
A value is parsed successfully if the
from_str
method from the given type returns successfully. Otherwise, the raw path segment is returned in theErr
value. -
This implementation always returns successfully.
The path segment is passed directly with no modification.
-
String
Percent decodes the path segment. If the decode is successful, the decoded string is returned. Otherwise, an
Err
with the original path segment is returned. -
Cow
Percent decodes the path segment, allocating only when necessary. If the decode is successful, the decoded string is returned. Otherwise, an
Err
with the original path segment is returned. -
Option<T> where T: FromParam
This implementation always returns successfully.
The path segment is parsed by
T
’sFromParam
implementation. If the parse succeeds, aSome(parsed_value)
is returned. Otherwise, aNone
is returned. -
Result<T, T::Error> where T: FromParam
This implementation always returns successfully.
The path segment is parsed by
T
’sFromParam
implementation. The returnedResult
value is returned.
Example
Say you want to parse a segment of the form:
[a-zA-Z]+:[0-9]+
into the following structure, where the string before the :
is stored in
key
and the number after the colon is stored in value
:
struct MyParam<'r> { key: &'r str, value: usize }
The following implementation accomplishes this:
use rocket::request::FromParam; use rocket::http::RawStr; impl<'r> FromParam<'r> for MyParam<'r> { type Error = &'r RawStr; fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> { let (key, val_str) = match param.find(':') { Some(i) if i > 0 => (¶m[..i], ¶m[(i + 1)..]), _ => return Err(param) }; if !key.chars().all(|c| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { return Err(param); } val_str.parse().map(|value| { MyParam { key: key, value: value } }).map_err(|_| param) } }
With the implementation, the MyParam
type can be used as the target of a
dynamic path segment:
#[get("/<key_val>")] fn hello(key_val: MyParam) -> String { ... }
Associated Types
Loading content...Required methods
pub fn from_param(param: &'a RawStr) -> Result<Self, Self::Error>
[src]
Parses and validates an instance of Self
from a path parameter string
or returns an Error
if parsing or validation fails.
Implementations on Foreign Types
impl<'a, T> FromParam<'a> for Option<T> where
T: FromParam<'a>,
[src]
T: FromParam<'a>,
type Error = !
pub fn from_param(
param: &'a RawStr
) -> Result<Option<T>, <Option<T> as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<Option<T>, <Option<T> as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroI32
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroI32, <NonZeroI32 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroI32, <NonZeroI32 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroU8
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroU8, <NonZeroU8 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroU8, <NonZeroU8 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for f64
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<f64, <f64 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<f64, <f64 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for SocketAddr
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<SocketAddr, <SocketAddr as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<SocketAddr, <SocketAddr as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for u64
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<u64, <u64 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<u64, <u64 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for bool
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<bool, <bool as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<bool, <bool as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for i16
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<i16, <i16 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<i16, <i16 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for u128
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<u128, <u128 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<u128, <u128 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroU16
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroU16, <NonZeroU16 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroU16, <NonZeroU16 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for i64
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<i64, <i64 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<i64, <i64 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for isize
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<isize, <isize as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<isize, <isize as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroU128
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroU128, <NonZeroU128 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroU128, <NonZeroU128 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for f32
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<f32, <f32 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<f32, <f32 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for usize
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<usize, <usize as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<usize, <usize as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroU64
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroU64, <NonZeroU64 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroU64, <NonZeroU64 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroI8
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroI8, <NonZeroI8 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroI8, <NonZeroI8 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroI64
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroI64, <NonZeroI64 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroI64, <NonZeroI64 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for u8
[src]
type Error = &'a RawStr
pub fn from_param(param: &'a RawStr) -> Result<u8, <u8 as FromParam<'a>>::Error>
[src]
impl<'a> FromParam<'a> for NonZeroUsize
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroUsize, <NonZeroUsize as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroUsize, <NonZeroUsize as FromParam<'a>>::Error>
impl<'a, T> FromParam<'a> for Result<T, <T as FromParam<'a>>::Error> where
T: FromParam<'a>,
[src]
T: FromParam<'a>,
type Error = !
pub fn from_param(
param: &'a RawStr
) -> Result<Result<T, <T as FromParam<'a>>::Error>, <Result<T, <T as FromParam<'a>>::Error> as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<Result<T, <T as FromParam<'a>>::Error>, <Result<T, <T as FromParam<'a>>::Error> as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for u16
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<u16, <u16 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<u16, <u16 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for SocketAddrV6
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<SocketAddrV6, <SocketAddrV6 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<SocketAddrV6, <SocketAddrV6 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroI16
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroI16, <NonZeroI16 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroI16, <NonZeroI16 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for i32
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<i32, <i32 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<i32, <i32 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for u32
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<u32, <u32 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<u32, <u32 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroIsize
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroIsize, <NonZeroIsize as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroIsize, <NonZeroIsize as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroI128
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroI128, <NonZeroI128 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroI128, <NonZeroI128 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for i128
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<i128, <i128 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<i128, <i128 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for NonZeroU32
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<NonZeroU32, <NonZeroU32 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<NonZeroU32, <NonZeroU32 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for SocketAddrV4
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<SocketAddrV4, <SocketAddrV4 as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<SocketAddrV4, <SocketAddrV4 as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for i8
[src]
type Error = &'a RawStr
pub fn from_param(param: &'a RawStr) -> Result<i8, <i8 as FromParam<'a>>::Error>
[src]
Implementors
impl<'a> FromParam<'a> for &'a RawStr
[src]
type Error = !
pub fn from_param(
param: &'a RawStr
) -> Result<&'a RawStr, <&'a RawStr as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<&'a RawStr, <&'a RawStr as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for Cow<'a, str>
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<Cow<'a, str>, <Cow<'a, str> as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<Cow<'a, str>, <Cow<'a, str> as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for IpAddr
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<IpAddr, <IpAddr as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<IpAddr, <IpAddr as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for Ipv4Addr
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<Ipv4Addr, <Ipv4Addr as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<Ipv4Addr, <Ipv4Addr as FromParam<'a>>::Error>
impl<'a> FromParam<'a> for Ipv6Addr
[src]
type Error = &'a RawStr
pub fn from_param(
param: &'a RawStr
) -> Result<Ipv6Addr, <Ipv6Addr as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<Ipv6Addr, <Ipv6Addr as FromParam<'a>>::Error>