Enum Target

pub enum Target<String = String> {
    Triple {
        arch: String,
        vendor: String,
        os: String,
        env: Option<String>,
    },
    Cfg(Cfg<String>),
}

Variants

Triple

Fields

arch: String

vendor: String

os: String

env: Option<String>

Cfg(Cfg<String>)

Implementations

impl<String: AsRef<str>> Target<String>

pub fn eval<'cfg, GetterCallback>(&'cfg self, getter: GetterCallback) -> bool

where GetterCallback: Fn(&'cfg str, &'cfg str) -> Option<&'cfg str>,

Check if the target matches keys returned by the getter.

The getter takes a key, and a hint of the value that it’s being compared against (to handle feature = "value"). Value given to the callback will be "" for existence checks (like cfg(unix)).

The callback returns Some with the key’s actual value if it’s set, or None if the key is not set. For booleans equal true return Some("").

NB: don’t use move closures for the callback, because these aren’t allowed to return data they own. Use closures temporarily borrowing the data from their outer scope.

Targets check for target_arch, target_vendor, target_os, and target_env separately.

See rustc --print=cfg for list of values to set to emulate proper environment, and rustup target list for list of valid target triples.

impl Target<String>

pub fn parse(target_triple_or_cfg: &str) -> Result<Self, ParseError>

Parse a target triple or a cfg(…) expression.

Supports values that are valid in Cargo’s [target.<this expression>.dependencies].

Parses into owned Strings.

impl<'input> Target<&'input str>

pub fn parse_ref(target_triple_or_cfg: &'input str) -> Result<Self, ParseError>

Parse a target triple or a cfg(…) expression.

Supports values that are valid in Cargo’s [target.<this expression>.dependencies].

Parses into temporarily borrowed &strs.

impl<'input, String: From<&'input str>> Target<String>

pub fn parse_generic( target_triple_or_cfg: &'input str, ) -> Result<Self, ParseError>

Parse a target triple or a cfg(…) expression.

Supports values that are valid in Cargo’s [target.<this expression>.dependencies].

Parses into any string-like type

Trait Implementations

impl<String: Clone> Clone for Target<String>

fn clone(&self) -> Target<String>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<String: AsRef<str>> Debug for Target<String>

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

Formats the value using the given formatter.

impl<String: AsRef<str>> Display for Target<String>

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

Formats the value using the given formatter.

impl FromStr for Target<String>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(cfg_str: &str) -> Result<Target<String>, Self::Err>

Parses a string s to return a value of this type.

impl<String: Hash> Hash for Target<String>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<String: PartialEq> PartialEq for Target<String>

fn eq(&self, other: &Target<String>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<String: Eq> Eq for Target<String>

impl<String> StructuralPartialEq for Target<String>