Enum Constraint 

pub enum Constraint {
    Dependency {
        package: String,
        version_set: VersionSet,
        dependent: Option<String>,
    },
    Conflict {
        package1: String,
        version1: Version,
        package2: String,
        version2: Version,
    },
    AtMostOne {
        package: String,
        versions: Vec<Version>,
    },
    AtLeastOne {
        package: String,
        versions: Vec<Version>,
    },
    Exactly {
        package: String,
        version: Version,
    },
    Exclude {
        package: String,
        version: Version,
    },
    Implies {
        premise_package: String,
        premise_version: Version,
        conclusion_package: String,
        conclusion_version_set: VersionSet,
    },
    OptionalDependency {
        package: String,
        version_set: VersionSet,
        dependent: Option<String>,
        condition: Option<String>,
    },
    ConditionalDependency {
        package: String,
        version_set: VersionSet,
        dependent: Option<String>,
        condition: String,
    },
}

A statement the SAT encoder must enforce.

All variants are hard constraints (must hold in any solution) unless explicitly described otherwise. Soft preferences (e.g. “prefer newer versions”) are expressed via assumptions on the solver, not via Constraint variants.

Variants

Dependency

dependent (if present) depends on package in a version satisfying version_set. If dependent is None, this is a top-level / root dependency.

Fields

package: String

version_set: VersionSet

dependent: Option<String>

Conflict

package1@version1 and package2@version2 may not both be selected. Two-clause exclusion.

Fields

package1: String

version1: Version

package2: String

version2: Version

AtMostOne

At most one of the listed versions of package may be selected. The standard “one version per package” rule for most ecosystems.

Fields

package: String

versions: Vec<Version>

AtLeastOne

At least one of the listed versions of package must be selected. Used when a dependency edge has multiple satisfying versions and we want the solver to pick some version.

Fields

package: String

versions: Vec<Version>

Exactly

Exactly this version of package must be selected. Used for pinning (e.g. lockfile-frozen installs).

Fields

package: String

version: Version

Exclude

This specific (package, version) pair must not be selected. Used for security advisories and explicit denies.

Fields

package: String

version: Version

Implies

If premise_package@premise_version is selected, then conclusion_package must be selected with a version satisfying conclusion_version_set. The base shape of a dependency edge in CNF.

Fields

premise_package: String

premise_version: Version

conclusion_package: String

conclusion_version_set: VersionSet

OptionalDependency

Like Self::Dependency but marked as not-required: the solver should satisfy it if it can, and skip it without error if it can’t.

Fields

package: String

version_set: VersionSet

dependent: Option<String>

condition: Option<String>

Platform-specific condition (e.g., “os=linux”, “arch=x64”). Interpretation is up to the caller; the SAT encoder treats it as opaque metadata.

ConditionalDependency

Like Self::Dependency but only active when condition is true. Caller is responsible for evaluating condition and either including or omitting this constraint accordingly; the SAT encoder treats it as a regular dependency when present.

Fields

package: String

version_set: VersionSet

dependent: Option<String>

condition: String

Implementations

impl Constraint

pub fn dependency( package: String, version_set: VersionSet, dependent: Option<String>, ) -> Self

Create a dependency constraint.

pub fn optional_dependency( package: String, version_set: VersionSet, dependent: Option<String>, condition: Option<String>, ) -> Self

Create an optional-dependency constraint.

pub fn conditional_dependency( package: String, version_set: VersionSet, dependent: Option<String>, condition: String, ) -> Self

Create a conditional-dependency constraint.

pub fn primary_package(&self) -> Option<&str>

Return the primary package name this constraint references, if there is one canonical answer. For variants with multiple packages (conflicts, workspaces), returns the “subject” package per the variant’s docs.

pub fn is_optional(&self) -> bool

True if this constraint is a soft preference rather than a hard requirement (i.e. it’s allowed to be unsatisfied without flagging UNSAT).

pub fn is_conditional(&self) -> bool

True if this constraint’s activation depends on a caller-evaluated condition.

Trait Implementations

impl Clone for Constraint

fn clone(&self) -> Constraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Constraint

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

Formats the value using the given formatter.