Struct PathRef 

pub struct PathRef<'a> { /* private fields */ }

Available on crate feature net only.

Borrowed view of a URI path.

The backing bytes preserve the parsed path representation. Use as_encoded_str for a whole-path presentation. Decode path data segment-by-segment via PathRef::segments and PathSegment::as_decoded_str so encoded delimiters such as %2F cannot be confused with structural / separators.

Implementations

impl<'a> PathRef<'a>

pub fn from_raw_str(path: &'a str) -> PathRef<'a>

Borrow a raw string as a PathRef — no allocation, no unsafe. Note that it can mean that invalid characters are not yet pct-encoded, this is fine as for comparison/hashing purposes it is handled fine.

pub fn as_encoded_str(self) -> Cow<'a, str>

Percent-encoded path.

pub fn is_empty(self) -> bool

true when the path contains no bytes.

pub fn trimmed_slashes(self) -> PathRef<'a>

Path view with every leading and trailing / removed.

pub fn segment_range(self, start: usize, count: usize) -> Option<PathRef<'a>>

Borrow a window of count consecutive path segments starting at start.

When the window begins after an earlier segment, the returned view includes the / delimiter immediately before the first selected segment, making it directly usable with rooted PathPatterns. Returns None when the requested window is empty or extends beyond the available segments.

pub fn segments(self) -> PathSegments<'a>

Iterator over path segments — the parts between / separators.

Matches url::Url::path_segments: an empty path yields no segments, a leading / is the delimiter (not a segment), and a trailing / yields a final empty segment (so /foo and /foo/ stay distinct). Opaque paths (no leading /, e.g. the path of data:text/plain) split from the first byte.

"/"        -> [""]
"/foo/"    -> ["foo", ""]
"/a//b"    -> ["a", "", "b"]

pub fn has_prefix(self, prefix: impl IntoUriComponent) -> bool

true when the path begins with prefix — matched at / segment boundaries, comparing percent-decoded segment values. Shortcut for has_prefix_with_opts with the default PathMatchOptions.

pub fn has_prefix_with_opts( self, prefix: impl IntoUriComponent, opts: PathMatchOptions, ) -> bool

true when the path begins with prefix under opts.

pub fn has_suffix(self, suffix: impl IntoUriComponent) -> bool

true when the path ends with suffix — matched at / segment boundaries, comparing percent-decoded segment values. Shortcut for has_suffix_with_opts with the default PathMatchOptions.

pub fn has_suffix_with_opts( self, suffix: impl IntoUriComponent, opts: PathMatchOptions, ) -> bool

true when the path ends with suffix under opts.

pub fn nth_segment(self, n: usize) -> Option<PathSegment<'a>>

The n-th path segment (0-based), or None when the path has fewer segments. See segments for the splitting rules.

pub fn first_segment(self) -> Option<PathSegment<'a>>

The first path segment, or None for an empty path.

pub fn last_segment(self) -> Option<PathSegment<'a>>

The last path segment, or None for an empty path. A trailing / yields a final empty segment, so /foo/’s last segment is "".

pub fn segment_count(self) -> usize

Number of path segments. O(n) in the path length.

pub fn contains_segments(self, needle: impl IntoUriComponent) -> bool

true when needle’s segment(s) appear as a consecutive run of whole path segments — matched at / boundaries with percent-decoded values (default PathMatchOptions). E.g. contains_segments("@v") is true for /golang.org/x/mod/@v/list, and false for /x/@version/y.

pub fn contains_segments_with_opts( self, needle: impl IntoUriComponent, opts: PathMatchOptions, ) -> bool

true when needle’s segment(s) appear as a consecutive run of whole path segments under opts.

pub fn is_pattern_match(self, pattern: &PathPattern) -> bool

true when path matches given PathPattern.

Shortcut for PathPattern::is_match.

pub fn pattern_captures( self, pattern: &PathPattern, ) -> Option<PathCaptures<'_, 'a>>

Match using the given PathPattern and return captured values, or None when path doesn’t match. May allocate a small Vec for the bindings.

Shortcut for PathPattern::captures.

Trait Implementations

impl<'a> Clone for PathRef<'a>

fn clone(&self) -> PathRef<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for PathRef<'a>

impl<'a> Debug for PathRef<'a>

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

Formats the value using the given formatter.

impl<'a> Default for PathRef<'a>

fn default() -> PathRef<'a>

Returns the “default value” for a type.

impl Display for PathRef<'_>

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

Renders the raw on-wire path bytes (pct-encoding preserved).

impl Eq for PathRef<'_>

impl<'a> From<&'a str> for PathRef<'a>

fn from(path: &'a str) -> PathRef<'a>

Borrow a raw on-the-wire path string as a PathRef. See PathRef::from_raw_str.

impl Hash for PathRef<'_>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoUriComponent for PathRef<'_>

impl Ord for PathRef<'_>

fn cmp(&self, other: &PathRef<'_>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PathRef<'_>

fn eq(&self, other: &PathRef<'_>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<&str> for PathRef<'_>

fn eq(&self, other: &&str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<PathRef<'a>> for str

fn eq(&self, other: &PathRef<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<PathRef<'a>> for &str

fn eq(&self, other: &PathRef<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<str> for PathRef<'_>

fn eq(&self, other: &str) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for PathRef<'_>

fn partial_cmp(&self, other: &PathRef<'_>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.