Enum guppy::platform::PlatformSpec

#[non_exhaustive]
pub enum PlatformSpec {
    Always,
    Platform(Arc<Platform>),
    Any,
}

A specifier for a single platform, or for a range of platforms.

Some uses of guppy care about a single platform, and others care about queries against the intersection of all hypothetical platforms, or against a union of any of them. PlatformSpec handles the

PlatformSpec does not currently support expressions, but it might in the future, using an SMT solver.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Always

The intersection of all platforms.

Dependency queries performed against this variant will return EnabledTernary::Enabled if and only if a dependency is not platform-dependent. They can never return EnabledTernary::Unknown.

This variant does not currently understand expressions that always evaluate to true (tautologies), like cfg(any(unix, not(unix))) or cfg(all()). In the future, an SMT solver would be able to handle such expressions.

Platform(Arc<Platform>)

An individual platform.

Dependency queries performed against this variant will return EnabledTernary::Enabled if and only if a dependency is enabled on this platform. They may also return EnabledTernary::Unknown if a platform is not enabled.

Any

The union of all platforms.

Dependency queries performed against this variant will return EnabledTernary::Enabled if a dependency is enabled on any platform.

This variant does not currently understand expressions that always evaluate to false (contradictions), like cfg(all(unix, not(unix))) or cfg(any()). In the future, an SMT solver would be able to handle such expressions.

Implementations

impl PlatformSpec

pub fn current() -> Result<Self, TargetSpecError>

Returns a PlatformSpec corresponding to the current platform, as detected at build time.

Returns an error if the current platform was unknown to the version of target-spec in use.

impl PlatformSpec

Helpers for property testing

The methods in this section allow a PlatformSpec to be used in property-based testing scenarios.

Currently, proptest 1 is supported if the proptest1 feature is enabled.

pub fn strategy( platform: impl Strategy<Value = Platform> ) -> impl Strategy<Value = Self>

Available on crate feature proptest1 only.

Returns a Strategy that generates a random PlatformSpec instance.

Trait Implementations

impl Arbitrary for PlatformSpec

Available on crate feature proptest1 only.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<PlatformSpec>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for PlatformSpec

fn clone(&self) -> PlatformSpec

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PlatformSpec

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

Formats the value using the given formatter.

impl<T: Into<Arc<Platform>>> From<T> for PlatformSpec

fn from(platform: T) -> Self

Converts to this type from the input type.