Struct cargo::util::Filesystem

pub struct Filesystem {
    root: PathBuf,
}

A “filesystem” is intended to be a globally shared, hence locked, resource in Cargo.

The Path of a filesystem cannot be learned unless it’s done in a locked fashion, and otherwise functions on this structure are prepared to handle concurrent invocations across multiple instances of Cargo.

Fields

root: PathBuf

Implementations

impl Filesystem

pub fn new(path: PathBuf) -> Filesystem

Creates a new filesystem to be rooted at the given path.

pub fn join<T: AsRef<Path>>(&self, other: T) -> Filesystem

Like Path::join, creates a new filesystem rooted at this filesystem joined with the given path.

pub fn push<T: AsRef<Path>>(&mut self, other: T)

Like Path::push, pushes a new path component onto this filesystem.

pub fn into_path_unlocked(self) -> PathBuf

Consumes this filesystem and returns the underlying PathBuf.

Note that this is a relatively dangerous operation and should be used with great caution!.

pub fn as_path_unlocked(&self) -> &Path

Returns the underlying Path.

Note that this is a relatively dangerous operation and should be used with great caution!.

pub fn create_dir(&self) -> CargoResult<()>

Creates the directory pointed to by this filesystem.

Handles errors where other Cargo processes are also attempting to concurrently create this directory.

pub fn display(&self) -> Display<'_>

Returns an adaptor that can be used to print the path of this filesystem.

pub fn open_rw<P>( &self, path: P, config: &Config, msg: &str ) -> CargoResult<FileLock>where P: AsRef<Path>,

Opens exclusive access to a file, returning the locked version of a file.

This function will create a file at path if it doesn’t already exist (including intermediate directories), and then it will acquire an exclusive lock on path. If the process must block waiting for the lock, the msg is printed to config.

The returned file can be accessed to look at the path and also has read/write access to the underlying file.

pub fn open_ro<P>( &self, path: P, config: &Config, msg: &str ) -> CargoResult<FileLock>where P: AsRef<Path>,

Opens shared access to a file, returning the locked version of a file.

This function will fail if path doesn’t already exist, but if it does then it will acquire a shared lock on path. If the process must block waiting for the lock, the msg is printed to config.

The returned file can be accessed to look at the path and also has read access to the underlying file. Any writes to the file will return an error.

fn open( &self, path: &Path, opts: &OpenOptions, state: State, config: &Config, msg: &str ) -> CargoResult<FileLock>

Trait Implementations

impl Clone for Filesystem

fn clone(&self) -> Filesystem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Filesystem

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

Formats the value using the given formatter.

impl PartialEq<Filesystem> for Path

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

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

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes