Struct rocket::http::uri::Origin

pub struct Origin<'a> { /* private fields */ }

A URI with an absolute path and optional query: /path?query.

Origin URIs are the primary type of URI encountered in Rocket applications. They are also the simplest type of URIs, made up of only a path and an optional query.

Structure

The following diagram illustrates the syntactic structure of an origin URI:

/first_segment/second_segment/third?optional=query
|---------------------------------| |------------|
                path                    query

The URI must begin with a /, can be followed by any number of segments, and an optional ? query separator and query string.

Normalization

Rocket prefers, and will sometimes require, origin URIs to be normalized. A normalized origin URI is a valid origin URI that contains no empty segments except optionally a trailing slash.

As an example, the following URIs are all valid, normalized URIs:

"/",
"/?",
"/a/b/",
"/a/b/c",
"/a/b/c/",
"/a/b/c?",
"/a/b/c?q",
"/hello?lang=en",
"/hello/?lang=en",
"/some%20thing?q=foo&lang=fr",

By contrast, the following are valid but non-normal URIs:

"//",               // an empty segment
"/a/ab//c//d",      // two empty segments
"/?a&&b",           // empty query segment
"/?foo&",           // trailing empty query segment

The Origin::into_normalized() method can be used to normalize any Origin:

// non-normal versions
"//", "/a/b//c", "/a/ab//c//d/", "/a?a&&b&",

// normalized versions
"/",  "/a/b/c",  "/a/ab/c/d/", "/a?a&b",

(De)serialization

Origin is both Serialize and Deserialize:

use serde::{Serialize, Deserialize};
use rocket::http::uri::Origin;

#[derive(Deserialize, Serialize)]
struct UriOwned {
    uri: Origin<'static>,
}

#[derive(Deserialize, Serialize)]
struct UriBorrowed<'a> {
    uri: Origin<'a>,
}

Implementations

impl<'a> Origin<'a>

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

Parses the string string into an Origin. Parsing will never allocate. Returns an Error if string is not a valid origin URI.

Example

use rocket::http::uri::Origin;

// Parse a valid origin URI.
let uri = Origin::parse("/a/b/c?query").expect("valid URI");
assert_eq!(uri.path(), "/a/b/c");
assert_eq!(uri.query().unwrap(), "query");

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

// Prefer to use `uri!()` when the input is statically known:
let uri = uri!("/a/b/c?query");
assert_eq!(uri.path(), "/a/b/c");
assert_eq!(uri.query().unwrap(), "query");

pub fn parse_owned(string: String) -> Result<Origin<'static>, Error<'static>>

Parses the string string into an Origin. Never allocates on success. May allocate on error.

This method should be used instead of Origin::parse() when the source URI is already a String. Returns an Error if string is not a valid origin URI.

Example

use rocket::http::uri::Origin;

let source = format!("/foo/{}/three", 2);
let uri = Origin::parse_owned(source).expect("valid URI");
assert_eq!(uri.path(), "/foo/2/three");
assert!(uri.query().is_none());

pub fn path(&self) -> Path<'_>

Returns the path part of this URI.

Example

let uri = uri!("/a/b/c");
assert_eq!(uri.path(), "/a/b/c");

let uri = uri!("/a/b/c?name=bob");
assert_eq!(uri.path(), "/a/b/c");

pub fn query(&self) -> Option<Query<'_>>

Returns the query part of this URI without the question mark, if there is any.

Example

let uri = uri!("/a/b/c?alphabet=true");
assert_eq!(uri.query().unwrap(), "alphabet=true");

let uri = uri!("/a/b/c");
assert!(uri.query().is_none());

pub fn map_path<'s, F, P>(&'s self, f: F) -> Option<Origin<'a>>

where F: FnOnce(&'s RawStr) -> P, P: Into<RawStrBuf> + 's,

Applies the function f to the internal path and returns a new Origin with the new path. If the path returned from f is invalid, returns None. Otherwise, returns Some, even if the new path is abnormal.

Examples

Affix a trailing slash if one isn’t present.

let uri = uri!("/a/b/c");
let expected_uri = uri!("/a/b/c/d");
assert_eq!(uri.map_path(|p| format!("{}/d", p)), Some(expected_uri));

let uri = uri!("/a/b/c");
let abnormal_map = uri.map_path(|p| format!("{}///d", p));
assert_eq!(abnormal_map.unwrap(), "/a/b/c///d");

let uri = uri!("/a/b/c");
let expected = uri!("/b/c");
let mapped = uri.map_path(|p| p.strip_prefix("/a").unwrap_or(p));
assert_eq!(mapped, Some(expected));

let uri = uri!("/a");
assert_eq!(uri.map_path(|p| p.strip_prefix("/a").unwrap_or(p)), None);

let uri = uri!("/a/b/c");
assert_eq!(uri.map_path(|p| format!("hi/{}", p)), None);

pub fn clear_query(&mut self)

Removes the query part of this URI, if there is any.

Example

let mut uri = uri!("/a/b/c?query=some");
assert_eq!(uri.query().unwrap(), "query=some");

uri.clear_query();
assert!(uri.query().is_none());

pub fn is_normalized(&self) -> bool

Returns true if self is normalized. Otherwise, returns false.

See Normalization for more information on what it means for an origin URI to be normalized. Note that uri!() always normalizes static input.

Example

use rocket::http::uri::Origin;

assert!(Origin::parse("/").unwrap().is_normalized());
assert!(Origin::parse("/a/b/c").unwrap().is_normalized());
assert!(Origin::parse("/a/b/c?a=b&c").unwrap().is_normalized());

assert!(!Origin::parse("/a/b/c//d").unwrap().is_normalized());
assert!(!Origin::parse("/a?q&&b").unwrap().is_normalized());

assert!(uri!("/a/b/c//d").is_normalized());
assert!(uri!("/a?q&&b").is_normalized());

pub fn normalize(&mut self)

Normalizes self. This is a no-op if self is already normalized.

See Normalization for more information on what it means for an origin URI to be normalized.

Example

use rocket::http::uri::Origin;

let mut abnormal = Origin::parse("/a/b/c//d").unwrap();
assert!(!abnormal.is_normalized());
abnormal.normalize();
assert!(abnormal.is_normalized());

pub fn into_normalized(self) -> Origin<'a>

Consumes self and returns a normalized version.

This is a no-op if self is already normalized. See Normalization for more information on what it means for an origin URI to be normalized.

Example

use rocket::http::uri::Origin;

let abnormal = Origin::parse("/a/b/c//d").unwrap();
assert!(!abnormal.is_normalized());
assert!(abnormal.into_normalized().is_normalized());

pub fn has_trailing_slash(&self) -> bool

Returns true if self has a trailing slash.

This is defined as path.len() > 1 && path.ends_with('/'). This implies that the URI / is not considered to have a trailing slash.

Example

assert!(!uri!("/").has_trailing_slash());
assert!(!uri!("/a").has_trailing_slash());
assert!(!uri!("/foo/bar/baz").has_trailing_slash());

assert!(uri!("/a/").has_trailing_slash());
assert!(uri!("/foo/").has_trailing_slash());
assert!(uri!("/foo/bar/baz/").has_trailing_slash());

pub fn is_normalized_nontrailing(&self) -> bool

Returns true if self is normalized (Origin::is_normalized()) and does not have a trailing slash (Origin::has_trailing_slash()). Otherwise returns false.

Example

use rocket::http::uri::Origin;

let origin = Origin::parse("/").unwrap();
assert!(origin.is_normalized_nontrailing());

let origin = Origin::parse("/foo/bar").unwrap();
assert!(origin.is_normalized_nontrailing());

let origin = Origin::parse("//").unwrap();
assert!(!origin.is_normalized_nontrailing());

let origin = Origin::parse("/foo/bar//baz/").unwrap();
assert!(!origin.is_normalized_nontrailing());

let origin = Origin::parse("/foo/bar/").unwrap();
assert!(!origin.is_normalized_nontrailing());

pub fn into_normalized_nontrailing(self) -> Origin<'a>

Converts self into a normalized origin path without a trailing slash. Does nothing is self is already normalized_nontrailing.

Example

use rocket::http::uri::Origin;

let origin = Origin::parse("/").unwrap();
assert!(origin.is_normalized_nontrailing());

let normalized = origin.into_normalized_nontrailing();
assert_eq!(normalized, uri!("/"));

let origin = Origin::parse("//").unwrap();
assert!(!origin.is_normalized_nontrailing());

let normalized = origin.into_normalized_nontrailing();
assert_eq!(normalized, uri!("/"));

let origin = Origin::parse_owned("/foo/bar//baz/".into()).unwrap();
assert!(!origin.is_normalized_nontrailing());

let normalized = origin.into_normalized_nontrailing();
assert_eq!(normalized, uri!("/foo/bar/baz"));

let origin = Origin::parse("/foo/bar/").unwrap();
assert!(!origin.is_normalized_nontrailing());

let normalized = origin.into_normalized_nontrailing();
assert_eq!(normalized, uri!("/foo/bar"));

Trait Implementations

impl<'a> Clone for Origin<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Origin<'a>

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

Formats the value using the given formatter.

impl<'a, 'de> Deserialize<'de> for Origin<'a>

fn deserialize<D>( deserializer: D ) -> Result<Origin<'a>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Origin<'_>

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

Formats the value using the given formatter.

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

fn from(origin: Origin<'a>) -> Reference<'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<'r> FromRequest<'r> for &'r Origin<'r>

type Error = Infallible

The associated error to be returned if derivation fails.

fn from_request<'life0, 'async_trait>( request: &'r Request<'life0> ) -> Pin<Box<dyn Future<Output = Outcome<Self, Infallible>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

Derives an instance of Self from the incoming request metadata.

impl Hash for Origin<'_>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoOwned for Origin<'_>

type Owned = Origin<'static>

The owned version of the type.

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

Converts self into an owned version of itself.

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 PartialEq<&str> for Origin<'_>

fn eq(&self, other: &&str) -> 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 PartialEq<Origin<'_>> for str

fn eq(&self, other: &Origin<'_>) -> 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<'a, 'b> PartialEq<Origin<'b>> for Origin<'a>

fn eq(&self, other: &Origin<'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, 'b> PartialEq<Origin<'b>> for RouteUri<'a>

fn eq(&self, other: &Origin<'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 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 PartialEq<str> for Origin<'_>

fn eq(&self, string: &str) -> 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> Serialize for Origin<'a>

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> TryFrom<&'a String> for Origin<'a>

type Error = Error<'a>

The type returned in the event of a conversion error.

fn try_from( value: &'a String ) -> Result<Origin<'a>, <Origin<'a> as TryFrom<&'a String>>::Error>

Performs the conversion.

impl<'a> TryFrom<&'a str> for Origin<'a>

type Error = Error<'a>

The type returned in the event of a conversion error.

fn try_from( value: &'a str ) -> Result<Origin<'a>, <Origin<'a> as TryFrom<&'a str>>::Error>

Performs the conversion.

impl TryFrom<String> for Origin<'static>

type Error = Error<'static>

The type returned in the event of a conversion error.

fn try_from( value: String ) -> Result<Origin<'static>, <Origin<'static> as TryFrom<String>>::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 Eq for Origin<'_>