Trait rocket::http::uri::fmt::FromUriParam

pub trait FromUriParam<P, T>
where P: Part,
{ type Target: UriDisplay<P>; // Required method fn from_uri_param(param: T) -> Self::Target; }
Expand description

Conversion trait for parameters used in uri! invocations.

§Overview

In addition to implementing UriDisplay, to use a custom type in a uri! expression, the FromUriParam trait must be implemented. The UriDisplay derive automatically generates identity implementations of FromUriParam, so in the majority of cases, as with UriDisplay, this trait is never implemented manually.

In the rare case that UriDisplay is implemented manually, this trait, too, must be implemented explicitly. In the majority of cases, implementation can be automated. Rocket provides impl_from_uri_param_identity! to generate the identity implementations automatically. For a type T, these are:

  • impl<P: Part> FromUriParam<P, T> for T
  • impl<'x, P: Part> FromUriParam<P, &'x T> for T
  • impl<'x, P: Part> FromUriParam<P, &'x mut T> for T

See impl_from_uri_param_identity! for usage details.

§Code Generation

This trait is invoked once per expression passed into a uri! invocation. In particular, for a route URI parameter of type T and a user-supplied expression e of type S, <T as FromUriParam<S>>::from_uri_param(e) is invoked. The returned value of type T::Target is used in place of the user’s value and rendered using its UriDisplay implementation.

This trait allows types that differ from the route URI parameter’s types to be used in their place at no cost. For instance, the following implementation, provided by Rocket, allows an &str to be used in a uri! invocation for route URI parameters declared as String:

impl<'a, P: Part> FromUriParam<P, &'a str> for String {
    type Target = &'a str;
}

Because the FromUriParam::Target type is the same as the input type, the conversion is a no-op and free of cost, allowing an &str to be used in place of a String without penalty.

§Provided Implementations

The following types have identity implementations:

  • String, i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64, bool, IpAddr, Ipv4Addr, Ipv6Addr, &str, Cow<str>, Either<A, B>

The following types have identity implementations only in Path:

  • &Path, PathBuf

The following types have identity implementations only in Query:

  • Option<T>, Result<T, E>

The following conversions are implemented for both paths and queries, allowing a value of the type on the left to be used when a type on the right is expected by a route:

  • &str to String
  • String to &str
  • T to Form<T>

The following conversions are implemented only in Path:

  • &str to &Path
  • &str to PathBuf
  • PathBuf to &Path
  • T to Option<T>
  • T to Result<T, E>

The following conversions are implemented only in Query:

  • Option<T> to Result<T, E> (for any E)
  • Result<T, E> to Option<T> (for any E)

See Foreign Impls for all provided implementations.

§Implementing

This trait should only be implemented when you’d like to allow a type different from the route’s declared type to be used in its place in a uri! invocation. For instance, if the route has a type of T and you’d like to use a type of S in a uri! invocation, you’d implement FromUriParam<P, T> for S where P is Path for conversions valid in the path part of a URI, Uri for conversions valid in the query part of a URI, or P: Part when a conversion is valid in either case.

This is typically only warranted for owned-value types with corresponding reference types: String and &str, for instance. In this case, it’s desirable to allow an &str to be used in place of a String.

When implementing FromUriParam, be aware that Rocket will use the UriDisplay implementation of FromUriParam::Target, not of the source type. Incorrect implementations can result in creating unsafe URIs.

§Example

The following example implements FromUriParam<Query, (&str, &str)> for a User type. The implementation allows an (&str, &str) type to be used in a uri! invocation where a User type is expected in the query part of the URI.

use std::fmt;

use rocket::http::uri::fmt::{Formatter, UriDisplay, FromUriParam, Query};

#[derive(FromForm)]
struct User<'a> {
    name: &'a str,
    nickname: String,
}

impl UriDisplay<Query> for User<'_> {
    fn fmt(&self, f: &mut Formatter<Query>) -> fmt::Result {
        f.write_named_value("name", &self.name)?;
        f.write_named_value("nickname", &self.nickname)
    }
}

impl<'a, 'b> FromUriParam<Query, (&'a str, &'b str)> for User<'a> {
    type Target = User<'a>;

    fn from_uri_param((name, nickname): (&'a str, &'b str)) -> User<'a> {
        User { name: name.into(), nickname: nickname.to_string() }
    }
}

With these implementations, the following typechecks:

#[post("/<name>?<user..>")]
fn some_route(name: &str, user: User<'_>)  { /* .. */ }

let uri = uri!(some_route(name = "hey", user = ("Robert Mike", "Bob")));
assert_eq!(uri.path(), "/hey");
assert_eq!(uri.query().unwrap(), "name=Robert%20Mike&nickname=Bob");

Required Associated Types§

type Target: UriDisplay<P>

The resulting type of this conversion.

Required Methods§

fn from_uri_param(param: T) -> Self::Target

Converts a value of type T into a value of type Self::Target. The resulting value of type Self::Target will be rendered into a URI using its UriDisplay implementation.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

§

impl FromUriParam<Path, PathBuf> for PathBuf

§

impl<'a> FromUriParam<Path, &'a str> for PathBuf

A no cost conversion allowing an &str to be used in place of a PathBuf.

§

type Target = &'a Path

§

fn from_uri_param(param: &'a str) -> &'a Path

§

impl<'a> FromUriParam<Path, &'a Path> for &'a Path

§

type Target = &'a Path

§

fn from_uri_param(param: &'a Path) -> &'a Path

§

impl<'a> FromUriParam<Path, &'a Path> for PathBuf

§

type Target = &'a Path

§

fn from_uri_param(param: &'a Path) -> &'a Path

§

impl<'a> FromUriParam<Path, PathBuf> for &'a Path

§

impl<'a> FromUriParam<Query, &'a [u8]> for &'a [u8]

§

type Target = &'a [u8]

§

fn from_uri_param(param: &'a [u8]) -> &'a [u8]

§

impl<'a, 'b> FromUriParam<Path, &'a &'b str> for PathBuf

A no cost conversion allowing an &&str to be used in place of a PathBuf.

§

type Target = &'b Path

§

fn from_uri_param(param: &'a &'b str) -> &'b Path

§

impl<'a, P> FromUriParam<P, &'a str> for &'a str
where P: Part,

§

type Target = &'a str

§

fn from_uri_param(param: &'a str) -> &'a str

§

impl<'a, P> FromUriParam<P, Cow<'a, str>> for Cow<'a, str>
where P: Part,

§

type Target = Cow<'a, str>

§

fn from_uri_param(param: Cow<'a, str>) -> Cow<'a, str>

§

impl<'a, P> FromUriParam<P, String> for &'a str
where P: Part,

§

impl<'x> FromUriParam<Path, &'x PathBuf> for PathBuf

§

type Target = &'x PathBuf

§

fn from_uri_param(param: &'x PathBuf) -> &'x PathBuf

§

impl<'x> FromUriParam<Path, &'x mut PathBuf> for PathBuf

§

type Target = &'x mut PathBuf

§

fn from_uri_param(param: &'x mut PathBuf) -> &'x mut PathBuf

§

impl<'x, 'a> FromUriParam<Path, &'x &'a Path> for &'a Path

§

type Target = &'x &'a Path

§

fn from_uri_param(param: &'x &'a Path) -> &'x &'a Path

§

impl<'x, 'a> FromUriParam<Path, &'x &'a Path> for PathBuf

§

type Target = &'x &'a Path

§

fn from_uri_param(param: &'x &'a Path) -> &'x &'a Path

§

impl<'x, 'a> FromUriParam<Path, &'x PathBuf> for &'a Path

§

type Target = &'x PathBuf

§

fn from_uri_param(param: &'x PathBuf) -> &'x PathBuf

§

impl<'x, 'a> FromUriParam<Path, &'x mut &'a Path> for &'a Path

§

type Target = &'x mut &'a Path

§

fn from_uri_param(param: &'x mut &'a Path) -> &'x mut &'a Path

§

impl<'x, 'a> FromUriParam<Path, &'x mut &'a Path> for PathBuf

§

type Target = &'x mut &'a Path

§

fn from_uri_param(param: &'x mut &'a Path) -> &'x mut &'a Path

§

impl<'x, 'a> FromUriParam<Path, &'x mut PathBuf> for &'a Path

§

type Target = &'x mut PathBuf

§

fn from_uri_param(param: &'x mut PathBuf) -> &'x mut PathBuf

§

impl<'x, 'a> FromUriParam<Query, &'x &'a [u8]> for &'a [u8]

§

type Target = &'x &'a [u8]

§

fn from_uri_param(param: &'x &'a [u8]) -> &'x &'a [u8]

§

impl<'x, 'a> FromUriParam<Query, &'x mut &'a [u8]> for &'a [u8]

§

type Target = &'x mut &'a [u8]

§

fn from_uri_param(param: &'x mut &'a [u8]) -> &'x mut &'a [u8]

§

impl<'x, 'a, P> FromUriParam<P, &'x &'a str> for &'a str
where P: Part,

§

type Target = &'x &'a str

§

fn from_uri_param(param: &'x &'a str) -> &'x &'a str

§

impl<'x, 'a, P> FromUriParam<P, &'x Cow<'a, str>> for Cow<'a, str>
where P: Part,

§

type Target = &'x Cow<'a, str>

§

fn from_uri_param(param: &'x Cow<'a, str>) -> &'x Cow<'a, str>

§

impl<'x, 'a, P> FromUriParam<P, &'x String> for &'a str
where P: Part,

§

type Target = &'x String

§

fn from_uri_param(param: &'x String) -> &'x String

§

impl<'x, 'a, P> FromUriParam<P, &'x mut &'a str> for &'a str
where P: Part,

§

type Target = &'x mut &'a str

§

fn from_uri_param(param: &'x mut &'a str) -> &'x mut &'a str

§

impl<'x, 'a, P> FromUriParam<P, &'x mut Cow<'a, str>> for Cow<'a, str>
where P: Part,

§

type Target = &'x mut Cow<'a, str>

§

fn from_uri_param(param: &'x mut Cow<'a, str>) -> &'x mut Cow<'a, str>

§

impl<'x, 'a, P> FromUriParam<P, &'x mut String> for &'a str
where P: Part,

§

type Target = &'x mut String

§

fn from_uri_param(param: &'x mut String) -> &'x mut String

§

impl<'x, P> FromUriParam<P, &'x IpAddr> for IpAddr
where P: Part,

§

type Target = &'x IpAddr

§

fn from_uri_param(param: &'x IpAddr) -> &'x IpAddr

§

impl<'x, P> FromUriParam<P, &'x SocketAddr> for SocketAddr
where P: Part,

§

type Target = &'x SocketAddr

§

fn from_uri_param(param: &'x SocketAddr) -> &'x SocketAddr

§

impl<'x, P> FromUriParam<P, &'x bool> for bool
where P: Part,

§

type Target = &'x bool

§

fn from_uri_param(param: &'x bool) -> &'x bool

§

impl<'x, P> FromUriParam<P, &'x f32> for f32
where P: Part,

§

type Target = &'x f32

§

fn from_uri_param(param: &'x f32) -> &'x f32

§

impl<'x, P> FromUriParam<P, &'x f64> for f64
where P: Part,

§

type Target = &'x f64

§

fn from_uri_param(param: &'x f64) -> &'x f64

§

impl<'x, P> FromUriParam<P, &'x i8> for i8
where P: Part,

§

type Target = &'x i8

§

fn from_uri_param(param: &'x i8) -> &'x i8

§

impl<'x, P> FromUriParam<P, &'x i16> for i16
where P: Part,

§

type Target = &'x i16

§

fn from_uri_param(param: &'x i16) -> &'x i16

§

impl<'x, P> FromUriParam<P, &'x i32> for i32
where P: Part,

§

type Target = &'x i32

§

fn from_uri_param(param: &'x i32) -> &'x i32

§

impl<'x, P> FromUriParam<P, &'x i64> for i64
where P: Part,

§

type Target = &'x i64

§

fn from_uri_param(param: &'x i64) -> &'x i64

§

impl<'x, P> FromUriParam<P, &'x i128> for i128
where P: Part,

§

type Target = &'x i128

§

fn from_uri_param(param: &'x i128) -> &'x i128

§

impl<'x, P> FromUriParam<P, &'x isize> for isize
where P: Part,

§

type Target = &'x isize

§

fn from_uri_param(param: &'x isize) -> &'x isize

§

impl<'x, P> FromUriParam<P, &'x u8> for u8
where P: Part,

§

type Target = &'x u8

§

fn from_uri_param(param: &'x u8) -> &'x u8

§

impl<'x, P> FromUriParam<P, &'x u16> for u16
where P: Part,

§

type Target = &'x u16

§

fn from_uri_param(param: &'x u16) -> &'x u16

§

impl<'x, P> FromUriParam<P, &'x u32> for u32
where P: Part,

§

type Target = &'x u32

§

fn from_uri_param(param: &'x u32) -> &'x u32

§

impl<'x, P> FromUriParam<P, &'x u64> for u64
where P: Part,

§

type Target = &'x u64

§

fn from_uri_param(param: &'x u64) -> &'x u64

§

impl<'x, P> FromUriParam<P, &'x u128> for u128
where P: Part,

§

type Target = &'x u128

§

fn from_uri_param(param: &'x u128) -> &'x u128

§

impl<'x, P> FromUriParam<P, &'x usize> for usize
where P: Part,

§

type Target = &'x usize

§

fn from_uri_param(param: &'x usize) -> &'x usize

§

impl<'x, P> FromUriParam<P, &'x Ipv4Addr> for Ipv4Addr
where P: Part,

§

type Target = &'x Ipv4Addr

§

fn from_uri_param(param: &'x Ipv4Addr) -> &'x Ipv4Addr

§

impl<'x, P> FromUriParam<P, &'x Ipv6Addr> for Ipv6Addr
where P: Part,

§

type Target = &'x Ipv6Addr

§

fn from_uri_param(param: &'x Ipv6Addr) -> &'x Ipv6Addr

§

impl<'x, P> FromUriParam<P, &'x SocketAddrV4> for SocketAddrV4
where P: Part,

§

impl<'x, P> FromUriParam<P, &'x SocketAddrV6> for SocketAddrV6
where P: Part,

§

impl<'x, P> FromUriParam<P, &'x NonZero<i8>> for NonZero<i8>
where P: Part,

§

type Target = &'x NonZero<i8>

§

fn from_uri_param(param: &'x NonZero<i8>) -> &'x NonZero<i8>

§

impl<'x, P> FromUriParam<P, &'x NonZero<i16>> for NonZero<i16>
where P: Part,

§

type Target = &'x NonZero<i16>

§

fn from_uri_param(param: &'x NonZero<i16>) -> &'x NonZero<i16>

§

impl<'x, P> FromUriParam<P, &'x NonZero<i32>> for NonZero<i32>
where P: Part,

§

type Target = &'x NonZero<i32>

§

fn from_uri_param(param: &'x NonZero<i32>) -> &'x NonZero<i32>

§

impl<'x, P> FromUriParam<P, &'x NonZero<i64>> for NonZero<i64>
where P: Part,

§

type Target = &'x NonZero<i64>

§

fn from_uri_param(param: &'x NonZero<i64>) -> &'x NonZero<i64>

§

impl<'x, P> FromUriParam<P, &'x NonZero<i128>> for NonZero<i128>
where P: Part,

§

type Target = &'x NonZero<i128>

§

fn from_uri_param(param: &'x NonZero<i128>) -> &'x NonZero<i128>

§

impl<'x, P> FromUriParam<P, &'x NonZero<isize>> for NonZero<isize>
where P: Part,

§

type Target = &'x NonZero<isize>

§

fn from_uri_param(param: &'x NonZero<isize>) -> &'x NonZero<isize>

§

impl<'x, P> FromUriParam<P, &'x NonZero<u8>> for NonZero<u8>
where P: Part,

§

type Target = &'x NonZero<u8>

§

fn from_uri_param(param: &'x NonZero<u8>) -> &'x NonZero<u8>

§

impl<'x, P> FromUriParam<P, &'x NonZero<u16>> for NonZero<u16>
where P: Part,

§

type Target = &'x NonZero<u16>

§

fn from_uri_param(param: &'x NonZero<u16>) -> &'x NonZero<u16>

§

impl<'x, P> FromUriParam<P, &'x NonZero<u32>> for NonZero<u32>
where P: Part,

§

type Target = &'x NonZero<u32>

§

fn from_uri_param(param: &'x NonZero<u32>) -> &'x NonZero<u32>

§

impl<'x, P> FromUriParam<P, &'x NonZero<u64>> for NonZero<u64>
where P: Part,

§

type Target = &'x NonZero<u64>

§

fn from_uri_param(param: &'x NonZero<u64>) -> &'x NonZero<u64>

§

impl<'x, P> FromUriParam<P, &'x NonZero<u128>> for NonZero<u128>
where P: Part,

§

type Target = &'x NonZero<u128>

§

fn from_uri_param(param: &'x NonZero<u128>) -> &'x NonZero<u128>

§

impl<'x, P> FromUriParam<P, &'x NonZero<usize>> for NonZero<usize>
where P: Part,

§

type Target = &'x NonZero<usize>

§

fn from_uri_param(param: &'x NonZero<usize>) -> &'x NonZero<usize>

§

impl<'x, P> FromUriParam<P, &'x Date> for Date
where P: Part,

§

type Target = &'x Date

§

fn from_uri_param(param: &'x Date) -> &'x Date

§

impl<'x, P> FromUriParam<P, &'x PrimitiveDateTime> for PrimitiveDateTime
where P: Part,

§

impl<'x, P> FromUriParam<P, &'x Time> for Time
where P: Part,

§

type Target = &'x Time

§

fn from_uri_param(param: &'x Time) -> &'x Time

§

impl<'x, P> FromUriParam<P, &'x mut IpAddr> for IpAddr
where P: Part,

§

type Target = &'x mut IpAddr

§

fn from_uri_param(param: &'x mut IpAddr) -> &'x mut IpAddr

§

impl<'x, P> FromUriParam<P, &'x mut SocketAddr> for SocketAddr
where P: Part,

§

type Target = &'x mut SocketAddr

§

fn from_uri_param(param: &'x mut SocketAddr) -> &'x mut SocketAddr

§

impl<'x, P> FromUriParam<P, &'x mut bool> for bool
where P: Part,

§

type Target = &'x mut bool

§

fn from_uri_param(param: &'x mut bool) -> &'x mut bool

§

impl<'x, P> FromUriParam<P, &'x mut f32> for f32
where P: Part,

§

type Target = &'x mut f32

§

fn from_uri_param(param: &'x mut f32) -> &'x mut f32

§

impl<'x, P> FromUriParam<P, &'x mut f64> for f64
where P: Part,

§

type Target = &'x mut f64

§

fn from_uri_param(param: &'x mut f64) -> &'x mut f64

§

impl<'x, P> FromUriParam<P, &'x mut i8> for i8
where P: Part,

§

type Target = &'x mut i8

§

fn from_uri_param(param: &'x mut i8) -> &'x mut i8

§

impl<'x, P> FromUriParam<P, &'x mut i16> for i16
where P: Part,

§

type Target = &'x mut i16

§

fn from_uri_param(param: &'x mut i16) -> &'x mut i16

§

impl<'x, P> FromUriParam<P, &'x mut i32> for i32
where P: Part,

§

type Target = &'x mut i32

§

fn from_uri_param(param: &'x mut i32) -> &'x mut i32

§

impl<'x, P> FromUriParam<P, &'x mut i64> for i64
where P: Part,

§

type Target = &'x mut i64

§

fn from_uri_param(param: &'x mut i64) -> &'x mut i64

§

impl<'x, P> FromUriParam<P, &'x mut i128> for i128
where P: Part,

§

type Target = &'x mut i128

§

fn from_uri_param(param: &'x mut i128) -> &'x mut i128

§

impl<'x, P> FromUriParam<P, &'x mut isize> for isize
where P: Part,

§

type Target = &'x mut isize

§

fn from_uri_param(param: &'x mut isize) -> &'x mut isize

§

impl<'x, P> FromUriParam<P, &'x mut u8> for u8
where P: Part,

§

type Target = &'x mut u8

§

fn from_uri_param(param: &'x mut u8) -> &'x mut u8

§

impl<'x, P> FromUriParam<P, &'x mut u16> for u16
where P: Part,

§

type Target = &'x mut u16

§

fn from_uri_param(param: &'x mut u16) -> &'x mut u16

§

impl<'x, P> FromUriParam<P, &'x mut u32> for u32
where P: Part,

§

type Target = &'x mut u32

§

fn from_uri_param(param: &'x mut u32) -> &'x mut u32

§

impl<'x, P> FromUriParam<P, &'x mut u64> for u64
where P: Part,

§

type Target = &'x mut u64

§

fn from_uri_param(param: &'x mut u64) -> &'x mut u64

§

impl<'x, P> FromUriParam<P, &'x mut u128> for u128
where P: Part,

§

type Target = &'x mut u128

§

fn from_uri_param(param: &'x mut u128) -> &'x mut u128

§

impl<'x, P> FromUriParam<P, &'x mut usize> for usize
where P: Part,

§

type Target = &'x mut usize

§

fn from_uri_param(param: &'x mut usize) -> &'x mut usize

§

impl<'x, P> FromUriParam<P, &'x mut Ipv4Addr> for Ipv4Addr
where P: Part,

§

type Target = &'x mut Ipv4Addr

§

fn from_uri_param(param: &'x mut Ipv4Addr) -> &'x mut Ipv4Addr

§

impl<'x, P> FromUriParam<P, &'x mut Ipv6Addr> for Ipv6Addr
where P: Part,

§

type Target = &'x mut Ipv6Addr

§

fn from_uri_param(param: &'x mut Ipv6Addr) -> &'x mut Ipv6Addr

§

impl<'x, P> FromUriParam<P, &'x mut SocketAddrV4> for SocketAddrV4
where P: Part,

§

type Target = &'x mut SocketAddrV4

§

fn from_uri_param(param: &'x mut SocketAddrV4) -> &'x mut SocketAddrV4

§

impl<'x, P> FromUriParam<P, &'x mut SocketAddrV6> for SocketAddrV6
where P: Part,

§

type Target = &'x mut SocketAddrV6

§

fn from_uri_param(param: &'x mut SocketAddrV6) -> &'x mut SocketAddrV6

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<i8>> for NonZero<i8>
where P: Part,

§

type Target = &'x mut NonZero<i8>

§

fn from_uri_param(param: &'x mut NonZero<i8>) -> &'x mut NonZero<i8>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<i16>> for NonZero<i16>
where P: Part,

§

type Target = &'x mut NonZero<i16>

§

fn from_uri_param(param: &'x mut NonZero<i16>) -> &'x mut NonZero<i16>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<i32>> for NonZero<i32>
where P: Part,

§

type Target = &'x mut NonZero<i32>

§

fn from_uri_param(param: &'x mut NonZero<i32>) -> &'x mut NonZero<i32>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<i64>> for NonZero<i64>
where P: Part,

§

type Target = &'x mut NonZero<i64>

§

fn from_uri_param(param: &'x mut NonZero<i64>) -> &'x mut NonZero<i64>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<i128>> for NonZero<i128>
where P: Part,

§

type Target = &'x mut NonZero<i128>

§

fn from_uri_param(param: &'x mut NonZero<i128>) -> &'x mut NonZero<i128>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<isize>> for NonZero<isize>
where P: Part,

§

type Target = &'x mut NonZero<isize>

§

fn from_uri_param(param: &'x mut NonZero<isize>) -> &'x mut NonZero<isize>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<u8>> for NonZero<u8>
where P: Part,

§

type Target = &'x mut NonZero<u8>

§

fn from_uri_param(param: &'x mut NonZero<u8>) -> &'x mut NonZero<u8>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<u16>> for NonZero<u16>
where P: Part,

§

type Target = &'x mut NonZero<u16>

§

fn from_uri_param(param: &'x mut NonZero<u16>) -> &'x mut NonZero<u16>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<u32>> for NonZero<u32>
where P: Part,

§

type Target = &'x mut NonZero<u32>

§

fn from_uri_param(param: &'x mut NonZero<u32>) -> &'x mut NonZero<u32>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<u64>> for NonZero<u64>
where P: Part,

§

type Target = &'x mut NonZero<u64>

§

fn from_uri_param(param: &'x mut NonZero<u64>) -> &'x mut NonZero<u64>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<u128>> for NonZero<u128>
where P: Part,

§

type Target = &'x mut NonZero<u128>

§

fn from_uri_param(param: &'x mut NonZero<u128>) -> &'x mut NonZero<u128>

§

impl<'x, P> FromUriParam<P, &'x mut NonZero<usize>> for NonZero<usize>
where P: Part,

§

type Target = &'x mut NonZero<usize>

§

fn from_uri_param(param: &'x mut NonZero<usize>) -> &'x mut NonZero<usize>

§

impl<'x, P> FromUriParam<P, &'x mut Date> for Date
where P: Part,

§

type Target = &'x mut Date

§

fn from_uri_param(param: &'x mut Date) -> &'x mut Date

§

impl<'x, P> FromUriParam<P, &'x mut PrimitiveDateTime> for PrimitiveDateTime
where P: Part,

§

impl<'x, P> FromUriParam<P, &'x mut Time> for Time
where P: Part,

§

type Target = &'x mut Time

§

fn from_uri_param(param: &'x mut Time) -> &'x mut Time

§

impl<'x, T, A, const N: usize> FromUriParam<Query, &'x [A; N]> for [T; N]

§

type Target = &'x [A; N]

§

fn from_uri_param(param: &'x [A; N]) -> &'x [A; N]

§

impl<'x, T, A, const N: usize> FromUriParam<Query, &'x Vec<A>> for [T; N]

§

type Target = &'x Vec<A>

§

fn from_uri_param(param: &'x Vec<A>) -> &'x Vec<A>

§

impl<'x, T, A, const N: usize> FromUriParam<Query, &'x mut [A; N]> for [T; N]

§

type Target = &'x mut [A; N]

§

fn from_uri_param(param: &'x mut [A; N]) -> &'x mut [A; N]

§

impl<'x, T, A, const N: usize> FromUriParam<Query, &'x mut Vec<A>> for [T; N]

§

type Target = &'x mut Vec<A>

§

fn from_uri_param(param: &'x mut Vec<A>) -> &'x mut Vec<A>

§

impl<P> FromUriParam<P, IpAddr> for IpAddr
where P: Part,

§

impl<P> FromUriParam<P, SocketAddr> for SocketAddr
where P: Part,

§

impl<P> FromUriParam<P, bool> for bool
where P: Part,

§

type Target = bool

§

fn from_uri_param(param: bool) -> bool

§

impl<P> FromUriParam<P, f32> for f32
where P: Part,

§

type Target = f32

§

fn from_uri_param(param: f32) -> f32

§

impl<P> FromUriParam<P, f64> for f64
where P: Part,

§

type Target = f64

§

fn from_uri_param(param: f64) -> f64

§

impl<P> FromUriParam<P, i8> for i8
where P: Part,

§

type Target = i8

§

fn from_uri_param(param: i8) -> i8

§

impl<P> FromUriParam<P, i16> for i16
where P: Part,

§

type Target = i16

§

fn from_uri_param(param: i16) -> i16

§

impl<P> FromUriParam<P, i32> for i32
where P: Part,

§

type Target = i32

§

fn from_uri_param(param: i32) -> i32

§

impl<P> FromUriParam<P, i64> for i64
where P: Part,

§

type Target = i64

§

fn from_uri_param(param: i64) -> i64

§

impl<P> FromUriParam<P, i128> for i128
where P: Part,

§

type Target = i128

§

fn from_uri_param(param: i128) -> i128

§

impl<P> FromUriParam<P, isize> for isize
where P: Part,

§

impl<P> FromUriParam<P, u8> for u8
where P: Part,

§

type Target = u8

§

fn from_uri_param(param: u8) -> u8

§

impl<P> FromUriParam<P, u16> for u16
where P: Part,

§

type Target = u16

§

fn from_uri_param(param: u16) -> u16

§

impl<P> FromUriParam<P, u32> for u32
where P: Part,

§

type Target = u32

§

fn from_uri_param(param: u32) -> u32

§

impl<P> FromUriParam<P, u64> for u64
where P: Part,

§

type Target = u64

§

fn from_uri_param(param: u64) -> u64

§

impl<P> FromUriParam<P, u128> for u128
where P: Part,

§

type Target = u128

§

fn from_uri_param(param: u128) -> u128

§

impl<P> FromUriParam<P, usize> for usize
where P: Part,

§

impl<P> FromUriParam<P, Ipv4Addr> for Ipv4Addr
where P: Part,

§

impl<P> FromUriParam<P, Ipv6Addr> for Ipv6Addr
where P: Part,

§

impl<P> FromUriParam<P, SocketAddrV4> for SocketAddrV4
where P: Part,

§

impl<P> FromUriParam<P, SocketAddrV6> for SocketAddrV6
where P: Part,

§

impl<P> FromUriParam<P, NonZero<i8>> for NonZero<i8>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<i16>> for NonZero<i16>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<i32>> for NonZero<i32>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<i64>> for NonZero<i64>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<i128>> for NonZero<i128>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<isize>> for NonZero<isize>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<u8>> for NonZero<u8>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<u16>> for NonZero<u16>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<u32>> for NonZero<u32>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<u64>> for NonZero<u64>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<u128>> for NonZero<u128>
where P: Part,

§

impl<P> FromUriParam<P, NonZero<usize>> for NonZero<usize>
where P: Part,

§

impl<P> FromUriParam<P, Date> for Date
where P: Part,

§

type Target = Date

§

fn from_uri_param(param: Date) -> Date

§

impl<P> FromUriParam<P, PrimitiveDateTime> for PrimitiveDateTime
where P: Part,

§

impl<P> FromUriParam<P, Time> for Time
where P: Part,

§

type Target = Time

§

fn from_uri_param(param: Time) -> Time

§

impl<P, A, B, T, U> FromUriParam<P, Either<A, B>> for Either<T, U>
where P: Part, T: FromUriParam<P, A>, U: FromUriParam<P, B>,

§

type Target = Either<<T as FromUriParam<P, A>>::Target, <U as FromUriParam<P, B>>::Target>

§

fn from_uri_param( param: Either<A, B> ) -> <Either<T, U> as FromUriParam<P, Either<A, B>>>::Target

§

impl<T, A, const N: usize> FromUriParam<Query, [A; N]> for [T; N]

§

impl<T, A, const N: usize> FromUriParam<Query, Vec<A>> for [T; N]

§

type Target = Vec<A>

§

fn from_uri_param(param: Vec<A>) -> Vec<A>

Implementors§

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a BTreeMap<A, B>> for BTreeMap<K, V>

§

type Target = &'a BTreeMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a BTreeMap<A, B>> for HashMap<K, V>

§

type Target = &'a BTreeMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a HashMap<A, B>> for BTreeMap<K, V>

§

type Target = &'a HashMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a HashMap<A, B>> for HashMap<K, V>

§

type Target = &'a HashMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a mut BTreeMap<A, B>> for BTreeMap<K, V>

§

type Target = &'a BTreeMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a mut BTreeMap<A, B>> for HashMap<K, V>

§

type Target = &'a BTreeMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a mut HashMap<A, B>> for BTreeMap<K, V>

§

type Target = &'a HashMap<A, B>

§

impl<'a, K, V, A, B> FromUriParam<Query, &'a mut HashMap<A, B>> for HashMap<K, V>

§

type Target = &'a HashMap<A, B>

§

impl<'a, P> FromUriParam<P, &'a str> for String
where P: Part,

§

type Target = &'a str

source§

impl<'a, T: Serialize> FromUriParam<Query, &'a T> for Json<T>

Available on crate feature json only.
source§

impl<'a, T: Serialize> FromUriParam<Query, &'a mut T> for Json<T>

Available on crate feature json only.
source§

impl<'f, A, T: FromUriParam<Query, A> + FromForm<'f>> FromUriParam<Query, A> for Lenient<T>

§

type Target = <T as FromUriParam<Query, A>>::Target

source§

impl<'f, A, T: FromUriParam<Query, A> + FromForm<'f>> FromUriParam<Query, A> for Strict<T>

§

type Target = <T as FromUriParam<Query, A>>::Target

§

impl<'x, 'a, P> FromUriParam<P, &'x &'a str> for String
where P: Part,

§

type Target = &'x &'a str

§

impl<'x, 'a, P> FromUriParam<P, &'x mut &'a str> for String
where P: Part,

§

type Target = &'x mut &'a str

§

impl<'x, P> FromUriParam<P, &'x String> for String
where P: Part,

§

type Target = &'x String

§

impl<'x, P> FromUriParam<P, &'x Uuid> for Uuid
where P: Part,

§

type Target = &'x Uuid

§

impl<'x, P> FromUriParam<P, &'x mut String> for String
where P: Part,

§

type Target = &'x mut String

§

impl<'x, P> FromUriParam<P, &'x mut Uuid> for Uuid
where P: Part,

§

type Target = &'x mut Uuid

§

impl<'x, T, A> FromUriParam<Query, &'x Vec<A>> for Vec<T>

§

type Target = &'x Vec<A>

§

impl<'x, T, A> FromUriParam<Query, &'x mut Vec<A>> for Vec<T>

§

type Target = &'x mut Vec<A>

§

impl<'x, T, A, const N: usize> FromUriParam<Query, &'x [A; N]> for Vec<T>

§

type Target = &'x [A; N]

§

impl<'x, T, A, const N: usize> FromUriParam<Query, &'x mut [A; N]> for Vec<T>

§

type Target = &'x mut [A; N]

source§

impl<'x, T: Serialize> FromUriParam<Query, &'x Json<T>> for Json<T>

Available on crate feature json only.
§

type Target = &'x Json<T>

source§

impl<'x, T: Serialize> FromUriParam<Query, &'x mut Json<T>> for Json<T>

Available on crate feature json only.
§

type Target = &'x mut Json<T>

§

impl<A, E, T> FromUriParam<Path, A> for Result<T, E>
where T: FromUriParam<Path, A>,

A no cost conversion allowing T to be used in place of an Result<T, E>.

§

type Target = <T as FromUriParam<Path, A>>::Target

§

impl<A, E, T> FromUriParam<Query, Option<A>> for Result<T, E>
where T: FromUriParam<Query, A>,

§

impl<A, E, T> FromUriParam<Query, Result<A, E>> for Option<T>
where T: FromUriParam<Query, A>,

§

type Target = Result<<T as FromUriParam<Query, A>>::Target, E>

§

impl<A, E, T> FromUriParam<Query, Result<A, E>> for Result<T, E>
where T: FromUriParam<Query, A>,

§

type Target = Result<<T as FromUriParam<Query, A>>::Target, E>

§

impl<A, T> FromUriParam<Path, A> for Option<T>
where T: FromUriParam<Path, A>,

A no cost conversion allowing any T to be used in place of an Option<T>.

§

type Target = <T as FromUriParam<Path, A>>::Target

§

impl<A, T> FromUriParam<Query, Option<A>> for Option<T>
where T: FromUriParam<Query, A>,

§

impl<K, V, A, B> FromUriParam<Query, BTreeMap<A, B>> for BTreeMap<K, V>

§

type Target = BTreeMap<A, B>

§

impl<K, V, A, B> FromUriParam<Query, BTreeMap<A, B>> for HashMap<K, V>

§

type Target = BTreeMap<A, B>

§

impl<K, V, A, B> FromUriParam<Query, HashMap<A, B>> for BTreeMap<K, V>

§

type Target = HashMap<A, B>

§

impl<K, V, A, B> FromUriParam<Query, HashMap<A, B>> for HashMap<K, V>

§

type Target = HashMap<A, B>

§

impl<P> FromUriParam<P, String> for String
where P: Part,

§

impl<P> FromUriParam<P, Uuid> for Uuid
where P: Part,

§

type Target = Uuid

§

impl<T, A> FromUriParam<Query, Vec<A>> for Vec<T>

§

type Target = Vec<A>

§

impl<T, A, const N: usize> FromUriParam<Query, [A; N]> for Vec<T>

source§

impl<T: Serialize> FromUriParam<Query, Json<T>> for Json<T>

Available on crate feature json only.
§

type Target = Json<T>

source§

impl<T: Serialize> FromUriParam<Query, T> for Json<T>

Available on crate feature json only.
§

type Target = Json<T>