Enum rocket::http::uri::Uri

pub enum Uri<'a> {
    Asterisk(Asterisk),
    Origin(Origin<'a>),
    Authority(Authority<'a>),
    Absolute(Absolute<'a>),
    Reference(Reference<'a>),
}

An enum encapsulating any of the possible URI variants.

Usage

In Rocket, this type will rarely be used directly. Instead, you will typically encounter URIs via the Origin type. This is because all incoming requests accepted by Rocket contain URIs in origin-form.

Parsing

The Uri type implements a full, zero-allocation, zero-copy RFC 7230 compliant “request target” parser with limited liberties for real-world deviations. In particular, the parser deviates as follows:

• It accepts % characters without two trailing hex-digits.

• It accepts the following additional unencoded characters in query parts, to match real-world browser behavior:

  {, }, [, ], \, ^, `, |

To parse an &str into a Uri, use Uri::parse(). Alternatively, you may also use the TryFrom<&str> and TryFrom<String> trait implementation. To inspect the parsed type, match on the resulting enum and use the methods of the internal structure.

Variants

Asterisk(Asterisk)

An asterisk: exactly *.

Origin(Origin<'a>)

An origin URI.

Authority(Authority<'a>)

An authority URI.

Absolute(Absolute<'a>)

An absolute URI.

Reference(Reference<'a>)

A URI reference.

Implementations

impl<'a> Uri<'a>

pub fn parse<T>(string: &'a str) -> Result<Uri<'a>, Error<'a>>

where T: Into<Uri<'a>> + TryFrom<&'a str, Error = Error<'a>>,

Parses the string string into a Uri of kind T.

This is identical to T::parse(string).map(Uri::from).

T is typically one of Asterisk, Origin, Authority, Absolute, or Reference. Parsing never allocates. Returns an Error if string is not a valid URI of kind T.

To perform an ambiguous parse into any valid URI type, use Uri::parse_any().

Example

use rocket::http::uri::{Uri, Origin};

// Parse a valid origin URI (note: in practice, use `Origin::parse()`).
let uri = Uri::parse::<Origin>("/a/b/c?query").expect("valid URI");
let origin = uri.origin().expect("origin URI");
assert_eq!(origin.path(), "/a/b/c");
assert_eq!(origin.query().unwrap(), "query");

// Prefer to use the `uri!()` macro for static inputs. The return value
// is of the specific type, not `Uri`.
let origin = uri!("/a/b/c?query");
assert_eq!(origin.path(), "/a/b/c");
assert_eq!(origin.query().unwrap(), "query");

// Invalid URIs fail to parse.
Uri::parse::<Origin>("foo bar").expect_err("invalid URI");

pub fn parse_any(string: &'a str) -> Result<Uri<'a>, Error<'a>>

Parse string into a the “best fit” URI type.

Always prefer to use uri!() for statically known inputs.

Because URI parsing is ambiguous (that is, there isn’t a one-to-one mapping between strings and a URI type), the internal type returned by this method may not be the desired type. This method chooses the “best fit” type for a given string by preferring to parse in the following order:

• Asterisk
• Origin
• Authority
• Absolute
• Reference

Thus, even though * is a valid Asterisk and Reference URI, it will parse as an Asterisk.

Example

use rocket::http::uri::{Uri, Origin, Reference};

// An absolute path is an origin _unless_ it contains a fragment.
let uri = Uri::parse_any("/a/b/c?query").expect("valid URI");
let origin = uri.origin().expect("origin URI");
assert_eq!(origin.path(), "/a/b/c");
assert_eq!(origin.query().unwrap(), "query");

let uri = Uri::parse_any("/a/b/c?query#fragment").expect("valid URI");
let reference = uri.reference().expect("reference URI");
assert_eq!(reference.path(), "/a/b/c");
assert_eq!(reference.query().unwrap(), "query");
assert_eq!(reference.fragment().unwrap(), "fragment");

// Prefer to use the `uri!()` macro for static inputs. The return type
// is the internal type, not `Uri`. The explicit type is not required.
let uri: Origin = uri!("/a/b/c?query");
let uri: Reference = uri!("/a/b/c?query#fragment");

pub fn origin(&self) -> Option<&Origin<'a>>

Returns the internal instance of Origin if self is a Uri::Origin. Otherwise, returns None.

Example

use rocket::http::uri::{Uri, Absolute, Origin};

let uri = Uri::parse::<Origin>("/a/b/c?query").expect("valid URI");
assert!(uri.origin().is_some());

let uri = Uri::from(uri!("/a/b/c?query"));
assert!(uri.origin().is_some());

let uri = Uri::parse::<Absolute>("https://rocket.rs").expect("valid URI");
assert!(uri.origin().is_none());

let uri = Uri::from(uri!("https://rocket.rs"));
assert!(uri.origin().is_none());

pub fn authority(&self) -> Option<&Authority<'a>>

Returns the internal instance of Authority if self is a Uri::Authority. Otherwise, returns None.

Example

use rocket::http::uri::{Uri, Absolute, Authority};

let uri = Uri::parse::<Authority>("user:pass@domain.com").expect("valid URI");
assert!(uri.authority().is_some());

let uri = Uri::from(uri!("user:pass@domain.com"));
assert!(uri.authority().is_some());

let uri = Uri::parse::<Absolute>("https://rocket.rs").expect("valid URI");
assert!(uri.authority().is_none());

let uri = Uri::from(uri!("https://rocket.rs"));
assert!(uri.authority().is_none());

pub fn absolute(&self) -> Option<&Absolute<'a>>

Returns the internal instance of Absolute if self is a Uri::Absolute. Otherwise, returns None.

Example

use rocket::http::uri::{Uri, Absolute, Origin};

let uri = Uri::parse::<Absolute>("http://rocket.rs").expect("valid URI");
assert!(uri.absolute().is_some());

let uri = Uri::from(uri!("http://rocket.rs"));
assert!(uri.absolute().is_some());

let uri = Uri::parse::<Origin>("/path").expect("valid URI");
assert!(uri.absolute().is_none());

let uri = Uri::from(uri!("/path"));
assert!(uri.absolute().is_none());

pub fn reference(&self) -> Option<&Reference<'a>>

Returns the internal instance of Reference if self is a Uri::Reference. Otherwise, returns None.

Example

use rocket::http::uri::{Uri, Absolute, Reference};

let uri = Uri::parse::<Reference>("foo/bar").expect("valid URI");
assert!(uri.reference().is_some());

let uri = Uri::from(uri!("foo/bar"));
assert!(uri.reference().is_some());

let uri = Uri::parse::<Absolute>("https://rocket.rs").expect("valid URI");
assert!(uri.reference().is_none());

let uri = Uri::from(uri!("https://rocket.rs"));
assert!(uri.reference().is_none());

Trait Implementations

impl<'a> Clone for Uri<'a>

fn clone(&self) -> Uri<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Uri<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for Uri<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<Absolute<'a>> for Uri<'a>

fn from(other: Absolute<'a>) -> Uri<'a>

Converts to this type from the input type.

impl<'a> From<Asterisk> for Uri<'a>

fn from(other: Asterisk) -> Uri<'a>

Converts to this type from the input type.

impl<'a> From<Authority<'a>> for Uri<'a>

fn from(other: Authority<'a>) -> Uri<'a>

Converts to this type from the input type.

impl<'a> From<Origin<'a>> for Uri<'a>

fn from(other: Origin<'a>) -> Uri<'a>

Converts to this type from the input type.

impl<'a> From<Reference<'a>> for Uri<'a>

fn from(other: Reference<'a>) -> Uri<'a>

Converts to this type from the input type.

impl IntoOwned for Uri<'_>

type Owned = Uri<'static>

The owned version of the type.

fn into_owned(self) -> Uri<'static>

Converts self into an owned version of itself.

impl<'b, 'a> PartialEq<&Absolute<'a>> for Uri<'b>

fn eq(&self, other: &&Absolute<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b> PartialEq<&Asterisk> for Uri<'b>

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

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<&Authority<'a>> for Uri<'b>

fn eq(&self, other: &&Authority<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<&Origin<'a>> for Uri<'b>

fn eq(&self, other: &&Origin<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<&Reference<'a>> for Uri<'b>

fn eq(&self, other: &&Reference<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Absolute<'a>> for Uri<'b>

fn eq(&self, other: &Absolute<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b> PartialEq<Asterisk> for Uri<'b>

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

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Authority<'a>> for Uri<'b>

fn eq(&self, other: &Authority<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Origin<'a>> for Uri<'b>

fn eq(&self, other: &Origin<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Reference<'a>> for Uri<'b>

fn eq(&self, other: &Reference<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for &Absolute<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b> PartialEq<Uri<'b>> for &Asterisk

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for &Authority<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for &Origin<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for &Reference<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for Absolute<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b> PartialEq<Uri<'b>> for Asterisk

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for Authority<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for Origin<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'b, 'a> PartialEq<Uri<'b>> for Reference<'a>

fn eq(&self, other: &Uri<'b>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'a> PartialEq for Uri<'a>

fn eq(&self, other: &Uri<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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<'a> TryFrom<Uri<'a>> for Absolute<'a>

type Error = TryFromUriError

The type returned in the event of a conversion error.

fn try_from( uri: Uri<'a> ) -> Result<Absolute<'a>, <Absolute<'a> as TryFrom<Uri<'a>>>::Error>

Performs the conversion.

impl<'a> TryFrom<Uri<'a>> for Asterisk

type Error = TryFromUriError

The type returned in the event of a conversion error.

fn try_from( uri: Uri<'a> ) -> Result<Asterisk, <Asterisk as TryFrom<Uri<'a>>>::Error>

Performs the conversion.

impl<'a> TryFrom<Uri<'a>> for Authority<'a>

type Error = TryFromUriError

The type returned in the event of a conversion error.

fn try_from( uri: Uri<'a> ) -> Result<Authority<'a>, <Authority<'a> as TryFrom<Uri<'a>>>::Error>

Performs the conversion.

impl<'a> TryFrom<Uri<'a>> for Origin<'a>

type Error = TryFromUriError

The type returned in the event of a conversion error.

fn try_from( uri: Uri<'a> ) -> Result<Origin<'a>, <Origin<'a> as TryFrom<Uri<'a>>>::Error>

Performs the conversion.

impl<'a> TryFrom<Uri<'a>> for Reference<'a>

type Error = TryFromUriError

The type returned in the event of a conversion error.

fn try_from( uri: Uri<'a> ) -> Result<Reference<'a>, <Reference<'a> as TryFrom<Uri<'a>>>::Error>

Performs the conversion.

impl<'a> StructuralPartialEq for Uri<'a>