Struct cargo::core::compiler::Unit

pub struct Unit<'a> {
    pub pkg: &'a Package,
    pub target: &'a Target,
    pub profile: Profile,
    pub kind: Kind,
    pub mode: CompileMode,
}

All information needed to define a Unit.

A unit is an object that has enough information so that cargo knows how to build it. For example, if your package has dependencies, then every dependency will be built as a library unit. If your package is a library, then it will be built as a library unit as well, or if it is a binary with main.rs, then a binary will be output. There are also separate unit types for testing and checking, amongst others.

The unit also holds information about all possible metadata about the package in pkg.

A unit needs to know extra information in addition to the type and root source file. For example, it needs to know the target architecture (OS, chip arch etc.) and it needs to know whether you want a debug or release build. There is enough information in this struct to figure all that out.

Fields

pkg: &'a Package

Information about available targets, which files to include/exclude, etc. Basically stuff in Cargo.toml.

target: &'a Target

Information about the specific target to build, out of the possible targets in pkg. Not to be confused with target-triple (or target architecture ...), the target arch for a build.

profile: Profile

The profile contains information about how the build should be run, including debug level, etc.

kind: Kind

Whether this compilation unit is for the host or target architecture.

For example, when cross compiling and using a custom build script, the build script needs to be compiled for the host architecture so the host rustc can use it (when compiling to the target architecture).

mode: CompileMode

The "mode" this unit is being compiled for. See CompileMode for more details.

Methods

impl<'a> Unit<'a>

pub fn buildkey(&self) -> String

Trait Implementations

impl<'a> PartialOrd<Unit<'a>> for Unit<'a>

fn partial_cmp(&self, other: &Unit<'a>) -> Option<Ordering>

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

fn lt(&self, other: &Unit<'a>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Unit<'a>) -> bool

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

fn gt(&self, other: &Unit<'a>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Unit<'a>) -> bool

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

impl<'a> Copy for Unit<'a>

impl<'a> PartialEq<Unit<'a>> for Unit<'a>

fn eq(&self, other: &Unit<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Unit<'a>) -> bool

This method tests for !=.

impl<'a> Clone for Unit<'a>

fn clone(&self) -> Unit<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Ord for Unit<'a>

fn cmp(&self, other: &Unit<'a>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<'a> Eq for Unit<'a>

impl<'a> Debug for Unit<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Unit<'a>

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

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].