Struct Path 

pub struct Path { /* private fields */ }

A borrowed reference to a subset of a path, e.g. another Path or a [PathBuf]

Implementations

impl Path

Conversions

pub const MAX_COMPONENT_LENGTH: usize

Path components must be 255 bytes or less

pub const EMPTY: &'static Path

An empty path for use as a default value, placeholder, comparisons, etc.

pub const KERNEL_PATH: &'static str = "$kernel"

Base kernel path.

pub const ABSOLUTE_KERNEL_PATH: &'static str = "::$kernel"

pub const KERNEL: &'static Path

pub const EXEC_PATH: &'static str = "$exec"

Path for an executable module.

pub const ABSOLUTE_EXEC_PATH: &'static str = "::$exec"

pub const EXEC: &'static Path

pub fn new<S>(path: &S) -> &Path

where S: AsRef<str> + ?Sized,

pub fn from_mut(path: &mut str) -> &mut Path

pub fn validate(path: &str) -> Result<&Path, PathError>

Verify that path meets all the requirements for a valid Path

pub const fn kernel_path() -> &'static Path

Get a Path corresponding to Self::KERNEL_PATH

pub const fn exec_path() -> &'static Path

Get a Path corresponding to Self::EXEC_PATH

pub const fn as_str(&self) -> &str

pub fn as_mut_str(&mut self) -> &mut str

pub fn as_ident(&self) -> Option<Ident>

Get an [Ident] that is equivalent to this Path, so long as the path has only a single component.

Returns None if the path cannot be losslessly represented as a single component.

pub fn to_path_buf(&self) -> PathBuf

Convert this Path to an owned [PathBuf]

pub fn from_ident(ident: &Ident) -> Cow<'_, Path>

Convert an [Ident] to an equivalent Path or [PathBuf], depending on whether the identifier would require quoting as a path.

impl Path

Accesssors

pub fn is_empty(&self) -> bool

Returns true if this path is empty (i.e. has no components)

pub fn len(&self) -> usize

Returns the number of components in the path

pub fn char_len(&self) -> usize

Return the size of the path in chars when displayed as a string

pub fn byte_len(&self) -> usize

Return the size of the path in bytes when displayed as a string

pub fn is_absolute(&self) -> bool

Returns true if this path is an absolute path

pub fn to_absolute(&self) -> Cow<'_, Path>

Make this path absolute, if not already

NOTE: This does not resolve the path, it simply ensures the path has the root prefix

pub fn to_relative(&self) -> &Path

Strip the root prefix from this path, if it has one.

pub fn parent(&self) -> Option<&Path>

Returns the Path without its final component, if there is one.

This means it may return an empty Path for relative paths with a single component.

Returns None if the path terminates with the root prefix, or if it is empty.

pub fn components(&self) -> Iter<'_>

Returns an iterator over all components of the path.

pub fn first(&self) -> Option<&str>

Get the first non-root component of this path as a str

Returns None if the path is empty, or consists only of the root prefix.

pub fn last(&self) -> Option<&str>

Get the first non-root component of this path as a str

Returns None if the path is empty, or consists only of the root prefix.

pub fn split_first(&self) -> Option<(&str, &Path)>

Splits this path on the first non-root component, returning it and a new Path of the remaining components.

Returns None if there are no components to split

pub fn split_last(&self) -> Option<(&str, &Path)>

Splits this path on the last component, returning it and a new Path of the remaining components.

Returns None if there are no components to split

pub fn is_kernel_path(&self) -> bool

Returns true if this path is for the root kernel module.

pub fn is_in_kernel(&self) -> bool

Returns true if this path is for the root kernel module or an item in it

pub fn is_exec_path(&self) -> bool

Returns true if this path is for an executable module.

pub fn is_in_exec(&self) -> bool

Returns true if this path is for the executable module or an item in it

pub fn starts_with<Prefix>(&self, prefix: &Prefix) -> bool

where Path: StartsWith<Prefix>, Prefix: ?Sized,

Returns true if the current path, sans root component, starts with prefix

The matching semantics of Prefix depend on the implementation of [StartsWith<Prefix>], in particular, if Prefix is str, then the prefix is matched against the first non-root component of self, regardless of whether the string contains path delimiters (i.e. ::).

See the [StartsWith] trait for more details.

pub fn starts_with_exactly<Prefix>(&self, prefix: &Prefix) -> bool

where Path: StartsWith<Prefix>, Prefix: ?Sized,

Returns true if the current path, including root component, starts with prefix

The matching semantics of Prefix depend on the implementation of [StartsWith<Prefix>], in particular, if Prefix is str, then the prefix is matched against the first component of self, regardless of whether the string contains path delimiters (i.e. ::).

See the [StartsWith] trait for more details.

pub fn strip_prefix<'a>(&'a self, prefix: &Path) -> Option<&'a Path>

Strips prefix from self, or returns None if self does not start with prefix.

NOTE: Prefixes must be exact, i.e. if you call path.strip_prefix(prefix) and path is relative but prefix is absolute, then this will return None. The same is true if path is absolute and prefix is relative.

pub fn join<P>(&self, other: &P) -> PathBuf

where Path: Join<P>, P: ?Sized,

Create an owned [PathBuf] with path adjoined to self.

If path is absolute, it replaces the current path.

The semantics of how other is joined to self in the resulting path depends on the implementation of [Join] used. The implementation for Path and [PathBuf] joins all components of other to self; while the implementation for [prim@str], string-like values, and identifiers/symbols joins just a single component. You must be careful to ensure that if you are passing a string here, that you specifically want to join it as a single component, or the resulting path may be different than you expect. It is recommended that you use Path::new(&string)` if you want to be explicit about treating a string-like value as a multi-component path.

pub fn canonicalize(&self) -> Result<PathBuf, PathError>

Canonicalize this path by ensuring that all components are in canonical form.

Canonical form dictates that:

• A component is quoted only if it requires quoting, and unquoted otherwise
• Is made absolute if relative and the first component is $kernel or $exec

Returns Err if the path is invalid

Trait Implementations

impl AsRef<Path> for Path

fn as_ref(&self) -> &Path

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

impl AsRef<Path> for str

fn as_ref(&self) -> &Path

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

impl AsRef<str> for Path

fn as_ref(&self) -> &str

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

impl Debug for Path

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for &'de Path

Available on crate feature serde only.

fn deserialize<D>( deserializer: D, ) -> Result<&'de Path, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Path

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

Formats the value using the given formatter.

impl Hash for Path

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

where __H: Hasher,

Feeds this value into the given Hasher.

impl Join<Arc<str>> for Path

fn join(&self, other: &Arc<str>) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<Box<str>> for Path

fn join(&self, other: &Box<str>) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<Ident> for Path

fn join(&self, other: &Ident) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<Path> for Path

fn join(&self, other: &Path) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<PathBuf> for Path

fn join(&self, other: &PathBuf) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<ProcedureName> for Path

fn join(&self, other: &ProcedureName) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<QualifiedProcedureName> for Path

fn join(&self, other: &QualifiedProcedureName) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<String> for Path

fn join(&self, other: &String) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Join<str> for Path

fn join(&self, other: &str) -> PathBuf

Joins other to self, producing a new [PathBuf] containing the joined path.

impl Ord for Path

fn cmp(&self, other: &Path) -> Ordering

This method returns an Ordering between self and other.

impl PartialEq<&Path> for Path

fn eq(&self, other: &&Path) -> 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 PartialEq<&PathBuf> for Path

fn eq(&self, other: &&PathBuf) -> 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 PartialEq<Arc<Path>> for Path

fn eq(&self, other: &Arc<Path>) -> 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 PartialEq<Box<Path>> for Path

fn eq(&self, other: &Box<Path>) -> 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 PartialEq<Cow<'_, Path>> for Path

fn eq(&self, other: &Cow<'_, Path>) -> 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 PartialEq<PathBuf> for Path

fn eq(&self, other: &PathBuf) -> 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 PartialEq<Rc<Path>> for Path

fn eq(&self, other: &Rc<Path>) -> 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 PartialEq<str> for Path

fn eq(&self, other: &str) -> 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 PartialEq for Path

fn eq(&self, other: &Path) -> 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 PartialOrd for Path

fn partial_cmp(&self, other: &Path) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serializable for Path

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Serialize for Path

Available on crate feature serde only.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StartsWith<Path> for Path

fn starts_with(&self, prefix: &Path) -> bool

Returns true if the current path, sans root component, starts with prefix

fn starts_with_exactly(&self, prefix: &Path) -> bool

Returns true if the current path, including root component, starts with prefix

impl StartsWith<str> for Path

fn starts_with(&self, prefix: &str) -> bool

Returns true if the current path, sans root component, starts with prefix

fn starts_with_exactly(&self, prefix: &str) -> bool

Returns true if the current path, including root component, starts with prefix

impl ToOwned for Path

type Owned = PathBuf

The resulting type after obtaining ownership.

fn to_owned(&self) -> PathBuf

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut <Path as ToOwned>::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl Eq for Path

impl StructuralPartialEq for Path