Struct SolverTask 

pub struct SolverTask<TAvailablePackagesIterator> {
    pub available_packages: TAvailablePackagesIterator,
    pub locked_packages: Vec<RepoDataRecord>,
    pub pinned_packages: Vec<RepoDataRecord>,
    pub virtual_packages: Vec<GenericVirtualPackage>,
    pub specs: Vec<MatchSpec>,
    pub constraints: Vec<MatchSpec>,
    pub timeout: Option<Duration>,
    pub channel_priority: ChannelPriority,
    pub exclude_newer: Option<DateTime<Utc>>,
    pub min_age: Option<MinimumAgeConfig>,
    pub strategy: SolveStrategy,
}

Represents a dependency resolution task, to be solved by one of the backends

Fields

available_packages: TAvailablePackagesIterator

An iterator over all available packages

locked_packages: Vec<RepoDataRecord>

Records of packages that are previously selected.

If the solver encounters multiple variants of a single package (identified by its name), it will sort the records and select the best possible version. However, if there exists a locked version it will prefer that variant instead. This is useful to reduce the number of packages that are updated when installing new packages.

Usually you add the currently installed packages or packages from a lock-file here.

pinned_packages: Vec<RepoDataRecord>

Records of packages that are previously selected and CANNOT be changed.

If the solver encounters multiple variants of a single package (identified by its name), it will sort the records and select the best possible version. However, if there is a variant available in the pinned_packages field it will always select that version no matter what even if that means other packages have to be downgraded.

virtual_packages: Vec<GenericVirtualPackage>

Virtual packages considered active

specs: Vec<MatchSpec>

The specs we want to solve

constraints: Vec<MatchSpec>

Additional constraints that should be satisfied by the solver. Packages included in the constraints are not necessarily installed, but they must be satisfied by the solution.

timeout: Option<Duration>

The timeout after which the solver should stop

channel_priority: ChannelPriority

The channel priority to solve with, either ChannelPriority::Strict or ChannelPriority::Disabled

exclude_newer: Option<DateTime<Utc>>

Exclude any package that has a timestamp newer than the specified timestamp.

min_age: Option<MinimumAgeConfig>

Only consider packages that have been published for at least the specified duration.

This helps reduce the risk of installing compromised packages, as malicious releases are typically discovered and removed from channels within a short time window. By requiring a minimum age, you give the community time to identify and report malicious packages.

Some packages can be exempted from this check using the MinimumAgeConfig::exempt_packages field.

strategy: SolveStrategy

The solve strategy.

Trait Implementations

impl<TAvailablePackagesIterator: Clone> Clone for SolverTask<TAvailablePackagesIterator>

fn clone(&self) -> SolverTask<TAvailablePackagesIterator>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TAvailablePackagesIterator: Debug> Debug for SolverTask<TAvailablePackagesIterator>

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

Formats the value using the given formatter.

impl<'r, I: IntoIterator<Item = &'r RepoDataRecord>> FromIterator<I> for SolverTask<Vec<RepoDataIter<I>>>

fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self

Creates a value from an iterator.

impl<TAvailablePackagesIterator: PartialEq> PartialEq for SolverTask<TAvailablePackagesIterator>

fn eq(&self, other: &SolverTask<TAvailablePackagesIterator>) -> 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<TAvailablePackagesIterator: Eq> Eq for SolverTask<TAvailablePackagesIterator>

impl<TAvailablePackagesIterator> StructuralPartialEq for SolverTask<TAvailablePackagesIterator>