Enum rocket_http::uri::Uri
source · 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 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§
source§impl<'a> Uri<'a>
impl<'a> Uri<'a>
sourcepub fn parse<T>(string: &'a str) -> Result<Uri<'a>, Error<'_>>where
T: Into<Uri<'a>> + TryFrom<&'a str, Error = Error<'a>>,
pub fn parse<T>(string: &'a str) -> Result<Uri<'a>, Error<'_>>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");sourcepub fn parse_any(string: &'a str) -> Result<Uri<'a>, Error<'_>>
pub fn parse_any(string: &'a str) -> Result<Uri<'a>, Error<'_>>
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:
AsteriskOriginAuthorityAbsoluteReference
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");sourcepub fn origin(&self) -> Option<&Origin<'a>>
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());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());sourcepub fn absolute(&self) -> Option<&Absolute<'a>>
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());sourcepub fn reference(&self) -> Option<&Reference<'a>>
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());