# Struct cargo::core::compiler::CompileTarget

source ·

    pub struct CompileTarget {
        name: InternedString,
    }

Expand description

Abstraction for the representation of a compilation target that Cargo has.

Compilation targets are one of two things right now:

1. A raw target string, like `x86_64-unknown-linux-gnu`.
2. The path to a JSON file, such as `/path/to/my-target.json`.

Raw target strings are typically dictated by `rustc` itself and represent built-in targets. Custom JSON files are somewhat unstable, but supported here in Cargo. Note that for JSON target files this `CompileTarget` stores a full canonicalized path to the target.

The main reason for this existence is to handle JSON target files where when we call rustc we pass full paths but when we use it for Cargo’s purposes like naming directories or looking up configuration keys we only check the file stem of JSON target files. For built-in rustc targets this is just an uninterpreted string basically.

## Fields§

§`name: InternedString`

## Implementations§

source§

### impl CompileTarget

source

#### pub fn new(name: &str) -> CargoResult<CompileTarget>

source

#### pub fn rustc_target(&self) -> InternedString

Returns the full unqualified name of this target, suitable for passing to `rustc` directly.

Typically this is pretty much the same as `short_name`, but for the case of JSON target files this will be a full canonicalized path name for the current filesystem.

source

#### pub fn short_name(&self) -> &str

Returns a “short” version of the target name suitable for usage within Cargo for configuration and such.

This is typically the same as `rustc_target`, or the full name, but for JSON target files this returns just the file stem (e.g. `foo` out of `foo.json`) instead of the full path.

source

#### pub fn fingerprint_hash(&self) -> u64

See `CompileKind::fingerprint_hash`.

## Trait Implementations§

source§

### impl Clone for CompileTarget

source§

#### fn clone(&self) -> CompileTarget

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl Debug for CompileTarget

source§

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

Formats the value using the given formatter. Read more
source§

### impl Hash for CompileTarget

source§

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

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl Ord for CompileTarget

source§

#### fn cmp(&self, other: &CompileTarget) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more
source§

### impl PartialEq<CompileTarget> for CompileTarget

source§

#### fn eq(&self, other: &CompileTarget) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · source§

#### 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.
source§

### impl PartialOrd<CompileTarget> for CompileTarget

source§

#### fn partial_cmp(&self, other: &CompileTarget) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · source§

#### fn lt(&self, other: &Rhs) -> bool

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · source§

#### fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · source§

#### fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · source§

#### fn ge(&self, other: &Rhs) -> bool

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

### impl Serialize for CompileTarget

source§

#### fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

### impl Copy for CompileTarget

source§

### impl Eq for CompileTarget

source§

### impl StructuralEq for CompileTarget

source§

### impl StructuralPartialEq for CompileTarget

## Auto Trait Implementations§

§

### impl RefUnwindSafe for CompileTarget

§

### impl Send for CompileTarget

§

### impl Sync for CompileTarget

§

### impl Unpin for CompileTarget

§

### impl UnwindSafe for CompileTarget

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§

#### fn equivalent(&self, key: &K) -> bool

Compare self to `key` and return `true` if they are equal.
§

### impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§

#### fn equivalent(&self, key: &K) -> bool

Checks if this value is equivalent to the given key. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> Same<T> for T

§

#### type Output = T

Should always be `Self`
source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

### impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

§

#### fn vzip(self) -> V

## 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:16 bytes