Struct url::Url
[-]
[+]
[src]
pub struct Url {
pub scheme: String,
pub scheme_data: SchemeData,
pub query: Option<String>,
pub fragment: Option<String>,
}The parsed representation of an absolute URL.
Fields
Methods
impl Url
fn parse(input: &str) -> ParseResult<Url>
Parse an URL with the default UrlParser parameters.
In particular, relative URL references are parse errors since no base URL is provided.
fn from_file_path<T: ToUrlPath>(path: &T) -> Result<Url, ()>
Convert a file name as std::path::Path into an URL in the file scheme.
This returns Err if the given path is not absolute
or, with a Windows path, if the prefix is not a disk prefix (e.g. C:).
fn from_directory_path<T: ToUrlPath>(path: &T) -> Result<Url, ()>
Convert a directory name as std::path::Path into an URL in the file scheme.
This returns Err if the given path is not absolute
or, with a Windows path, if the prefix is not a disk prefix (e.g. C:).
Compared to from_file_path, this adds an empty component to the path
(or, in terms of URL syntax, adds a trailing slash)
so that the entire path is considered when using this URL as a base URL.
For example:
"index.html"parsed withUrl::from_directory_path(Path::new("/var/www"))as the base URL isfile:///var/www/index.html"index.html"parsed withUrl::from_file_path(Path::new("/var/www/"))as the base URL isfile:///var/index.html, which might not be what was intended.
(Note that Path::new removes any trailing slash.)
fn to_file_path<T: FromUrlPath>(&self) -> Result<T, ()>
Assuming the URL is in the file scheme or similar,
convert its path to an absolute std::path::Path.
Note: This does not actually check the URL’s scheme,
and may give nonsensical results for other schemes.
It is the user’s responsibility to check the URL’s scheme before calling this.
The return type (when Ok()) is generic and can be either std::path::posix::Path
or std::path::windows::Path.
(Use std::path::Path to pick one of them depending on the local system.)
If the compiler can not infer the desired type from context, you may have to specifiy it:
let path = url.to_file_path::<std::path::posix::Path>();
Returns Err if the host is neither empty nor "localhost",
or if Path::new_opt() returns None.
(That is, if the percent-decoded path contains a NUL byte or,
for a Windows path, is not UTF-8.)
fn serialize(&self) -> String
Return the serialization of this URL as a string.
fn serialize_no_fragment(&self) -> String
Return the serialization of this URL, without the fragment identifier, as a string
fn non_relative_scheme_data<'a>(&'a self) -> Option<&'a str>
If the URL is non-relative, return the string scheme data.
fn non_relative_scheme_data_mut<'a>(&'a mut self) -> Option<&'a mut String>
If the URL is non-relative, return a mutable reference to the string scheme data.
fn relative_scheme_data<'a>(&'a self) -> Option<&'a RelativeSchemeData>
If the URL is in a relative scheme, return the structured scheme data.
fn relative_scheme_data_mut<'a>(&'a mut self) -> Option<&'a mut RelativeSchemeData>
If the URL is in a relative scheme, return a mutable reference to the structured scheme data.
fn username<'a>(&'a self) -> Option<&'a str>
If the URL is in a relative scheme, return its username.
fn username_mut<'a>(&'a mut self) -> Option<&'a mut String>
If the URL is in a relative scheme, return a mutable reference to its username.
fn lossy_percent_decode_username(&self) -> Option<String>
Percent-decode the URL’s username, if any.
This is “lossy”: invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.
fn password<'a>(&'a self) -> Option<&'a str>
If the URL is in a relative scheme, return its password, if any.
fn password_mut<'a>(&'a mut self) -> Option<&'a mut String>
If the URL is in a relative scheme, return a mutable reference to its password, if any.
fn lossy_percent_decode_password(&self) -> Option<String>
Percent-decode the URL’s password, if any.
This is “lossy”: invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.
fn serialize_userinfo<'a>(&'a mut self) -> Option<String>
Serialize the URL's username and password, if any.
Format: "
fn host<'a>(&'a self) -> Option<&'a Host>
If the URL is in a relative scheme, return its structured host.
fn host_mut<'a>(&'a mut self) -> Option<&'a mut Host>
If the URL is in a relative scheme, return a mutable reference to its structured host.
fn domain<'a>(&'a self) -> Option<&'a str>
If the URL is in a relative scheme and its host is a domain, return the domain as a string.
fn domain_mut<'a>(&'a mut self) -> Option<&'a mut String>
If the URL is in a relative scheme and its host is a domain, return a mutable reference to the domain string.
fn serialize_host(&self) -> Option<String>
If the URL is in a relative scheme, serialize its host as a string.
A domain a returned as-is, an IPv6 address between [] square brackets.
fn port<'a>(&'a self) -> Option<u16>
If the URL is in a relative scheme and has a port number, return it.
fn port_mut<'a>(&'a mut self) -> Option<&'a mut Option<u16>>
If the URL is in a relative scheme, return a mutable reference to its port.
fn port_or_default(&self) -> Option<u16>
If the URL is in a relative scheme that is not a file-like, return its port number, even if it is the default.
fn path<'a>(&'a self) -> Option<&'a [String]>
If the URL is in a relative scheme, return its path components.
fn path_mut<'a>(&'a mut self) -> Option<&'a mut Vec<String>>
If the URL is in a relative scheme, return a mutable reference to its path components.
fn serialize_path(&self) -> Option<String>
If the URL is in a relative scheme, serialize its path as a string.
The returned string starts with a "/" slash, and components are separated by slashes. A trailing slash represents an empty last component.
fn query_pairs(&self) -> Option<Vec<(String, String)>>
Parse the URL’s query string, if any, as application/x-www-form-urlencoded
and return a vector of (key, value) pairs.
fn set_query_from_pairs<'a, I: Iterator<Item=(&'a str, &'a str)>>(&mut self, pairs: I)
Serialize an iterator of (key, value) pairs as application/x-www-form-urlencoded
and set it as the URL’s query string.
fn lossy_percent_decode_query(&self) -> Option<String>
Percent-decode the URL’s query string, if any.
This is “lossy”: invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.
fn lossy_percent_decode_fragment(&self) -> Option<String>
Percent-decode the URL’s fragment identifier, if any.
This is “lossy”: invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD, the replacement character.