Enum RedoxPath 

pub enum RedoxPath<'a> {
    Standard(RedoxReference<'a>),
    Legacy(RedoxScheme<'a>, RedoxReference<'a>),
}

A fully qualified Redox path

Variants

Standard(RedoxReference<'a>)

Standard UNIX compatible format

Legacy(RedoxScheme<'a>, RedoxReference<'a>)

Legacy URI format

Implementations

impl<'a> RedoxPath<'a>

pub fn from_absolute<S: Into<Cow<'a, str>>>(path: S) -> Option<Self>

Create RedoxPath from absolute path

Returns Some on success and None if the path contains NUL

pub fn from_absolute_c<S: Into<&'a CStr>>(path: S) -> Option<Self>

Create a new RedoxPath from C string, ensuring it is a valid UTF-8

pub fn from_absolute_buf(path: &'a [u8], len: usize) -> Option<Self>

Create a new RedoxPath from a buffer, ensuring it is a valid UTF-8 and valid from NUL

pub fn from_reference(path: RedoxReference<'a>) -> Option<Self>

Create a new RedoxPath from RedoxReference if the reference is absolute

pub fn join<'b, S: Into<Cow<'b, str>>>(&self, path: S) -> Option<RedoxPath<'b>>

Join a RedoxPath with a &str path. Relative paths will be appended to self, absolute paths will be returned as a RedoxPath, ignoring self.

Returns Some on success and None if the path is not valid

pub fn join_checked<'b>(&self, path: RedoxReference<'b>) -> RedoxPath<'b>

Join, but checked from NUL

pub fn canonical(self) -> Self

Canonicalize path, see RedoxReference::canonical

pub fn is_canon(&self) -> bool

Verify that the path is canonicalized.

Returns false if any segment is “.”, “..” or “”. A path that is empty is allowed and is interpreted as “/”. Legacy paths are assumed to be canonical.

pub fn as_parts(&'a self) -> Option<(RedoxScheme<'a>, RedoxReference<'a>)>

Convert into a RedoxScheme and RedoxReference.

• Standard paths will parse /scheme/scheme_name/reference, and anything not starting with /scheme will be parsed as being part of the file scheme
• Legacy paths can be instantly converted

pub fn get_scheme(&'a self) -> Option<RedoxScheme<'a>>

Get a RedoxScheme if the reference contained /scheme/scheme_name. Does not fallback to default scheme if absent.

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

Is the scheme for this path the same as the given string?

pub fn is_scheme_category(&self, category: &str) -> bool

Does the scheme match the given category, e.g. “disk-”

pub fn is_default_scheme(&self) -> bool

Is this the default scheme, “/scheme/file”?

pub fn is_legacy(&self) -> bool

Is this a Legacy format path?

pub fn to_standard(self) -> RedoxReference<'a>

Format a RedoxPath into a UNIX style path

pub fn to_standard_canon(self) -> RedoxPath<'a>

Format a RedoxPath into a UNIX style path, ensuring it is canonicalized

pub fn dirname<'b>(&self) -> RedoxPath<'b>

Get path upward one time

pub fn dirname_split(&'a self) -> (RedoxPath<'a>, Option<RedoxReference<'a>>)

Get path upward one time and the file name

pub fn to_reference(self) -> RedoxReference<'a>

Convert into RedoxReference, if it an old scheme, the scheme part will be discarded.

pub fn as_reference(&self) -> &RedoxReference<'a>

Get RedoxReference, if it an old scheme, the scheme part will be discarded.

pub fn canonicalize_as_cwd<'b>(&self, path: RedoxStr<'b>) -> RedoxPath<'b>

Similar to canonicalize_using_cwd

pub fn canonicalize_as_cwd_standard<'b>( &self, path: RedoxStr<'b>, ) -> RedoxPath<'b>

Similar to canonicalize_to_standard

pub fn canonicalize_as_cwd_with_max_upward<'b>( &self, relpath: RedoxReference<'b>, max_upward: usize, ) -> Option<(RedoxPath<'b>, usize)>

Similar to canonicalize_using_cwd_with_max_upward

pub fn into_owned<'b>(self) -> RedoxPath<'b>

Copy the content into owned

Trait Implementations

impl<'a> Clone for RedoxPath<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RedoxPath<'a>

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

Formats the value using the given formatter.

impl<'a> Display for RedoxPath<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for RedoxPath<'a>

impl<'a> From<RedoxPath<'a>> for Cow<'a, str>

fn from(value: RedoxPath<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<RedoxPath<'a>> for RedoxStr<'a>

fn from(value: RedoxPath<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for RedoxPath<'a>

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

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

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for RedoxPath<'a>