Struct cargo::util::Filesystem

pub struct Filesystem { /* fields omitted */ }

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.

Methods

impl Filesystem

fn new(path: PathBuf) -> Filesystem

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

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.

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

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

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

fn create_dir(&self) -> Result<()>

Creates the directory pointed to by this filesystem.

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

fn display(&self) -> Display

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

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.

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.

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, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.