pub enum Uri<'a> {
Origin(Origin<'a>),
Authority(Authority<'a>),
Absolute(Absolute<'a>),
Asterisk,
}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 contain origin-type URIs.
Nevertheless, the Uri type is typically enountered as a conversion target.
In particular, you will likely see generic bounds of the form: T: TryInto<Uri> (for instance, in Redirect
methods). This means that you can provide any type T that implements
TryInto<Uri>, or, equivalently, any type U for which Uri implements
TryFrom<U> or From<U>. These include &str and String, Origin,
Authority, and Absolute.
Parsing
The Uri type implements a full, zero-allocation, zero-copy RFC 7230
compliant parser. To parse an &str into a Uri, use the Uri::parse()
method. 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.
Percent Encoding/Decoding
This type also provides the following percent encoding/decoding helper
methods: Uri::percent_encode(), Uri::percent_decode(), and
Uri::percent_decode_lossy().
Variants
Origin(Origin<'a>)
An origin URI.
Authority(Authority<'a>)
An authority URI.
Absolute(Absolute<'a>)
An absolute URI.
Asterisk
An asterisk: exactly *.
Implementations
sourceimpl<'a> Uri<'a>
impl<'a> Uri<'a>
sourcepub fn parse(string: &'a str) -> Result<Uri<'a>, Error<'a>>
pub fn parse(string: &'a str) -> Result<Uri<'a>, Error<'a>>
Parses the string string into a Uri. Parsing will never allocate.
Returns an Error if string is not a valid URI.
Example
use rocket::http::uri::Uri;
// Parse a valid origin URI (note: in practice, use `Origin::parse()`).
let uri = Uri::parse("/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(), Some("query"));
// Invalid URIs fail to parse.
Uri::parse("foo bar").expect_err("invalid URI");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;
let uri = Uri::parse("/a/b/c?query").expect("valid URI");
assert!(uri.origin().is_some());
let uri = Uri::parse("http://google.com").expect("valid URI");
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;
let uri = Uri::parse("user:pass@domain.com").expect("valid URI");
assert!(uri.authority().is_some());
let uri = Uri::parse("http://google.com").expect("valid URI");
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;
let uri = Uri::parse("http://google.com").expect("valid URI");
assert!(uri.absolute().is_some());
let uri = Uri::parse("/path").expect("valid URI");
assert!(uri.absolute().is_none());sourcepub fn percent_encode(string: &str) -> Cow<'_, str>
pub fn percent_encode(string: &str) -> Cow<'_, str>
Returns a URL-encoded version of the string. Any reserved characters are percent-encoded.
Examples
use rocket::http::uri::Uri;
let encoded = Uri::percent_encode("hello?a=<b>hi</b>");
assert_eq!(encoded, "hello%3Fa%3D%3Cb%3Ehi%3C%2Fb%3E");sourcepub fn percent_decode(string: &[u8]) -> Result<Cow<'_, str>, Utf8Error>
pub fn percent_decode(string: &[u8]) -> Result<Cow<'_, str>, Utf8Error>
Returns a URL-decoded version of the string. If the percent encoded
values are not valid UTF-8, an Err is returned.
Examples
use rocket::http::uri::Uri;
let decoded = Uri::percent_decode("/Hello%2C%20world%21".as_bytes());
assert_eq!(decoded.unwrap(), "/Hello, world!");sourcepub fn percent_decode_lossy(string: &[u8]) -> Cow<'_, str>
pub fn percent_decode_lossy(string: &[u8]) -> Cow<'_, str>
Returns a URL-decoded version of the path. Any invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.
Examples
use rocket::http::uri::Uri;
let decoded = Uri::percent_decode_lossy("/Hello%2C%20world%21".as_bytes());
assert_eq!(decoded, "/Hello, world!");Trait Implementations
sourceimpl<'a> IntoOwned for Uri<'a>
impl<'a> IntoOwned for Uri<'a>
sourcefn into_owned(self) -> Uri<'static>
fn into_owned(self) -> Uri<'static>
Converts self into an owned version of itself.
impl<'a> StructuralPartialEq for Uri<'a>
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Uri<'a>
impl<'a> Send for Uri<'a>
impl<'a> Sync for Uri<'a>
impl<'a> Unpin for Uri<'a>
impl<'a> UnwindSafe for Uri<'a>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> IntoCollection<T> for T
impl<T> IntoCollection<T> for T
sourcefn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
Converts self into a collection.
fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
F: FnMut(T) -> U,
A: Array<Item = U>,
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into)Uses borrowed data to replace owned data, usually by cloning. Read more