Struct RedoxReference 

pub struct RedoxReference<'a>(/* private fields */);

The part of a path that is sent to each scheme

Implementations

impl<'a> RedoxReference<'a>

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

Create a new RedoxReference, ensuring there are no invalid characters. An empty path is considered valid and equivalent to ‘/’. A path not starting with ‘/’ will be considered not canonical.

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

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

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

Create a RedoxReference from a buf, returns None if it not a valid UTF-8 or valid from NUL

pub unsafe fn new_unchecked<S: Into<Cow<'a, str>>>(reference: S) -> Self

SAFETY: Caller ensures that path contains no NUL character

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

Join a RedoxReference 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 join_checked<'b>(&self, path: RedoxReference<'b>) -> RedoxReference<'b>

Join, but checked from NUL

pub fn canonical(self) -> Self

Canonicalize RedoxReference, removing ., .. and empty subpaths. In this function, relative path will be remain relative and the path remain not canon.

Paths that goes upward beyond the root path will be truncated i.e. /.. converted to / and ../foo/ converted to foo.

pub fn canonical_max_upward(self, max_upward: usize) -> Option<(Self, usize)>

Normalize RedoxReference, removing ., .. (if possible) and empty subpaths. This function will return None if the path is absolute or escapes root.

This function is useful to validate if the path still remain in scope within root. To make this works within symlink, max_upward is provided, and also returning an integer for next canonical_max_upward(max_upward). The amount of .. will never exceed max_upward.

pub fn to_relative(self) -> Self

Convert RedoxReference into relative path if it’s not already.

Converting the path to relative allows using Self::canonical_max_upward

pub fn is_canon(&self) -> bool

Verify that the reference is canonicalized

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

Get path upward one time

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

Get path upward one time and the file name

pub fn is_relative(&self) -> bool

Is this path relative?

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

Copy the content into owned

Trait Implementations

impl<'a> AsRef<str> for RedoxReference<'a>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for RedoxReference<'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 RedoxReference<'a>

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

Formats the value using the given formatter.

impl<'a> Display for RedoxReference<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for RedoxReference<'a>

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<'a> Hash for RedoxReference<'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 RedoxReference<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for RedoxReference<'a>