Struct Conflicts 

pub struct Conflicts(/* private fields */);

A list of conflicting sets of extras/groups pre-defined by an end user.

This is useful to force the resolver to fork according to extras that have unavoidable conflicts with each other. (The alternative is that resolution will fail.)

Implementations

impl Conflicts

pub fn empty() -> Self

Returns no conflicts.

This results in no effect on resolution.

pub fn push(&mut self, set: ConflictSet)

Push a single set of conflicts.

pub fn iter(&self) -> impl Iterator<Item = &ConflictSet> + Clone + '_

Returns an iterator over all sets of conflicting sets.

pub fn contains<'a>( &self, package: &PackageName, kind: impl Into<ConflictKindRef<'a>>, ) -> bool

Returns true if these conflicts contain any set that contains the given package and extra name pair.

pub fn is_empty(&self) -> bool

Returns true if there are no conflicts.

pub fn append(&mut self, other: &mut Self)

Appends the given conflicts to this one. This drains all sets from the conflicts given, such that after this call, it is empty.

pub fn expand_transitive_group_includes( &mut self, package: &PackageName, groups: &DependencyGroups, )

Expand Conflictss to include all ConflictSets that can be transitively inferred from group conflicts directly defined in configuration.

A directed acyclic graph (DAG) is created representing all transitive group includes, with nodes corresponding to group conflict items. For every conflict item directly mentioned in configuration, its node starts with a set of canonical items with itself as the only member.

The graph is traversed one node at a time in topological order and canonical items are propagated to each neighbor. We also update our substitutions at each neighbor to reflect that this neighbor transitively includes all canonical items visited so far to reach it.

Finally, we apply the substitutions to the conflict sets that were directly defined in configuration to generate all transitively inferable ConflictSets.

There is an assumption that inclusion graphs will not be very large or complex. This algorithm creates all combinations of substitutions. Each resulting ConflictSet would also later correspond to a separate resolver fork during resolution.

Trait Implementations

impl Clone for Conflicts

fn clone(&self) -> Conflicts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Conflicts

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

Formats the value using the given formatter.

impl Default for Conflicts

fn default() -> Conflicts

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Conflicts

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Conflicts

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

impl StructuralPartialEq for Conflicts