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(path: &'a str) -> Option<Self>

Create RedoxPath from absolute path

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

pub fn join(&self, path: &'a str) -> Option<Self>

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 canonical(&self) -> Option<Self>

Canonicalize path, removing . and ..

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

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 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) -> String

Format a RedoxPath into a UNIX style path

pub fn to_standard_canon(&self) -> Option<String>

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

Trait Implementations

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

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

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> 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: &RedoxPath<'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> Eq for RedoxPath<'a>

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