Struct iref::Path

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

Methods

impl<'a> Path<'a>

pub fn as_ref(&self) -> &[u8]

pub fn as_str(&self) -> &str

Get the underlying path slice as a string slice.

pub fn as_pct_str(&self) -> &PctStr

Get the underlying path slice as a percent-encoded string slice.

pub fn is_empty(&self) -> bool

Checks if the path is empty.

Returns true if the path is `` or /.

pub fn is_absolute(&self) -> bool

Checks if the path is absolute.

A path is absolute if it starts with a /. A path is necessarily absolute if the IRI it is contained in contains a non-empty authority.

pub fn is_relative(&self) -> bool

Checks if the path is relative.

A path is relative if it does not start with a /. A path cannot be relative if the IRI it is contained in contains a non-empty authority.

pub fn is_open(&self) -> bool

Checks if the path ends with a / but is not equal to /.

pub fn is_closed(&self) -> bool

pub fn first(&self) -> Option<Segment<'a>>

pub fn directory(&self) -> Path

Return the path directory part.

This correspond to the path without everything after the right most /.

pub fn segments(&self) -> Segments

Produces an iterator over the segments of the IRI path.

Note that this is an IRI path, not an IRI reference path: no normalization occurs with . and .. segments. This is done by the IRI reference resolution function.

Empty segments are preserved: the path a//b will raise the three segments a, and `b`. The absolute path `/` has no segments, but the path `/a/` has two segments, `a` and.

pub fn normalized_segments(&self) -> NormalizedSegments

Iterate over the normalized segments of the path.

Remove the special dot segments .. and . from the iteration using the usual path semantics for dot segments. This may be expensive for large paths since it will need to internally normalize the path first.

pub fn into_normalized_segments(self) -> NormalizedSegments<'a>

Consume the path reference and return an iterator over its normalized segments.

pub fn file_name(&self) -> Option<&'a str>

Returns the name of the final segment of the path, if there is one.

If the path is a normal file, this is the file name. If it's the path of a directory, this is the directory name.

This does not consider the normalized version of the path, dot segments are preserved.

pub fn parent(&self) -> Option<Path<'a>>

Returns the path without its final component, if there is one.

Trait Implementations

impl<'a> Clone for Path<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Path<'a>

impl<'a> Debug for Path<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Display for Path<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Eq for Path<'a>

impl<'a> Hash for Path<'a>

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<'a> IntoIterator for Path<'a>

type Item = Segment<'a>

The type of the elements being iterated over.

type IntoIter = Segments<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Segments<'a>

Creates an iterator from a value.

impl<'a> Ord for Path<'a>

fn cmp(&self, other: &Path<'a>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

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

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<Path<'a>> for Path<'a>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialOrd<Path<'a>> for Path<'a>

fn partial_cmp(&self, other: &Path<'a>) -> Option<Ordering>

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl<'a> TryFrom<&'a str> for Path<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(str: &'a str) -> Result<Path<'a>, Error>

Performs the conversion.