Enum rocket_http::uri::Uri [−][src]
pub enum Uri<'a> { Asterisk(Asterisk), Origin(Origin<'a>), Authority(Authority<'a>), Absolute(Absolute<'a>), Reference(Reference<'a>), }
Expand description
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 accepred 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
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 ambgiuous 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");
Parse string
into a the “best fit” URI type.
Always prefer to use uri!()
for statically known inputs.
Because URI parsing is ambgious (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");
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());
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());
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());
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
Converts self
into an owned version of itself.
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Uri<'a>
impl<'a> UnwindSafe for Uri<'a>
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more