Struct uriparse::uri::URI

pub struct URI<'uri> { /* fields omitted */ }

A Uniform Resource Identifier (URI) as defined in RFC3986.

A URI is a URI reference, one with a scheme.

Methods

impl<'uri> URI<'uri>

pub fn authority(&self) -> Option<&Authority<'uri>>

Returns the authority, if present, of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com:80/my/path").unwrap();
assert_eq!(uri.authority().unwrap().to_string(), "example.com:80");

pub fn builder<'new_uri>() -> URIBuilder<'new_uri>

Constructs a default builder for a URI.

This provides an alternative means of constructing a URI besides parsing and URI::from_parts.

Examples

use uriparse::URI;

let mut builder = URI::builder();
builder.scheme("http").authority(Some("example.com")).path("/my/path");
let uri = builder.build().unwrap();
assert_eq!(uri.to_string(), "http://example.com/my/path");

pub fn can_be_a_base(&self) -> bool

Returns whether or not the URI can act as a base URI.

A URI can be a base if it is absolute (i.e. it has no fragment component).

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com/my/path").unwrap();
assert!(uri.can_be_a_base());

let uri = URI::try_from("ftp://127.0.0.1#fragment").unwrap();
assert!(!uri.can_be_a_base());

pub fn from_parts<'new_uri, SchemeType, AuthorityType, PathType, QueryType, FragmentType, SchemeError, AuthorityError, PathError, QueryError, FragmentError>(     scheme: SchemeType,     authority: Option<AuthorityType>,     path: PathType,     query: Option<QueryType>,     fragment: Option<FragmentType> ) -> Result<URI<'new_uri>, InvalidURI> where     Scheme<'new_uri>: TryFrom<SchemeType, Error = SchemeError>,     Authority<'new_uri>: TryFrom<AuthorityType, Error = AuthorityError>,     Path<'new_uri>: TryFrom<PathType, Error = PathError>,     Query<'new_uri>: TryFrom<QueryType, Error = QueryError>,     Fragment<'new_uri>: TryFrom<FragmentType, Error = FragmentError>,     InvalidURIReference: From<SchemeError> + From<AuthorityError> + From<PathError> + From<QueryError> + From<FragmentError>,

Constructs a new URI from the individual parts: scheme, authority, path, query, and fragment.

The lifetime used by the resulting value will be the lifetime of the part that is most restricted in scope.

Examples

use std::convert::TryFrom;

use uriparse::{Fragment, URI};

let uri = URI::from_parts(
    "http",
    Some("example.com"),
    "",
    Some("query"),
    None::<Fragment>
).unwrap();
assert_eq!(uri.to_string(), "http://example.com/?query");

pub fn fragment(&self) -> Option<&Fragment<'uri>>

Returns the fragment, if present, of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com#fragment").unwrap();
assert_eq!(uri.fragment().unwrap(), "fragment");

pub fn has_authority(&self) -> bool

Returns whether or not the URI has an authority component.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com").unwrap();
assert!(uri.has_authority());

let uri = URI::try_from("urn:test").unwrap();
assert!(!uri.has_authority());

pub fn has_fragment(&self) -> bool

Returns whether or not the URI has a fragment component.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com#test").unwrap();
assert!(uri.has_fragment());

let uri = URI::try_from("http://example.com").unwrap();
assert!(!uri.has_fragment());

pub fn has_password(&self) -> bool

Returns whether or not the URI has a password component.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://user:pass@127.0.0.1").unwrap();
assert!(uri.has_password());

let uri = URI::try_from("http://user@127.0.0.1").unwrap();
assert!(!uri.has_password());

pub fn has_query(&self) -> bool

Returns whether or not the URI has a query component.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com/my/path?my=query").unwrap();
assert!(uri.has_query());

let uri = URI::try_from("http://example.com/my/path").unwrap();
assert!(!uri.has_query());

pub fn has_username(&self) -> bool

Returns whether or not the URI has a username component.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://username@example.com").unwrap();
assert!(uri.has_username());

let uri = URI::try_from("http://example.com").unwrap();
assert!(!uri.has_username());

pub fn host(&self) -> Option<&Host<'uri>>

Returns the host, if present, of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://username@example.com").unwrap();
assert_eq!(uri.host().unwrap().to_string(), "example.com");

pub fn into_base_uri(self) -> URI<'uri>

Converts the URI into a base URI (i.e. the fragment component is removed).

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com#fragment").unwrap();
assert_eq!(uri.to_string(), "http://example.com/#fragment");
let uri = uri.into_base_uri();
assert_eq!(uri.to_string(), "http://example.com/");

pub fn into_builder(self) -> URIBuilder<'uri>

Consumes the URI and converts it into a builder with the same values.

Examples

use std::convert::TryFrom;

use uriparse::{Fragment, Query, URI};

let uri = URI::try_from("http://example.com/path?query#fragment").unwrap();
let mut builder = uri.into_builder();
builder.query(None::<Query>).fragment(None::<Fragment>);
let uri = builder.build().unwrap();
assert_eq!(uri.to_string(), "http://example.com/path");

pub fn into_owned(self) -> URI<'static>

Converts the URI into an owned copy.

If you construct the URI from a source with a non-static lifetime, you may run into lifetime problems due to the way the struct is designed. Calling this function will ensure that the returned value has a static lifetime.

This is different from just cloning. Cloning the URI will just copy the references, and thus the lifetime will remain the same.

pub fn into_parts(     self ) -> (Scheme<'uri>, Option<Authority<'uri>>, Path<'uri>, Option<Query<'uri>>, Option<Fragment<'uri>>)

Consumes the URI and returns its parts: scheme, authority, path, query, and fragment.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from(
    "http://username:password@example.com:80/my/path?my=query#fragment",
).unwrap();
let (scheme, authority, path, query, fragment) = uri.into_parts();

assert_eq!(scheme, "http");
assert_eq!(authority.unwrap().to_string(), "username:password@example.com:80");
assert_eq!(path, "/my/path");
assert_eq!(query.unwrap(), "my=query");
assert_eq!(fragment.unwrap(), "fragment");

pub fn map_authority<Mapper>(     &mut self,     mapper: Mapper ) -> Option<&Authority<'uri>> where     Mapper: FnOnce(Option<Authority<'uri>>) -> Option<Authority<'uri>>,

Maps the authority using the given map function.

This function will panic if, as a result of the authority change, the URI reference becomes invalid.

Examples

use std::convert::TryFrom;

use uriparse::{Authority, URI};

let mut uri = URI::try_from("http://example.com").unwrap();
uri.map_authority(|_| Some(Authority::try_from("127.0.0.1").unwrap()));
assert_eq!(uri.to_string(), "http://127.0.0.1/");

pub fn map_fragment<Mapper>(     &mut self,     mapper: Mapper ) -> Option<&Fragment<'uri>> where     Mapper: FnOnce(Option<Fragment<'uri>>) -> Option<Fragment<'uri>>,

Maps the fragment using the given map function.

Examples

use std::convert::TryFrom;

use uriparse::{Fragment, URI};

let mut uri = URI::try_from("http://example.com").unwrap();
uri.map_fragment(|_| Some(Fragment::try_from("fragment").unwrap()));
assert_eq!(uri.to_string(), "http://example.com/#fragment");

pub fn map_path<Mapper>(&mut self, mapper: Mapper) -> &Path<'uri> where     Mapper: FnOnce(Path<'uri>) -> Path<'uri>,

Maps the path using the given map function.

This function will panic if, as a result of the path change, the URI becomes invalid.

Examples

use std::convert::TryFrom;

use uriparse::{Authority, URI};

let mut uri = URI::try_from("http://example.com").unwrap();
uri.map_path(|mut path| {
    path.push("test").unwrap();
    path.push("path").unwrap();
    path
});
assert_eq!(uri.to_string(), "http://example.com/test/path");

pub fn map_query<Mapper>(&mut self, mapper: Mapper) -> Option<&Query<'uri>> where     Mapper: FnOnce(Option<Query<'uri>>) -> Option<Query<'uri>>,

Maps the query using the given map function.

Examples

use std::convert::TryFrom;

use uriparse::{Query, URI};

let mut uri = URI::try_from("http://example.com").unwrap();
uri.map_query(|_| Some(Query::try_from("query").unwrap()));
assert_eq!(uri.to_string(), "http://example.com/?query");

pub fn map_scheme<Mapper>(&mut self, mapper: Mapper) -> Option<&Scheme<'uri>> where     Mapper: FnOnce(Scheme<'uri>) -> Scheme<'uri>,

Maps the scheme using the given map function.

Examples

use std::convert::TryFrom;

use uriparse::{Scheme, URI};

let mut uri = URI::try_from("http://example.com").unwrap();
uri.map_scheme(|_| Scheme::try_from("https").unwrap());
assert_eq!(uri.to_string(), "https://example.com/");

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

Returns the path of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://127.0.0.1/my/path").unwrap();
assert_eq!(uri.path(), "/my/path");

pub fn password(&self) -> Option<&Password<'uri>>

Returns the password, if present, of the URI.

Usage of a password in URIs is deprecated.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://user:pass@example.com").unwrap();
assert_eq!(uri.password().unwrap(), "pass");

pub fn port(&self) -> Option<u16>

Returns the port, if present, of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://example.com:8080/").unwrap();
assert_eq!(uri.port().unwrap(), 8080);

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

Returns the query, if present, of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://127.0.0.1?my=query").unwrap();
assert_eq!(uri.query().unwrap(), "my=query");

pub fn scheme(&self) -> &Scheme<'uri>

Returns the scheme of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://127.0.0.1/").unwrap();
assert_eq!(uri.scheme(), "http");

pub fn set_authority<AuthorityType, AuthorityError>(     &mut self,     authority: Option<AuthorityType> ) -> Result<Option<&Authority<'uri>>, InvalidURI> where     Authority<'uri>: TryFrom<AuthorityType, Error = AuthorityError>,     InvalidURIReference: From<AuthorityError>,

Sets the authority of the URI.

An error will be returned if the conversion to an Authority fails.

The existing path will be set to absolute (i.e. starts with a '/').

Examples

use std::convert::TryFrom;

use uriparse::URI;

let mut uri = URI::try_from("http://example.com").unwrap();
uri.set_authority(Some("user@example.com:80"));
assert_eq!(uri.to_string(), "http://user@example.com:80/");

pub fn set_fragment<FragmentType, FragmentError>(     &mut self,     fragment: Option<FragmentType> ) -> Result<Option<&Fragment<'uri>>, InvalidURI> where     Fragment<'uri>: TryFrom<FragmentType, Error = FragmentError>,     InvalidURIReference: From<FragmentError>,

Sets the fragment of the URI.

An error will be returned if the conversion to a Fragment fails.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let mut uri = URI::try_from("http://example.com").unwrap();
uri.set_fragment(Some("fragment"));
assert_eq!(uri.to_string(), "http://example.com/#fragment");

pub fn set_path<PathType, PathError>(     &mut self,     path: PathType ) -> Result<&Path<'uri>, InvalidURI> where     Path<'uri>: TryFrom<PathType, Error = PathError>,     InvalidURIReference: From<PathError>,

Sets the path of the URI.

An error will be returned in one of two cases:

• The conversion to Path failed.
• The path was set to a value that resulted in an invalid URI.

Regardless of whether or not the given path was set as absolute or relative, if the URI reference currently has an authority, the path will be forced to be absolute.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let mut uri = URI::try_from("http://example.com").unwrap();
uri.set_path("my/path");
assert_eq!(uri.to_string(), "http://example.com/my/path");

pub fn set_query<QueryType, QueryError>(     &mut self,     query: Option<QueryType> ) -> Result<Option<&Query<'uri>>, InvalidURI> where     Query<'uri>: TryFrom<QueryType, Error = QueryError>,     InvalidURIReference: From<QueryError>,

Sets the query of the URI.

An error will be returned if the conversion to a Query fails.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let mut uri = URI::try_from("http://example.com").unwrap();
uri.set_query(Some("myquery"));
assert_eq!(uri.to_string(), "http://example.com/?myquery");

pub fn set_scheme<SchemeType, SchemeError>(     &mut self,     scheme: SchemeType ) -> Result<&Scheme<'uri>, InvalidURI> where     Scheme<'uri>: TryFrom<SchemeType, Error = SchemeError>,     InvalidURIReference: From<SchemeError>,

Sets the scheme of the URI.

An error will be returned if the conversion to a Scheme fails.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let mut uri = URI::try_from("http://example.com").unwrap();
uri.set_scheme("https");
assert_eq!(uri.to_string(), "https://example.com/");

pub fn username(&self) -> Option<&Username<'uri>>

Returns the username, if present, of the URI.

Examples

use std::convert::TryFrom;

use uriparse::URI;

let uri = URI::try_from("http://username@example.com").unwrap();
assert_eq!(uri.username().unwrap(), "username");

Trait Implementations

impl<'uri> Clone for URI<'uri>

fn clone(&self) -> URI<'uri>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'uri> Debug for URI<'uri>

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

Formats the value using the given formatter.

impl<'uri> Eq for URI<'uri>

impl<'uri> Hash for URI<'uri>

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,

Feeds a slice of this type into the given [Hasher].

impl<'uri> PartialEq for URI<'uri>

fn eq(&self, other: &URI<'uri>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &URI<'uri>) -> bool

This method tests for !=.

impl<'uri> Display for URI<'uri>

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'uri> From<URI<'uri>> for String

fn from(value: URI<'uri>) -> Self

Performs the conversion.

impl<'uri> TryFrom<&'uri [u8]> for URI<'uri>

type Error = InvalidURI

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &'uri [u8]) -> Result<Self, Self::Error>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'uri> TryFrom<&'uri str> for URI<'uri>

type Error = InvalidURI

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &'uri str) -> Result<Self, Self::Error>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'uri> TryFrom<URIReference<'uri>> for URI<'uri>

type Error = InvalidURI

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: URIReference<'uri>) -> Result<Self, Self::Error>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'uri> From<URI<'uri>> for URIReference<'uri>

fn from(value: URI<'uri>) -> Self

Performs the conversion.