Struct iref::PathMut

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

Implementations

impl<'a> PathMut<'a>

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

Returns a reference to the bytes representation of the path.

pub fn as_path(&self) -> Path<'_>

Get the inner path.

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 open(&mut self)

Make sure the last segment is followed by a /.

This has no effect if the path is empty.

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<'_>

pub fn push(&mut self, segment: Segment<'_>)

Add a segment at the end of the path.

pub fn pop(&mut self)

pub fn clear(&mut self)

pub fn symbolic_append<'s, P: IntoIterator<Item = Segment<'s>>>(
    &mut self,
    path: P
)

pub fn normalize(&mut self)

Trait Implementations

impl<'a> AsIriRef for PathMut<'a>

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

impl<'a> AsRef<[u8]> for PathMut<'a>

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

Performs the conversion.

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 ==.

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 ==.

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

This method tests for !=.

impl<'a> PartialEq<PathMut<'a>> for PathBuf

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

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

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

This method tests for !=.