# url::PathSegmentsMut - Rust
API documentation for the Rust `PathSegmentsMut` struct in crate `url`.
Keywords: rust, rustlang, rust-lang, PathSegmentsMut

# Struct url::PathSegmentsMut [−] [src]

    pub struct PathSegmentsMut<'a> { /* fields omitted */ }

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;

    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");

## Implementations

### `impl<'a> PathSegmentsMut<'a>` [src]

#### `pub fn clear(&mut self) -> &mut Self` [src]

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;

    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");

#### `pub fn pop_if_empty(&mut self) -> &mut Self` [src]

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;

    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");

#### `pub fn pop(&mut self) -> &mut Self` [src]

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.

#### `pub fn push(&mut self, segment: &str) -> &mut Self` [src]

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.

#### `pub fn extend<I>(&mut self, segments: I) -> &mut Self where
I: IntoIterator,
I::Item: AsRef<str>,` [src]

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;

    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");

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;

    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");

## Trait Implementations

### `impl<'a> Debug for PathSegmentsMut<'a>` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<'a> Drop for PathSegmentsMut<'a>` [src]

#### `fn drop(&mut self)` [src]

Executes the destructor for this type. Read more

## Auto Trait Implementations

### `impl<'a> RefUnwindSafe for PathSegmentsMut<'a>` [src]

### `impl<'a> Send for PathSegmentsMut<'a>` [src]

### `impl<'a> Sync for PathSegmentsMut<'a>` [src]

### `impl<'a> Unpin for PathSegmentsMut<'a>` [src]

### `impl<'a> !UnwindSafe for PathSegmentsMut<'a>` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.