Struct PathAndQuery

pub struct PathAndQuery { /* private fields */ }

Represents the path component of a URI

Implementations

impl PathAndQuery

pub fn from_static(src: &'static str) -> PathAndQuery

Convert a PathAndQuery from a static string.

This function will not perform any copying, however the string is checked to ensure that it is valid.

Panics

This function panics if the argument is an invalid path and query.

Examples

let v = PathAndQuery::from_static("/hello?world");

assert_eq!(v.path(), "/hello");
assert_eq!(v.query(), Some("world"));

pub fn from_maybe_shared<T>(src: T) -> Result<PathAndQuery, InvalidUri>

where T: AsRef<[u8]> + 'static,

Attempt to convert a Bytes buffer to a PathAndQuery.

This will try to prevent a copy if the type passed is the type used internally, and will copy the data if it is not.

pub fn path(&self) -> &str

Returns the path component

The path component is case sensitive.

abc://username:password@example.com:123/path/data?key=value&key2=value2#fragid1
                                       |--------|
                                            |
                                          path

If the URI is * then the path component is equal to *.

Examples

let path_and_query: PathAndQuery = "/hello/world".parse().unwrap();

assert_eq!(path_and_query.path(), "/hello/world");

pub fn query(&self) -> Option<&str>

Returns the query string component

The query component contains non-hierarchical data that, along with data in the path component, serves to identify a resource within the scope of the URI’s scheme and naming authority (if any). The query component is indicated by the first question mark (“?”) character and terminated by a number sign (“#”) character or by the end of the URI.

abc://username:password@example.com:123/path/data?key=value&key2=value2#fragid1
                                                  |-------------------|
                                                            |
                                                          query

Examples

With a query string component

let path_and_query: PathAndQuery = "/hello/world?key=value&foo=bar".parse().unwrap();

assert_eq!(path_and_query.query(), Some("key=value&foo=bar"));

Without a query string component

let path_and_query: PathAndQuery = "/hello/world".parse().unwrap();

assert!(path_and_query.query().is_none());

pub fn as_str(&self) -> &str

Returns the path and query as a string component.

Examples

With a query string component

let path_and_query: PathAndQuery = "/hello/world?key=value&foo=bar".parse().unwrap();

assert_eq!(path_and_query.as_str(), "/hello/world?key=value&foo=bar");

Without a query string component

let path_and_query: PathAndQuery = "/hello/world".parse().unwrap();

assert_eq!(path_and_query.as_str(), "/hello/world");

Trait Implementations

impl Clone for PathAndQuery

fn clone(&self) -> PathAndQuery

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PathAndQuery

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

Formats the value using the given formatter.

impl Display for PathAndQuery

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

Formats the value using the given formatter.

impl From<PathAndQuery> for Uri

Convert a PathAndQuery into a Uri.

fn from(path_and_query: PathAndQuery) -> Uri

Converts to this type from the input type.

impl FromStr for PathAndQuery

type Err = InvalidUri

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<PathAndQuery, InvalidUri>

Parses a string s to return a value of this type.

impl Hash for PathAndQuery

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<'a> PartialEq<&'a str> for PathAndQuery

fn eq(&self, other: &&'a str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<PathAndQuery> for &'a str

fn eq(&self, other: &PathAndQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<PathAndQuery> for String

fn eq(&self, other: &PathAndQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<PathAndQuery> for str

fn eq(&self, other: &PathAndQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<String> for PathAndQuery

fn eq(&self, other: &String) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for PathAndQuery

fn eq(&self, other: &str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for PathAndQuery

fn eq(&self, other: &PathAndQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd<&'a str> for PathAndQuery

fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> PartialOrd<PathAndQuery> for &'a str

fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<PathAndQuery> for String

fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<PathAndQuery> for str

fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<String> for PathAndQuery

fn partial_cmp(&self, other: &String) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<str> for PathAndQuery

fn partial_cmp(&self, other: &str) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for PathAndQuery

fn partial_cmp(&self, other: &PathAndQuery) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> TryFrom<&'a [u8]> for PathAndQuery

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from( s: &'a [u8], ) -> Result<PathAndQuery, <PathAndQuery as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl TryFrom<&String> for PathAndQuery

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from( s: &String, ) -> Result<PathAndQuery, <PathAndQuery as TryFrom<&String>>::Error>

Performs the conversion.

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

type Error = InvalidUri

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<String> for PathAndQuery

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from( s: String, ) -> Result<PathAndQuery, <PathAndQuery as TryFrom<String>>::Error>

Performs the conversion.

impl<'a> TryFrom<Vec<u8>> for PathAndQuery

type Error = InvalidUri

The type returned in the event of a conversion error.

fn try_from( vec: Vec<u8>, ) -> Result<PathAndQuery, <PathAndQuery as TryFrom<Vec<u8>>>::Error>

Performs the conversion.

impl Eq for PathAndQuery