Enum guppy::platform::PlatformSpecSummary

pub enum PlatformSpecSummary {
    Always,
    Platform(PlatformSummary),
    Any,
}

Available on crate feature summaries only.

A serializable version of PlatformSpec.

Requires the summaries feature to be enabled.

Variants

Always

The intersection of all platforms.

This is converted to and from PlatformSpec::Always, and is expressed as the string "always", or as spec = "always".

Examples

Deserialize the string "always".

let spec: PlatformSpecSummary = serde_json::from_str(r#""always""#).unwrap();
assert_eq!(spec, PlatformSpecSummary::Always);

Deserialize spec = "always".

let spec: PlatformSpecSummary = toml::from_str(r#"spec = "always""#).unwrap();
assert_eq!(spec, PlatformSpecSummary::Always);

Platform(PlatformSummary)

An individual platform.

This is converted to and from PlatformSpec::Platform, and is serialized as the platform itself (either a triple string, or a map such as { triple = "x86_64-unknown-linux-gnu", target-features = [] }).

Examples

Deserialize a target triple.

let spec: PlatformSpecSummary = serde_json::from_str(r#""x86_64-unknown-linux-gnu""#).unwrap();
assert_eq!(
    spec,
    PlatformSpecSummary::Platform(PlatformSummary::new("x86_64-unknown-linux-gnu")),
);

Deserialize a target map.

let spec: PlatformSpecSummary = toml::from_str(r#"
triple = "x86_64-unknown-linux-gnu"
target-features = []
flags = []
"#).unwrap();
assert_eq!(
    spec,
    PlatformSpecSummary::Platform(
        PlatformSummary::new("x86_64-unknown-linux-gnu")
            .with_target_features(TargetFeaturesSummary::Features(BTreeSet::new()))
    )
);

Any

The union of all platforms.

This is converted to and from PlatformSpec::Any, and is serialized as the string "any".

This is also the default, since in many cases one desires to compute the union of enabled dependencies across all platforms.

Examples

Deserialize the string "any".

let spec: PlatformSpecSummary = serde_json::from_str(r#""any""#).unwrap();
assert_eq!(spec, PlatformSpecSummary::Any);

Deserialize spec = "any".

let spec: PlatformSpecSummary = toml::from_str(r#"spec = "any""#).unwrap();
assert_eq!(spec, PlatformSpecSummary::Any);

Implementations

impl PlatformSpecSummary

pub fn new(platform_spec: &PlatformSpec) -> Self

Creates a new PlatformSpecSummary from a PlatformSpec.

pub fn to_platform_spec(&self) -> Result<PlatformSpec, TargetSpecError>

Converts self to a PlatformSpec.

Returns an Error if the platform was unknown.

pub fn is_any(&self) -> bool

Returns true if self is PlatformSpecSummary::Any.

Trait Implementations

impl Clone for PlatformSpecSummary

fn clone(&self) -> PlatformSpecSummary

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PlatformSpecSummary

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

Formats the value using the given formatter.

impl Default for PlatformSpecSummary

fn default() -> PlatformSpecSummary

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PlatformSpecSummary

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PlatformSpecSummary

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

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

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.

impl Serialize for PlatformSpecSummary

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PlatformSpecSummary

impl StructuralPartialEq for PlatformSpecSummary