Struct cargo::core::compiler::layout::Layout

pub struct Layout {
    root: PathBuf,
    dest: PathBuf,
    deps: PathBuf,
    build: PathBuf,
    artifact: PathBuf,
    incremental: PathBuf,
    fingerprint: PathBuf,
    examples: PathBuf,
    doc: PathBuf,
    tmp: PathBuf,
    _lock: FileLock,
}

Contains the paths of all target output locations.

See module docs for more information.

Fields

root: PathBuf

The root directory: /path/to/target. If cross compiling: /path/to/target/$TRIPLE.

dest: PathBuf

The final artifact destination: $root/debug (or release).

deps: PathBuf

The directory with rustc artifacts: $dest/deps

build: PathBuf

The directory for build scripts: $dest/build

artifact: PathBuf

The directory for artifacts, i.e. binaries, cdylibs, staticlibs: $dest/deps/artifact

incremental: PathBuf

The directory for incremental files: $dest/incremental

fingerprint: PathBuf

The directory for fingerprints: $dest/.fingerprint

examples: PathBuf

The directory for examples: $dest/examples

doc: PathBuf

The directory for rustdoc output: $root/doc

tmp: PathBuf

The directory for temporary data of integration tests and benches: $dest/tmp

_lock: FileLock

The lockfile for a build (.cargo-lock). Will be unlocked when this struct is dropped.

Implementations

impl Layout

pub fn new( ws: &Workspace<'_>, target: Option<CompileTarget>, dest: &str, ) -> CargoResult<Layout>

Calculate the paths for build output, lock the build directory, and return as a Layout.

This function will block if the directory is already locked.

dest should be the final artifact directory name. Currently either “debug” or “release”.

pub fn prepare(&mut self) -> CargoResult<()>

Makes sure all directories stored in the Layout exist on the filesystem.

pub fn dest(&self) -> &Path

Fetch the destination path for final artifacts (/…/target/debug).

pub fn deps(&self) -> &Path

Fetch the deps path.

pub fn examples(&self) -> &Path

Fetch the examples path.

pub fn doc(&self) -> &Path

Fetch the doc path.

pub fn root(&self) -> &Path

Fetch the root path (/…/target).

pub fn incremental(&self) -> &Path

Fetch the incremental path.

pub fn fingerprint(&self) -> &Path

Fetch the fingerprint path.

pub fn build(&self) -> &Path

Fetch the build script path.

pub fn artifact(&self) -> &Path

Fetch the artifact path.

pub fn prepare_tmp(&self) -> CargoResult<&Path>

Create and return the tmp path.

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: 272 bytes