Struct iref::Path

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

Implementations

impl<'a> Path<'a>

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

pub fn into_ref(self) -> &'a [u8]

pub fn as_str(&self) -> &str

Get the underlying path slice as a string slice.

pub fn into_str(self) -> &'a str

Convert this path into the underlying path slice.

pub fn as_pct_str(&self) -> &PctStr

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

pub fn as_iri_ref(&self) -> IriRef<'_>

Get the path slice as an IRI reference.

pub fn into_iri_ref(self) -> IriRef<'a>

Convert this path into an IRI reference.

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.

pub fn suffix(&self, prefix: Path<'_>) -> Option<PathBuf>

Get the suffix part of this path, if any, with regard to the given prefix path.

Returns Some(suffix) if this path is of the form prefix/suffix where prefix is given as parameter. Returns None otherwise.

Both paths are normalized during the process. The result is a normalized suffix path.

Example

use iref::{Path, PathBuf};

let prefix = Path::try_from("/foo/bar").unwrap();
let path = Path::try_from("/foo/bar/baz").unwrap();
let suffix: PathBuf = path.suffix(prefix).unwrap();

assert_eq!(suffix, "baz");

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> From<Path<'a>> for PathBuf

fn from(path: Path<'a>) -> PathBuf

Performs the conversion.

impl<'a> From<Path<'a>> for IriRefBuf

fn from(path: Path<'a>) -> IriRefBuf

Performs the conversion.

impl<'a> From<Path<'a>> for IriRef<'a>

fn from(path: Path<'a>) -> IriRef<'a>

Performs the conversion.

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> PartialEq<Path<'a>> for PathMut<'a>

fn eq(&self, other: &Path<'a>) -> 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 PathBuf

fn eq(&self, other: &Path<'a>) -> 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<PathMut<'a>> for Path<'a>

fn eq(&self, other: &PathMut<'a>) -> 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.