Struct rocket_http::uri::Path

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

A URI path: /foo/bar, foo/bar, etc.

Implementations

impl<'a> Path<'a>

pub fn raw(&self) -> &'a RawStr

Returns the raw path value.

Example

let uri = uri!("/foo%20bar%2dbaz");
assert_eq!(uri.path(), "/foo%20bar%2dbaz");
assert_eq!(uri.path().raw(), "/foo%20bar%2dbaz");

pub fn as_str(&self) -> &'a str

Returns the raw, undecoded path value as an &str.

Example

let uri = uri!("/foo%20bar%2dbaz");
assert_eq!(uri.path(), "/foo%20bar%2dbaz");
assert_eq!(uri.path().as_str(), "/foo%20bar%2dbaz");

pub fn raw_segments(&self) -> impl Iterator<Item = &'a RawStr>

Returns an iterator over the raw, undecoded segments. Segments may be empty.

Example

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

let uri = Origin::parse("/").unwrap();
assert_eq!(uri.path().raw_segments().count(), 0);

let uri = Origin::parse("//").unwrap();
let segments: Vec<_> = uri.path().raw_segments().collect();
assert_eq!(segments, &["", ""]);

// Recall that `uri!()` normalizes static inputs.
let uri = uri!("//");
assert_eq!(uri.path().raw_segments().count(), 0);

let uri = Origin::parse("/a").unwrap();
let segments: Vec<_> = uri.path().raw_segments().collect();
assert_eq!(segments, &["a"]);

let uri = Origin::parse("/a//b///c/d?query&param").unwrap();
let segments: Vec<_> = uri.path().raw_segments().collect();
assert_eq!(segments, &["a", "", "b", "", "", "c", "d"]);

pub fn segments(&self) -> Segments<'a, Path>

Returns a (smart) iterator over the non-empty, percent-decoded segments.

Example

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

let uri = Origin::parse("/a%20b/b%2Fc/d//e?query=some").unwrap();
let path_segs: Vec<&str> = uri.path().segments().collect();
assert_eq!(path_segs, &["a b", "b/c", "d", "e"]);

Methods from Deref<Target = RawStr>

pub fn percent_decode(&self) -> Result<Cow<'_, str>, Utf8Error>

Returns a percent-decoded version of the string.

Errors

Returns an Err if the percent encoded values are not valid UTF-8.

Example

With a valid string:

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello%21");
let decoded = raw_str.percent_decode();
assert_eq!(decoded, Ok("Hello!".into()));

With an invalid string:

use rocket::http::RawStr;

// Note: Rocket should never hand you a bad `&RawStr`.
let bad_str = unsafe { std::str::from_utf8_unchecked(b"a=\xff") };
let bad_raw_str = RawStr::new(bad_str);
assert!(bad_raw_str.percent_decode().is_err());

pub fn percent_decode_lossy(&self) -> Cow<'_, str>

Returns a percent-decoded version of the string. Any invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.

Example

With a valid string:

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello%21");
let decoded = raw_str.percent_decode_lossy();
assert_eq!(decoded, "Hello!");

With an invalid string:

use rocket::http::RawStr;

// Note: Rocket should never hand you a bad `&RawStr`.
let bad_str = unsafe { std::str::from_utf8_unchecked(b"a=\xff") };
let bad_raw_str = RawStr::new(bad_str);
assert_eq!(bad_raw_str.percent_decode_lossy(), "a=�");

pub fn percent_encode(&self) -> Cow<'_, RawStr>

Returns a percent-encoded version of the string.

Example

With a valid string:

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello%21");
let decoded = raw_str.percent_decode();
assert_eq!(decoded, Ok("Hello!".into()));

With an invalid string:

use rocket::http::RawStr;

// NOTE: Rocket will never hand you a bad `&RawStr`.
let bad_str = unsafe { std::str::from_utf8_unchecked(b"a=\xff") };
let bad_raw_str = RawStr::new(bad_str);
assert!(bad_raw_str.percent_decode().is_err());

pub fn url_decode(&self) -> Result<Cow<'_, str>, Utf8Error>

Returns a URL-decoded version of the string. This is identical to percent decoding except that + characters are converted into spaces. This is the encoding used by form values.

Errors

Returns an Err if the percent encoded values are not valid UTF-8.

Example

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello%2C+world%21");
let decoded = raw_str.url_decode();
assert_eq!(decoded.unwrap(), "Hello, world!");

pub fn url_decode_lossy(&self) -> Cow<'_, str>

Returns a URL-decoded version of the string.

Any invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character. This is identical to lossy percent decoding except that + characters are converted into spaces. This is the encoding used by form values.

Example

With a valid string:

use rocket::http::RawStr;

let raw_str: &RawStr = "Hello%2C+world%21".into();
let decoded = raw_str.url_decode_lossy();
assert_eq!(decoded, "Hello, world!");

With an invalid string:

use rocket::http::RawStr;

// Note: Rocket should never hand you a bad `&RawStr`.
let bad_str = unsafe { std::str::from_utf8_unchecked(b"a+b=\xff") };
let bad_raw_str = RawStr::new(bad_str);
assert_eq!(bad_raw_str.url_decode_lossy(), "a b=�");

pub fn html_escape(&self) -> Cow<'_, str>

Returns an HTML escaped version of self. Allocates only when characters need to be escaped.

The following characters are escaped: &, <, >, ", ', /, `. This suffices as long as the escaped string is not used in an execution context such as inside of <script> or <style> tags! See the OWASP XSS Prevention Rules for more information.

Example

Strings with HTML sequences are escaped:

use rocket::http::RawStr;

let raw_str: &RawStr = "<b>Hi!</b>".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "&lt;b&gt;Hi!&lt;&#x2F;b&gt;");

let raw_str: &RawStr = "Hello, <i>world!</i>".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "Hello, &lt;i&gt;world!&lt;&#x2F;i&gt;");

Strings without HTML sequences remain untouched:

use rocket::http::RawStr;

let raw_str: &RawStr = "Hello!".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "Hello!");

let raw_str: &RawStr = "大阪".into();
let escaped = raw_str.html_escape();
assert_eq!(escaped, "大阪");

pub fn len(&self) -> usize

Returns the length of self.

This length is in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Example

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello, world!");
assert_eq!(raw_str.len(), 13);

pub fn is_empty(&self) -> bool

Returns true if self has a length of zero bytes.

Example

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello, world!");
assert!(!raw_str.is_empty());

let raw_str = RawStr::new("");
assert!(raw_str.is_empty());

pub fn as_str(&self) -> &str

Converts self into an &str.

This method should be used sparingly. Only use this method when you are absolutely certain that doing so is safe.

Example

use rocket::http::RawStr;

let raw_str = RawStr::new("Hello, world!");
assert_eq!(raw_str.as_str(), "Hello, world!");

pub fn as_bytes(&self) -> &[u8]

Converts self into an &[u8].

Example

use rocket::http::RawStr;

let raw_str = RawStr::new("hi");
assert_eq!(raw_str.as_bytes(), &[0x68, 0x69]);

pub fn as_ptr(&self) -> *const u8

Converts a string slice to a raw pointer.

As string slices are a slice of bytes, the raw pointer points to a u8. This pointer will be pointing to the first byte of the string slice.

The caller must ensure that the returned pointer is never written to. If you need to mutate the contents of the string slice, use as_mut_ptr.

Examples

Basic usage:

use rocket::http::RawStr;

let raw_str = RawStr::new("hi");
let ptr = raw_str.as_ptr();

pub fn as_uncased_str(&self) -> &UncasedStr

Converts self into an &UncasedStr.

This method should be used sparingly. Only use this method when you are absolutely certain that doing so is safe.

Example

use rocket::http::RawStr;

let raw_str = RawStr::new("Content-Type");
assert!(raw_str.as_uncased_str() == "content-TYPE");

pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool

Returns true if the given pattern matches a sub-slice of this string slice.

Returns false if it does not.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Examples

Basic usage:

use rocket::http::RawStr;

let bananas = RawStr::new("bananas");

assert!(bananas.contains("nana"));
assert!(!bananas.contains("apples"));

pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool

Returns true if the given pattern matches a prefix of this string slice.

Returns false if it does not.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Examples

Basic usage:

use rocket::http::RawStr;

let bananas = RawStr::new("bananas");

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));

pub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

Returns true if the given pattern matches a suffix of this string slice.

Returns false if it does not.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Examples

Basic usage:

use rocket::http::RawStr;

let bananas = RawStr::new("bananas");

assert!(bananas.ends_with("anas"));
assert!(!bananas.ends_with("nana"));

pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>

Returns the byte index of the first character of this string slice that matches the pattern.

Returns None if the pattern doesn’t match.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Example

use rocket::http::RawStr;

let s = RawStr::new("Löwe 老虎 Léopard Gepardi");

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("pard"), Some(17));

pub fn split<'a, P>(&'a self, pat: P) -> impl Iterator<Item = &'a RawStr>where P: Pattern<'a>,

An iterator over substrings of this string slice, separated by characters matched by a pattern.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Examples

Simple patterns:

use rocket::http::RawStr;

let v: Vec<_> = RawStr::new("Mary had a little lamb")
    .split(' ')
    .map(|r| r.as_str())
    .collect();

assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

pub fn split_at_byte(&self, b: u8) -> (&RawStr, &RawStr)

Splits self into two pieces: the piece before the first byte b and the piece after (not including b). Returns the tuple (before, after). If b is not in self, or b is not an ASCII characters, returns the entire string self as before and the empty string as after.

Example

use rocket::http::RawStr;

let haystack = RawStr::new("a good boy!");

let (before, after) = haystack.split_at_byte(b'a');
assert_eq!(before, "");
assert_eq!(after, " good boy!");

let (before, after) = haystack.split_at_byte(b' ');
assert_eq!(before, "a");
assert_eq!(after, "good boy!");

let (before, after) = haystack.split_at_byte(b'o');
assert_eq!(before, "a g");
assert_eq!(after, "od boy!");

let (before, after) = haystack.split_at_byte(b'!');
assert_eq!(before, "a good boy");
assert_eq!(after, "");

let (before, after) = haystack.split_at_byte(b'?');
assert_eq!(before, "a good boy!");
assert_eq!(after, "");

let haystack = RawStr::new("");
let (before, after) = haystack.split_at_byte(b' ');
assert_eq!(before, "");
assert_eq!(after, "");

pub fn strip_prefix<'a, P: Pattern<'a>>( &'a self, prefix: P ) -> Option<&'a RawStr>

Returns a string slice with the prefix removed.

If the string starts with the pattern prefix, returns substring after the prefix, wrapped in Some. This method removes the prefix exactly once.

If the string does not start with prefix, returns None.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Examples

use rocket::http::RawStr;

assert_eq!(RawStr::new("foo:bar").strip_prefix("foo:").unwrap(), "bar");
assert_eq!(RawStr::new("foofoo").strip_prefix("foo").unwrap(), "foo");
assert!(RawStr::new("foo:bar").strip_prefix("bar").is_none());

pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a RawStr>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

Returns a string slice with the suffix removed.

If the string ends with the pattern suffix, returns the substring before the suffix, wrapped in Some. Unlike trim_end_matches, this method removes the suffix exactly once.

If the string does not end with suffix, returns None.

The pattern can be a &str, char, a slice of chars, or a function or closure that determines if a character matches.

Examples

use rocket::http::RawStr;

assert_eq!(RawStr::new("bar:foo").strip_suffix(":foo").unwrap(), "bar");
assert_eq!(RawStr::new("foofoo").strip_suffix("foo").unwrap(), "foo");
assert!(RawStr::new("bar:foo").strip_suffix("bar").is_none());

pub fn parse<F: FromStr>(&self) -> Result<F, F::Err>

Parses this string slice into another type.

Because parse is so general, it can cause problems with type inference. As such, parse is one of the few times you’ll see the syntax affectionately known as the ‘turbofish’: ::<>. This helps the inference algorithm understand specifically which type you’re trying to parse into.

Errors

Will return Err if it’s not possible to parse this string slice into the desired type.

Examples

Basic usage

use rocket::http::RawStr;

let four: u32 = RawStr::new("4").parse().unwrap();

assert_eq!(4, four);

Trait Implementations

impl AsRef<RawStr> for Path<'_>

fn as_ref(&self) -> &RawStr

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Path<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Path<'a>

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

Formats the value using the given formatter.

impl Deref for Path<'_>

type Target = RawStr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for Path<'_>

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

Formats the value using the given formatter.

impl Hash for Path<'_>

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

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 PartialEq<&RawStr> for Path<'_>

fn eq(&self, other: &&RawStr) -> 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 Path<'_>

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<Path<'_>> for &RawStr

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

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

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

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

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

fn eq(&self, other: &RawStr) -> 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 Path<'_>

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<'a> Copy for Path<'a>

impl Eq for Path<'_>