Enum redox_path::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 path. Relative paths will be joined, absolute paths will be returned as-is.

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 “/”.

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

Trait Implementations

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

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

Returns a copy 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

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