Struct url::Url
[−]
[src]
pub struct Url { /* fields omitted */ }
A parsed URL record.
Methods
impl Url
[src]
fn parse(input: &str) -> Result<Url, ParseError>
[src]
Parse an absolute URL from a string.
Examples
use url::Url; let url = Url::parse("https://example.net")?;
Errors
If the function can not parse an absolute URL from the given string,
a ParseError
variant will be returned.
fn parse_with_params<I, K, V>(input: &str, iter: I) -> Result<Url, ParseError> where
I: IntoIterator,
I::Item: Borrow<(K, V)>,
K: AsRef<str>,
V: AsRef<str>,
[src]
I: IntoIterator,
I::Item: Borrow<(K, V)>,
K: AsRef<str>,
V: AsRef<str>,
Parse an absolute URL from a string and add params to its query string.
Existing params are not removed.
Examples
use url::Url; let url = Url::parse_with_params("https://example.net?dont=clobberme", &[("lang", "rust"), ("browser", "servo")])?;
Errors
If the function can not parse an absolute URL from the given string,
a ParseError
variant will be returned.
fn join(&self, input: &str) -> Result<Url, ParseError>
[src]
Parse a string as an URL, with this URL as the base URL.
Note: a trailing slash is significant. Without it, the last path component is considered to be a “file” name to be removed to get at the “directory” that is used as the base:
Examples
use url::Url; let base = Url::parse("https://example.net/a/b.html")?; let url = base.join("c.png")?; assert_eq!(url.as_str(), "https://example.net/a/c.png"); // Not /a/b.html/c.png let base = Url::parse("https://example.net/a/b/")?; let url = base.join("c.png")?; assert_eq!(url.as_str(), "https://example.net/a/b/c.png");
Errors
If the function can not parse an URL from the given string
with this URL as the base URL, a ParseError
variant will be returned.
fn options<'a>() -> ParseOptions<'a>
[src]
Return a default ParseOptions
that can fully configure the URL parser.
Examples
Get default ParseOptions
, then change base url
use url::Url; let options = Url::options(); let api = Url::parse("https://api.example.com")?; let base_url = options.base_url(Some(&api)); let version_url = base_url.parse("version.json")?; assert_eq!(version_url.as_str(), "https://api.example.com/version.json");
fn as_str(&self) -> &str
[src]
Return the serialization of this URL.
This is fast since that serialization is already stored in the Url
struct.
Examples
use url::Url; let url_str = "https://example.net/"; let url = Url::parse(url_str)?; assert_eq!(url.as_str(), url_str);
fn into_string(self) -> String
[src]
Return the serialization of this URL.
This consumes the Url
and takes ownership of the String
stored in it.
Examples
use url::Url; let url_str = "https://example.net/"; let url = Url::parse(url_str)?; assert_eq!(url.into_string(), url_str);
fn origin(&self) -> Origin
[src]
Return the origin of this URL (https://url.spec.whatwg.org/#origin)
Note: this returns an opaque origin for file:
URLs, which causes
url.origin() != url.origin()
.
Examples
URL with ftp
scheme:
use url::{Host, Origin, Url}; let url = Url::parse("ftp://example.com/foo")?; assert_eq!(url.origin(), Origin::Tuple("ftp".into(), Host::Domain("example.com".into()), 21));
URL with blob
scheme:
use url::{Host, Origin, Url}; let url = Url::parse("blob:https://example.com/foo")?; assert_eq!(url.origin(), Origin::Tuple("https".into(), Host::Domain("example.com".into()), 443));
URL with file
scheme:
use url::{Host, Origin, Url}; let url = Url::parse("file:///tmp/foo")?; assert!(!url.origin().is_tuple()); let other_url = Url::parse("file:///tmp/foo")?; assert!(url.origin() != other_url.origin());
URL with other scheme:
use url::{Host, Origin, Url}; let url = Url::parse("foo:bar")?; assert!(!url.origin().is_tuple());
fn scheme(&self) -> &str
[src]
Return the scheme of this URL, lower-cased, as an ASCII string without the ':' delimiter.
Examples
use url::Url; let url = Url::parse("file:///tmp/foo")?; assert_eq!(url.scheme(), "file");
[src]
Return whether the URL has an 'authority', which can contain a username, password, host, and port number.
URLs that do not are either path-only like unix:/run/foo.socket
or cannot-be-a-base like data:text/plain,Stuff
.
Examples
use url::Url; let url = Url::parse("ftp://rms@example.com")?; assert!(url.has_authority()); let url = Url::parse("unix:/run/foo.socket")?; assert!(!url.has_authority()); let url = Url::parse("data:text/plain,Stuff")?; assert!(!url.has_authority());
fn cannot_be_a_base(&self) -> bool
[src]
Return whether this URL is a cannot-be-a-base URL, meaning that parsing a relative URL string with this URL as the base will return an error.
This is the case if the scheme and :
delimiter are not followed by a /
slash,
as is typically the case of data:
and mailto:
URLs.
Examples
use url::Url; let url = Url::parse("ftp://rms@example.com")?; assert!(!url.cannot_be_a_base()); let url = Url::parse("unix:/run/foo.socket")?; assert!(!url.cannot_be_a_base()); let url = Url::parse("data:text/plain,Stuff")?; assert!(url.cannot_be_a_base());
fn username(&self) -> &str
[src]
Return the username for this URL (typically the empty string) as a percent-encoded ASCII string.
Examples
use url::Url; let url = Url::parse("ftp://rms@example.com")?; assert_eq!(url.username(), "rms"); let url = Url::parse("ftp://:secret123@example.com")?; assert_eq!(url.username(), ""); let url = Url::parse("https://example.com")?; assert_eq!(url.username(), "");
fn password(&self) -> Option<&str>
[src]
Return the password for this URL, if any, as a percent-encoded ASCII string.
Examples
use url::Url; let url = Url::parse("ftp://rms:secret123@example.com")?; assert_eq!(url.password(), Some("secret123")); let url = Url::parse("ftp://:secret123@example.com")?; assert_eq!(url.password(), Some("secret123")); let url = Url::parse("ftp://rms@example.com")?; assert_eq!(url.password(), None); let url = Url::parse("https://example.com")?; assert_eq!(url.password(), None);
fn has_host(&self) -> bool
[src]
Equivalent to url.host().is_some()
.
Examples
use url::Url; let url = Url::parse("ftp://rms@example.com")?; assert!(url.has_host()); let url = Url::parse("unix:/run/foo.socket")?; assert!(!url.has_host()); let url = Url::parse("data:text/plain,Stuff")?; assert!(!url.has_host());
fn host_str(&self) -> Option<&str>
[src]
Return the string representation of the host (domain or IP address) for this URL, if any.
Non-ASCII domains are punycode-encoded per IDNA.
IPv6 addresses are given between [
and ]
brackets.
Cannot-be-a-base URLs (typical of data:
and mailto:
) and some file:
URLs
don’t have a host.
See also the host
method.
Examples
use url::Url; let url = Url::parse("https://127.0.0.1/index.html")?; assert_eq!(url.host_str(), Some("127.0.0.1")); let url = Url::parse("ftp://rms@example.com")?; assert_eq!(url.host_str(), Some("example.com")); let url = Url::parse("unix:/run/foo.socket")?; assert_eq!(url.host_str(), None); let url = Url::parse("data:text/plain,Stuff")?; assert_eq!(url.host_str(), None);
fn host(&self) -> Option<Host<&str>>
[src]
Return the parsed representation of the host for this URL. Non-ASCII domain labels are punycode-encoded per IDNA.
Cannot-be-a-base URLs (typical of data:
and mailto:
) and some file:
URLs
don’t have a host.
See also the host_str
method.
Examples
use url::Url; let url = Url::parse("https://127.0.0.1/index.html")?; assert!(url.host().is_some()); let url = Url::parse("ftp://rms@example.com")?; assert!(url.host().is_some()); let url = Url::parse("unix:/run/foo.socket")?; assert!(url.host().is_none()); let url = Url::parse("data:text/plain,Stuff")?; assert!(url.host().is_none());
fn domain(&self) -> Option<&str>
[src]
If this URL has a host and it is a domain name (not an IP address), return it.
Examples
use url::Url; let url = Url::parse("https://127.0.0.1/")?; assert_eq!(url.domain(), None); let url = Url::parse("mailto:rms@example.net")?; assert_eq!(url.domain(), None); let url = Url::parse("https://example.com/")?; assert_eq!(url.domain(), Some("example.com"));
fn port(&self) -> Option<u16>
[src]
Return the port number for this URL, if any.
Examples
use url::Url; let url = Url::parse("https://example.com")?; assert_eq!(url.port(), None); let url = Url::parse("ssh://example.com:22")?; assert_eq!(url.port(), Some(22));
fn port_or_known_default(&self) -> Option<u16>
[src]
Return the port number for this URL, or the default port number if it is known.
This method only knows the default port number
of the http
, https
, ws
, wss
, ftp
, and gopher
schemes.
For URLs in these schemes, this method always returns Some(_)
.
For other schemes, it is the same as Url::port()
.
Examples
use url::Url; let url = Url::parse("foo://example.com")?; assert_eq!(url.port_or_known_default(), None); let url = Url::parse("foo://example.com:1456")?; assert_eq!(url.port_or_known_default(), Some(1456)); let url = Url::parse("https://example.com")?; assert_eq!(url.port_or_known_default(), Some(443));
fn with_default_port<F>(&self, f: F) -> Result<HostAndPort<&str>> where
F: FnOnce(&Url) -> Result<u16, ()>,
[src]
F: FnOnce(&Url) -> Result<u16, ()>,
If the URL has a host, return something that implements ToSocketAddrs
.
If the URL has no port number and the scheme’s default port number is not known
(see Url::port_or_known_default
),
the closure is called to obtain a port number.
Typically, this closure can match on the result Url::scheme
to have per-scheme default port numbers,
and panic for schemes it’s not prepared to handle.
For example:
fn connect(url: &Url) -> io::Result<TcpStream> { TcpStream::connect(url.with_default_port(default_port)?) } fn default_port(url: &Url) -> Result<u16, ()> { match url.scheme() { "git" => Ok(9418), "git+ssh" => Ok(22), "git+https" => Ok(443), "git+http" => Ok(80), _ => Err(()), } }
fn path(&self) -> &str
[src]
Return the path for this URL, as a percent-encoded ASCII string. For cannot-be-a-base URLs, this is an arbitrary string that doesn’t start with '/'. For other URLs, this starts with a '/' slash and continues with slash-separated path segments.
Examples
use url::{Url, ParseError}; let url = Url::parse("https://example.com/api/versions?page=2")?; assert_eq!(url.path(), "/api/versions"); let url = Url::parse("https://example.com")?; assert_eq!(url.path(), "/"); let url = Url::parse("https://example.com/countries/việt nam")?; assert_eq!(url.path(), "/countries/vi%E1%BB%87t%20nam");
fn path_segments(&self) -> Option<Split<char>>
[src]
Unless this URL is cannot-be-a-base, return an iterator of '/' slash-separated path segments, each as a percent-encoded ASCII string.
Return None
for cannot-be-a-base URLs.
When Some
is returned, the iterator always contains at least one string
(which may be empty).
Examples
use url::Url; let url = Url::parse("https://example.com/foo/bar")?; let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?; assert_eq!(path_segments.next(), Some("foo")); assert_eq!(path_segments.next(), Some("bar")); assert_eq!(path_segments.next(), None); let url = Url::parse("https://example.com")?; let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?; assert_eq!(path_segments.next(), Some("")); assert_eq!(path_segments.next(), None); let url = Url::parse("data:text/plain,HelloWorld")?; assert!(url.path_segments().is_none()); let url = Url::parse("https://example.com/countries/việt nam")?; let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?; assert_eq!(path_segments.next(), Some("countries")); assert_eq!(path_segments.next(), Some("vi%E1%BB%87t%20nam"));
fn query(&self) -> Option<&str>
[src]
Return this URL’s query string, if any, as a percent-encoded ASCII string.
Examples
use url::Url; fn run() -> Result<(), ParseError> { let url = Url::parse("https://example.com/products?page=2")?; let query = url.query(); assert_eq!(query, Some("page=2")); let url = Url::parse("https://example.com/products")?; let query = url.query(); assert!(query.is_none()); let url = Url::parse("https://example.com/?country=español")?; let query = url.query(); assert_eq!(query, Some("country=espa%C3%B1ol"));
fn query_pairs(&self) -> Parse
[src]
Parse the URL’s query string, if any, as application/x-www-form-urlencoded
and return an iterator of (key, value) pairs.
Examples
use std::borrow::Cow; use url::Url; let url = Url::parse("https://example.com/products?page=2&sort=desc")?; let mut pairs = url.query_pairs(); assert_eq!(pairs.count(), 2); assert_eq!(pairs.next(), Some((Cow::Borrowed("page"), Cow::Borrowed("2")))); assert_eq!(pairs.next(), Some((Cow::Borrowed("sort"), Cow::Borrowed("desc"))));
fn fragment(&self) -> Option<&str>
[src]
Return this URL’s fragment identifier, if any.
A fragment is the part of the URL after the #
symbol.
The fragment is optional and, if present, contains a fragment identifier
that identifies a secondary resource, such as a section heading
of a document.
In HTML, the fragment identifier is usually the id attribute of a an element that is scrolled to on load. Browsers typically will not send the fragment portion of a URL to the server.
Note: the parser did not percent-encode this component, but the input may have been percent-encoded already.
Examples
use url::Url; let url = Url::parse("https://example.com/data.csv#row=4")?; assert_eq!(url.fragment(), Some("row=4")); let url = Url::parse("https://example.com/data.csv#cell=4,1-6,2")?; assert_eq!(url.fragment(), Some("cell=4,1-6,2"));
fn set_fragment(&mut self, fragment: Option<&str>)
[src]
Change this URL’s fragment identifier.
Examples
use url::Url; let mut url = Url::parse("https://example.com/data.csv")?; assert_eq!(url.as_str(), "https://example.com/data.csv"); url.set_fragment(Some("cell=4,1-6,2")); assert_eq!(url.as_str(), "https://example.com/data.csv#cell=4,1-6,2"); assert_eq!(url.fragment(), Some("cell=4,1-6,2")); url.set_fragment(None); assert_eq!(url.as_str(), "https://example.com/data.csv"); assert!(url.fragment().is_none());
fn set_query(&mut self, query: Option<&str>)
[src]
Change this URL’s query string.
Examples
use url::Url; let mut url = Url::parse("https://example.com/products")?; assert_eq!(url.as_str(), "https://example.com/products"); url.set_query(Some("page=2")); assert_eq!(url.as_str(), "https://example.com/products?page=2"); assert_eq!(url.query(), Some("page=2"));
fn query_pairs_mut(&mut self) -> Serializer<UrlQuery>
[src]
Manipulate this URL’s query string, viewed as a sequence of name/value pairs
in application/x-www-form-urlencoded
syntax.
The return value has a method-chaining API:
let mut url = Url::parse("https://example.net?lang=fr#nav")?; assert_eq!(url.query(), Some("lang=fr")); url.query_pairs_mut().append_pair("foo", "bar"); assert_eq!(url.query(), Some("lang=fr&foo=bar")); assert_eq!(url.as_str(), "https://example.net/?lang=fr&foo=bar#nav"); url.query_pairs_mut() .clear() .append_pair("foo", "bar & baz") .append_pair("saisons", "\u{00C9}t\u{00E9}+hiver"); assert_eq!(url.query(), Some("foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver")); assert_eq!(url.as_str(), "https://example.net/?foo=bar+%26+baz&saisons=%C3%89t%C3%A9%2Bhiver#nav");
Note: url.query_pairs_mut().clear();
is equivalent to url.set_query(Some(""))
,
not url.set_query(None)
.
The state of Url
is unspecified if this return value is leaked without being dropped.
fn set_path(&mut self, path: &str)
[src]
Change this URL’s path.
Examples
use url::Url; let mut url = Url::parse("https://example.com")?; url.set_path("api/comments"); assert_eq!(url.as_str(), "https://example.com/api/comments"); assert_eq!(url.path(), "/api/comments"); let mut url = Url::parse("https://example.com/api")?; url.set_path("data/report.csv"); assert_eq!(url.as_str(), "https://example.com/data/report.csv"); assert_eq!(url.path(), "/data/report.csv");
fn path_segments_mut(&mut self) -> Result<PathSegmentsMut, ()>
[src]
Return an object with methods to manipulate this URL’s path segments.
Return Err(())
if this URL is cannot-be-a-base.
fn set_port(&mut self, port: Option<u16>) -> Result<(), ()>
[src]
Change this URL’s port number.
If this URL is cannot-be-a-base, does not have a host, or has the file
scheme;
do nothing and return Err
.
Examples
use url::Url; let mut url = Url::parse("ssh://example.net:2048/")?; url.set_port(Some(4096)).map_err(|_| "cannot be base")?; assert_eq!(url.as_str(), "ssh://example.net:4096/"); url.set_port(None).map_err(|_| "cannot be base")?; assert_eq!(url.as_str(), "ssh://example.net/");
Cannot set port for cannot-be-a-base URLs:
use url::Url; let mut url = Url::parse("mailto:rms@example.net")?; let result = url.set_port(Some(80)); assert!(result.is_err()); let result = url.set_port(None); assert!(result.is_err());
fn set_host(&mut self, host: Option<&str>) -> Result<(), ParseError>
[src]
Change this URL’s host.
Removing the host (calling this with None
)
will also remove any username, password, and port number.
Examples
Change host:
use url::Url; let mut url = Url::parse("https://example.net")?; let result = url.set_host(Some("rust-lang.org")); assert!(result.is_ok()); assert_eq!(url.as_str(), "https://rust-lang.org/");
Remove host:
use url::Url; let mut url = Url::parse("foo://example.net")?; let result = url.set_host(None); assert!(result.is_ok()); assert_eq!(url.as_str(), "foo:/");
Cannot remove host for 'special' schemes (e.g. http
):
use url::Url; let mut url = Url::parse("https://example.net")?; let result = url.set_host(None); assert!(result.is_err()); assert_eq!(url.as_str(), "https://example.net/");
Cannot change or remove host for cannot-be-a-base URLs:
use url::Url; let mut url = Url::parse("mailto:rms@example.net")?; let result = url.set_host(Some("rust-lang.org")); assert!(result.is_err()); assert_eq!(url.as_str(), "mailto:rms@example.net"); let result = url.set_host(None); assert!(result.is_err()); assert_eq!(url.as_str(), "mailto:rms@example.net");
Errors
If this URL is cannot-be-a-base or there is an error parsing the given host
,
a ParseError
variant will be returned.
fn set_ip_host(&mut self, address: IpAddr) -> Result<(), ()>
[src]
Change this URL’s host to the given IP address.
If this URL is cannot-be-a-base, do nothing and return Err
.
Compared to Url::set_host
, this skips the host parser.
Examples
use url::{Url, ParseError}; let mut url = Url::parse("http://example.com")?; url.set_ip_host("127.0.0.1".parse().unwrap()); assert_eq!(url.host_str(), Some("127.0.0.1")); assert_eq!(url.as_str(), "http://127.0.0.1/");
Cannot change URL's from mailto(cannot-be-base) to ip:
use url::{Url, ParseError}; let mut url = Url::parse("mailto:rms@example.com")?; let result = url.set_ip_host("127.0.0.1".parse().unwrap()); assert_eq!(url.as_str(), "mailto:rms@example.com"); assert!(result.is_err());
fn set_password(&mut self, password: Option<&str>) -> Result<(), ()>
[src]
Change this URL’s password.
If this URL is cannot-be-a-base or does not have a host, do nothing and return Err
.
Examples
use url::{Url, ParseError}; let mut url = Url::parse("mailto:rmz@example.com")?; let result = url.set_password(Some("secret_password")); assert!(result.is_err()); let mut url = Url::parse("ftp://user1:secret1@example.com")?; let result = url.set_password(Some("secret_password")); assert_eq!(url.password(), Some("secret_password")); let mut url = Url::parse("ftp://user2:@example.com")?; let result = url.set_password(Some("secret2")); assert!(result.is_ok()); assert_eq!(url.password(), Some("secret2"));
fn set_username(&mut self, username: &str) -> Result<(), ()>
[src]
Change this URL’s username.
If this URL is cannot-be-a-base or does not have a host, do nothing and return Err
.
Examples
Cannot setup username from mailto(cannot-be-base)
use url::{Url, ParseError}; let mut url = Url::parse("mailto:rmz@example.com")?; let result = url.set_username("user1"); assert_eq!(url.as_str(), "mailto:rmz@example.com"); assert!(result.is_err());
Setup username to user1
use url::{Url, ParseError}; let mut url = Url::parse("ftp://:secre1@example.com/")?; let result = url.set_username("user1"); assert!(result.is_ok()); assert_eq!(url.username(), "user1"); assert_eq!(url.as_str(), "ftp://user1:secre1@example.com/");
fn set_scheme(&mut self, scheme: &str) -> Result<(), ()>
[src]
Change this URL’s scheme.
Do nothing and return Err
if:
- The new scheme is not in
[a-zA-Z][a-zA-Z0-9+.-]+
- This URL is cannot-be-a-base and the new scheme is one of
http
,https
,ws
,wss
,ftp
, orgopher
Examples
Change the URL’s scheme from https
to foo
:
use url::Url; let mut url = Url::parse("https://example.net")?; let result = url.set_scheme("foo"); assert_eq!(url.as_str(), "foo://example.net/"); assert!(result.is_ok());
Cannot change URL’s scheme from https
to foõ
:
use url::Url; let mut url = Url::parse("https://example.net")?; let result = url.set_scheme("foõ"); assert_eq!(url.as_str(), "https://example.net/"); assert!(result.is_err());
Cannot change URL’s scheme from mailto
(cannot-be-a-base) to https
:
use url::Url; let mut url = Url::parse("mailto:rms@example.net")?; let result = url.set_scheme("https"); assert_eq!(url.as_str(), "mailto:rms@example.net"); assert!(result.is_err());
fn from_file_path<P: AsRef<Path>>(path: P) -> Result<Url, ()>
[src]
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,
on Windows, if the prefix is not a disk prefix (e.g. C:
) or a UNC prefix (\\
).
Examples
On Unix-like platforms:
use url::Url; let url = Url::from_file_path("/tmp/foo.txt")?; assert_eq!(url.as_str(), "file:///tmp/foo.txt"); let url = Url::from_file_path("../foo.txt"); assert!(url.is_err()); let url = Url::from_file_path("https://google.com/"); assert!(url.is_err());
fn from_directory_path<P: AsRef<Path>>(path: P) -> Result<Url, ()>
[src]
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,
on Windows, if the prefix is not a disk prefix (e.g. C:
) or a UNC prefix (\\
).
Compared to from_file_path
, this ensure that URL’s the path has 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 std::path
does not consider trailing slashes significant
and usually does not include them (e.g. in Path::parent()
).
fn serialize_internal<S>(&self, serializer: &mut S) -> Result<(), S::Error> where
S: Serializer,
[src]
S: Serializer,
Serialize with Serde using the internal representation of the Url
struct.
The corresponding deserialize_internal
method sacrifices some invariant-checking
for speed, compared to the Deserialize
trait impl.
This method is only available if the serde
Cargo feature is enabled.
fn deserialize_internal<D>(deserializer: &mut D) -> Result<Self, D::Error> where
D: Deserializer,
[src]
D: Deserializer,
Serialize with Serde using the internal representation of the Url
struct.
The corresponding deserialize_internal
method sacrifices some invariant-checking
for speed, compared to the Deserialize
trait impl.
This method is only available if the serde
Cargo feature is enabled.
fn to_file_path(&self) -> Result<PathBuf, ()>
[src]
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.
let path = url.to_file_path();
Returns Err
if the host is neither empty nor "localhost"
(except on Windows, where
file:
URLs may have a non-local host),
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.)
Trait Implementations
impl Index<RangeFull> for Url
[src]
type Output = str
The returned type after indexing.
fn index(&self, _: RangeFull) -> &str
[src]
Performs the indexing (container[index]
) operation.
impl Index<RangeFrom<Position>> for Url
[src]
type Output = str
The returned type after indexing.
fn index(&self, range: RangeFrom<Position>) -> &str
[src]
Performs the indexing (container[index]
) operation.
impl Index<RangeTo<Position>> for Url
[src]
type Output = str
The returned type after indexing.
fn index(&self, range: RangeTo<Position>) -> &str
[src]
Performs the indexing (container[index]
) operation.
impl Index<Range<Position>> for Url
[src]
type Output = str
The returned type after indexing.
fn index(&self, range: Range<Position>) -> &str
[src]
Performs the indexing (container[index]
) operation.
impl Clone for Url
[src]
fn clone(&self) -> Url
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl ToSocketAddrs for Url
[src]
Return an error if Url::host
or Url::port_or_known_default
return None
.
type Iter = SocketAddrs
Returned iterator over socket addresses which this type may correspond to. Read more
fn to_socket_addrs(&self) -> Result<Self::Iter>
[src]
Converts this object to an iterator of resolved SocketAddr
s. Read more
impl FromStr for Url
[src]
Parse a string as an URL, without a base URL or encoding override.
type Err = ParseError
The associated error which can be returned from parsing.
fn from_str(input: &str) -> Result<Url, ParseError>
[src]
Parses a string s
to return a value of this type. Read more
impl Display for Url
[src]
Display the serialization of this URL.
fn fmt(&self, formatter: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl Debug for Url
[src]
Debug the serialization of this URL.
fn fmt(&self, formatter: &mut Formatter) -> Result
[src]
Formats the value using the given formatter.
impl Eq for Url
[src]
URLs compare like their serialization.
impl PartialEq for Url
[src]
URLs compare like their serialization.
fn eq(&self, other: &Self) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl Ord for Url
[src]
URLs compare like their serialization.
fn cmp(&self, other: &Self) -> Ordering
[src]
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.21.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
Compares and returns the minimum of two values. Read more
impl PartialOrd for Url
[src]
URLs compare like their serialization.
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Hash for Url
[src]
URLs hash like their serialization.
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl AsRef<str> for Url
[src]
Return the serialization of this URL.
impl Serialize for Url
[src]
Serializes this URL into a serde
stream.
This implementation is only available if the serde
Cargo feature is enabled.
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where
S: Serializer,
[src]
S: Serializer,
Serializes this value into this serializer.
impl Deserialize for Url
[src]
Deserializes this URL from a serde
stream.
This implementation is only available if the serde
Cargo feature is enabled.
fn deserialize<D>(deserializer: &mut D) -> Result<Url, D::Error> where
D: Deserializer,
[src]
D: Deserializer,
Deserialize this value given this Deserializer
.