Struct RawStr

pub struct RawStr(/* private fields */);

Expand description

A reference to a string inside of a raw HTTP message.

A RawStr is an unsanitized, unvalidated, and undecoded raw string from an HTTP message. It exists to separate validated string inputs, represented by the String, &str, and Cow<str> types, from unvalidated inputs, represented by &RawStr.

§Validation

An &RawStr should be converted into one of the validated string input types through methods on RawStr. These methods are summarized below:

url_decode() - used to decode a raw string in a form value context
percent_decode(), percent_decode_lossy() - used to percent-decode a raw string, typically in a URL context
html_escape() - used to decode a string for use in HTML templates
as_str() - used when the RawStr is known to be safe in the context of its intended use. Use sparingly and with care!
as_uncased_str() - used when the RawStr is known to be safe in the context of its intended, uncased use

Note: Template engines like Tera and Handlebars all functions like html_escape() on all rendered template outputs by default.

§Usage

A RawStr is a dynamically sized type (just like str). It is always used through a reference an as &RawStr (just like &str).

Implementations§

§

impl RawStr

pub fn new<S>(string: &S) -> &RawStr
where S: AsRef<str> + ?Sized,

Constructs an &RawStr from a string-like type at no cost.

§Example

use rocket::http::RawStr;

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

// `into` can also be used; note that the type must be specified
let raw_str: &RawStr = "Hello, world!".into();

pub fn from_cow_str(cow: Cow<'_, str>) -> Cow<'_, RawStr>

Construct a Cow<RawStr> from a Cow<Str>. Does not allocate.

See RawStr::into_cow_str() for the inverse operation.

§Example

use std::borrow::Cow;
use rocket::http::RawStr;

let cow_str = Cow::from("hello!");
let cow_raw = RawStr::from_cow_str(cow_str);
assert_eq!(cow_raw.as_str(), "hello!");

pub fn into_cow_str(cow: Cow<'_, RawStr>) -> Cow<'_, str>

Construct a Cow<str> from a Cow<RawStr>. Does not allocate.

See RawStr::from_cow_str() for the inverse operation.

§Example

use std::borrow::Cow;
use rocket::http::RawStr;

let cow_raw = Cow::from(RawStr::new("hello!"));
let cow_str = RawStr::into_cow_str(cow_raw);
assert_eq!(&*cow_str, "hello!");

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;

let bad_raw_str = RawStr::new("%FF");
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;

let bad_raw_str = RawStr::new("a=%FF");
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/goodbye");
let encoded = raw_str.percent_encode();
assert_eq!(encoded.as_str(), "Hello%2Fgoodbye");

pub fn percent_encode_bytes(bytes: &[u8]) -> Cow<'_, RawStr>

Returns a percent-encoded version of bytes.

§Example

use rocket::http::RawStr;

// Note: Rocket should never hand you a bad `&RawStr`.
let bytes = &[93, 12, 0, 13, 1];
let encoded = RawStr::percent_encode_bytes(&bytes[..]);
assert_eq!(encoded.as_str(), "]%0C%00%0D%01");

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;

let bad_raw_str = RawStr::new("a+b=%FF");
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 const 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 const 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 const 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 const 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 const 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>(&'a self, pat: P) -> bool
where P: Pattern<'a>,

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>(&'a self, pat: P) -> bool
where P: Pattern<'a>,

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) -> bool
where 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>(&'a self, pat: P) -> Option<usize>
where P: Pattern<'a>,

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 DoubleEndedIterator
where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'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>(&'a self, prefix: P) -> Option<&'a RawStr>
where P: Pattern<'a>,

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 trim(&self) -> &RawStr

Returns a string slice with leading and trailing whitespace removed.

‘Whitespace’ is defined according to the terms of the Unicode Derived Core Property White_Space, which includes newlines.

§Examples

Basic usage:

use rocket::http::RawStr;

let s = RawStr::new("\n Hello\tworld\t\n");

assert_eq!("Hello\tworld", s.trim());

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

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<[u8]> for RawStr

§

fn as_ref(&self) -> &[u8] ⓘ

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

Struct RawStrCopy item path

§Validation

§Usage

Implementations§

impl RawStr

pub fn new<S>(string: &S) -> &RawStrwhere S: AsRef<str> + ?Sized,

§Example

pub fn from_cow_str(cow: Cow<'_, str>) -> Cow<'_, RawStr>

§Example

pub fn into_cow_str(cow: Cow<'_, RawStr>) -> Cow<'_, str>

§Example

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

§Errors

§Example

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

§Example

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

§Example

pub fn percent_encode_bytes(bytes: &[u8]) -> Cow<'_, RawStr>

§Example

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

§Errors

§Example

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

§Example

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

§Example

pub const fn len(&self) -> usize

§Example

pub const fn is_empty(&self) -> bool

§Example

pub const fn as_str(&self) -> &str

§Example

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

§Example

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

§Examples

pub fn as_uncased_str(&self) -> &UncasedStr

§Example

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

§Examples

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

§Examples

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

§Examples

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

§Example

pub fn split<'a, P>(&'a self, pat: P) -> impl DoubleEndedIteratorwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,

§Examples

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

§Example

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

§Examples

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

§Examples

pub fn trim(&self) -> &RawStr

§Examples

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

§Errors

§Examples

Trait Implementations§

impl AsRef<[u8]> for RawStr

fn as_ref(&self) -> &[u8] ⓘ

impl AsRef<Key> for RawStr

fn as_ref(&self) -> &Key

impl AsRef<Name> for RawStr

fn as_ref(&self) -> &Name

impl AsRef<OsStr> for RawStr

fn as_ref(&self) -> &OsStr

impl AsRef<RawStr> for Path<'_>

fn as_ref(&self) -> &RawStr

impl AsRef<RawStr> for Query<'_>

fn as_ref(&self) -> &RawStr

impl AsRef<RawStr> for RawStr

fn as_ref(&self) -> &RawStr

impl AsRef<RawStr> for RawStrBuf

fn as_ref(&self) -> &RawStr

impl AsRef<RawStr> for str

fn as_ref(&self) -> &RawStr

impl AsRef<str> for RawStr

Struct RawStr

pub fn new<S>(string: &S) -> &RawStr
where S: AsRef<str> + ?Sized,

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

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

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

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

pub fn split<'a, P>(&'a self, pat: P) -> impl DoubleEndedIterator
where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,

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

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

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

impl<'de, 'a> Deserialize<'de> for &'a RawStr
where 'de: 'a,

fn deserialize<D>(de: D) -> Result<&'a RawStr, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

fn from_data<'life0, 'async_trait>( r: &'r Request<'life0>, d: Data<'r>, ) -> Pin<Box<dyn Future<Output = Outcome<'r, Self>> + Send + 'async_trait>>
where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait,

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

impl<I> Index<I> for RawStr
where I: SliceIndex<str, Output = str>,