Struct PathSegmentsMut

struct PathSegmentsMut<'a> { ... }

Exposes methods to manipulate the path of an URL that is not cannot-be-base.

The path always starts with a / slash, and is made of slash-separated segments. There is always at least one segment (which may be the empty string).

Examples:

use url::Url;

# #[cfg(feature = "std")]
# use std::error::Error;
# #[cfg(not(feature = "std"))]
# use core::error::Error;

# fn run() -> Result<(), Box<dyn Error>> {
let mut url = Url::parse("mailto:me@example.com")?;
assert!(url.path_segments_mut().is_err());

let mut url = Url::parse("http://example.net/foo/index.html")?;
url.path_segments_mut().map_err(|_| "cannot be base")?
    .pop().push("img").push("2/100%.png");
assert_eq!(url.as_str(), "http://example.net/foo/img/2%2F100%25.png");
# Ok(())
# }
# run().unwrap();

Implementations

impl<'a> PathSegmentsMut<'a>

fn clear(self: &mut Self) -> &mut Self

Remove all segments in the path, leaving the minimal url.path() == "/".

Returns &mut Self so that method calls can be chained.

Example:

use url::Url;

# #[cfg(feature = "std")]
# use std::error::Error;
# #[cfg(not(feature = "std"))]
# use core::error::Error;

# fn run() -> Result<(), Box<dyn Error>> {
let mut url = Url::parse("https://github.com/servo/rust-url/")?;
url.path_segments_mut().map_err(|_| "cannot be base")?
    .clear().push("logout");
assert_eq!(url.as_str(), "https://github.com/logout");
# Ok(())
# }
# run().unwrap();

fn pop_if_empty(self: &mut Self) -> &mut Self

Remove the last segment of this URL’s path if it is empty, except if these was only one segment to begin with.

In other words, remove one path trailing slash, if any, unless it is also the initial slash (so this does nothing if url.path() == "/").

Returns &mut Self so that method calls can be chained.

Example:

use url::Url;

# #[cfg(feature = "std")]
# use std::error::Error;
# #[cfg(not(feature = "std"))]
# use core::error::Error;

# fn run() -> Result<(), Box<dyn Error>> {
let mut url = Url::parse("https://github.com/servo/rust-url/")?;
url.path_segments_mut().map_err(|_| "cannot be base")?
    .push("pulls");
assert_eq!(url.as_str(), "https://github.com/servo/rust-url//pulls");

let mut url = Url::parse("https://github.com/servo/rust-url/")?;
url.path_segments_mut().map_err(|_| "cannot be base")?
    .pop_if_empty().push("pulls");
assert_eq!(url.as_str(), "https://github.com/servo/rust-url/pulls");
# Ok(())
# }
# run().unwrap();

fn pop(self: &mut Self) -> &mut Self

Remove the last segment of this URL’s path.

If the path only has one segment, make it empty such that url.path() == "/".

Returns &mut Self so that method calls can be chained.

fn push(self: &mut Self, segment: &str) -> &mut Self

Append the given segment at the end of this URL’s path.

See the documentation for .extend().

Returns &mut Self so that method calls can be chained.

fn extend<I>(self: &mut Self, segments: I) -> &mut Self
where
    I: IntoIterator,
    <I as >::Item: AsRef<str>

Append each segment from the given iterator at the end of this URL’s path.

Each segment is percent-encoded like in Url::parse or Url::join, except that % and / characters are also encoded (to %25 and %2F). This is unlike Url::parse where % is left as-is in case some of the input is already percent-encoded, and / denotes a path segment separator.)

Note that, in addition to slashes between new segments, this always adds a slash between the existing path and the new segments except if the existing path is "/". If the previous last segment was empty (if the path had a trailing slash) the path after .extend() will contain two consecutive slashes. If that is undesired, call .pop_if_empty() first.

To obtain a behavior similar to Url::join, call .pop() unconditionally first.

Returns &mut Self so that method calls can be chained.

Example:

use url::Url;

# #[cfg(feature = "std")]
# use std::error::Error;
# #[cfg(not(feature = "std"))]
# use core::error::Error;

# fn run() -> Result<(), Box<dyn Error>> {
let mut url = Url::parse("https://github.com/")?;
let org = "servo";
let repo = "rust-url";
let issue_number = "188";
url.path_segments_mut().map_err(|_| "cannot be base")?
    .extend(&[org, repo, "issues", issue_number]);
assert_eq!(url.as_str(), "https://github.com/servo/rust-url/issues/188");
# Ok(())
# }
# run().unwrap();

In order to make sure that parsing the serialization of an URL gives the same URL, a segment is ignored if it is "." or "..":

use url::Url;

# #[cfg(feature = "std")]
# use std::error::Error;
# #[cfg(not(feature = "std"))]
# use core::error::Error;

# fn run() -> Result<(), Box<dyn Error>> {
let mut url = Url::parse("https://github.com/servo")?;
url.path_segments_mut().map_err(|_| "cannot be base")?
    .extend(&["..", "rust-url", ".", "pulls"]);
assert_eq!(url.as_str(), "https://github.com/servo/rust-url/pulls");
# Ok(())
# }
# run().unwrap();

impl<'a> Debug for PathSegmentsMut<'a>

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

impl<'a> Drop for PathSegmentsMut<'a>

fn drop(self: &mut Self)

impl<'a> Freeze for PathSegmentsMut<'a>

impl<'a> RefUnwindSafe for PathSegmentsMut<'a>

impl<'a> Send for PathSegmentsMut<'a>

impl<'a> Sync for PathSegmentsMut<'a>

impl<'a> Unpin for PathSegmentsMut<'a>

impl<'a> UnsafeUnpin for PathSegmentsMut<'a>

impl<'a> UnwindSafe for PathSegmentsMut<'a>

impl<T> Any for PathSegmentsMut<'a>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for PathSegmentsMut<'a>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for PathSegmentsMut<'a>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> ErasedDestructor for PathSegmentsMut<'a>

impl<T> From for PathSegmentsMut<'a>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for PathSegmentsMut<'a>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for PathSegmentsMut<'a>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for PathSegmentsMut<'a>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>