Struct cargo::util::Filesystem

source · [−]

pub struct Filesystem { /* private fields */ }

Expand description

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.

Implementations

source

impl Filesystem

source

pub fn new(path: PathBuf) -> Filesystem

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

source

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.

source

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

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

source

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

source

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

source

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.

source

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

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

source

pub fn open_rw(
 &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.

source

pub fn open_ro(
 &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.