Struct holochain::prelude::dependencies::kitsune_p2p_types::dependencies::lair_keystore_api::dependencies::url::PathSegmentsMut
source · pub struct PathSegmentsMut<'a> { /* private fields */ }
Expand description
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
sourceimpl<'a> PathSegmentsMut<'a>
impl<'a> PathSegmentsMut<'a>
sourcepub fn clear(&mut self) -> &mut PathSegmentsMut<'a>
pub fn clear(&mut self) -> &mut PathSegmentsMut<'a>
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");
sourcepub fn pop_if_empty(&mut self) -> &mut PathSegmentsMut<'a>
pub fn pop_if_empty(&mut self) -> &mut PathSegmentsMut<'a>
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");
sourcepub fn pop(&mut self) -> &mut PathSegmentsMut<'a>
pub fn pop(&mut self) -> &mut PathSegmentsMut<'a>
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.
sourcepub fn push(&mut self, segment: &str) -> &mut PathSegmentsMut<'a>
pub fn push(&mut self, segment: &str) -> &mut PathSegmentsMut<'a>
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.
sourcepub fn extend<I>(&mut self, segments: I) -> &mut PathSegmentsMut<'a>where
I: IntoIterator,
<I as IntoIterator>::Item: AsRef<str>,
pub fn extend<I>(&mut self, segments: I) -> &mut PathSegmentsMut<'a>where
I: IntoIterator,
<I as IntoIterator>::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;
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
sourceimpl<'a> Debug for PathSegmentsMut<'a>
impl<'a> Debug for PathSegmentsMut<'a>
Auto Trait Implementations
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> !UnwindSafe for PathSegmentsMut<'a>
Blanket Implementations
impl<T> Any for Twhere
T: Any + ?Sized,
impl<T> Any for Twhere
T: Any + ?Sized,
fn type_id_compat(&self) -> TypeId
fn type_id_compat(&self) -> TypeId
impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
type ArchivedMetadata = ()
type ArchivedMetadata = ()
fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata
) -> <T as Pointee>::Metadata
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
impl<F, W, T, D> Deserialize<With<T, W>, D> for Fwhere
W: DeserializeWith<F, T, D>,
D: Fallible + ?Sized,
F: ?Sized,
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
fn deserialize(
&self,
deserializer: &mut D
) -> Result<With<T, W>, <D as Fallible>::Error>
impl<T> FutureExt for T
impl<T> FutureExt for T
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
sourcefn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
sourcefn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
impl<T> Pointable for T
impl<T> Pointable for T
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read morefn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.