Package org.eclipse.aether.util.graph.transformer

Class ConflictResolver.State

java.lang.Object

org.eclipse.aether.util.graph.transformer.ConflictResolver.State

Enclosing class:

ConflictResolver

final class ConflictResolver.State
extends Object

Field Summary

Fields

Modifier and Type	Field	Description
(package private) final ConflictResolver.ConflictContext	conflictCtx	The conflict context passed to the version/scope/optionality selectors, updated as we move along rather than recreated to avoid tmp objects.
(package private) final Map<?,?>	conflictIds	The output from the conflict marker
(package private) Object	currentId	The conflict id currently processed.
(package private) final Map<List<DependencyNode>,ConflictResolver.NodeInfo>	infos	The (conceptual) mapping from nodes to extra infos, technically keyed by the node's child list which better captures the identity of a node since we're basically concerned with effects towards children.
(package private) final List<ConflictResolver.ConflictItem>	items	The conflict items we have gathered so far for the current conflict id.
(package private) final ConflictResolver.OptionalitySelector	optionalitySelector	The effective optionality selector, i.e.
(package private) final List<ConflictResolver.NodeInfo>	parentInfos	The stack of node infos for parent nodes, may contain null which is used to disable creating new conflict items when visiting their parent again (conflict items are meant to be unique by parent-node combo).
(package private) final List<DependencyNode>	parentNodes	The stack of parent nodes.
(package private) final List<Boolean>	parentOptionals	The stack of derived optional flags for parent nodes.
(package private) final List<String>	parentScopes	The stack of derived scopes for parent nodes.
(package private) final Collection<Object>	potentialAncestorIds	The set of conflict ids which could apply to ancestors of nodes with the current conflict id, used to avoid recursion early on.
(package private) final Map<Object,DependencyNode>	resolvedIds	A mapping from conflict id to winner node, helps to recognize nodes that have their effective scopeinvalid input: '&optionality' set or are leftovers from previous removals.
(package private) final ConflictResolver.ScopeContext	scopeCtx	The scope context passed to the scope deriver, updated as we move along rather than recreated to avoid tmp objects.
(package private) final ConflictResolver.ScopeDeriver	scopeDeriver	The effective scope deriver, i.e.
(package private) final ConflictResolver.ScopeSelector	scopeSelector	The effective scope selector, i.e.
(package private) final Map<List<DependencyNode>,Object>	stack	The set of nodes on the DFS stack to detect cycles, technically keyed by the node's child list to match the dirty graph structure produced by the dependency collector for cycles.
(package private) int	totalConflictItems	Stats counter.
(package private) final ConflictResolver.Verbosity	verbosity	Flag whether we should keep losers in the graph to enable visualization/troubleshooting of conflicts.
(package private) final ConflictResolver.VersionSelector	versionSelector	The effective version selector, i.e.

Constructor Summary

Constructors

Constructor	Description
State(DependencyNode root, Map<?,?> conflictIds, int conflictIdCount, DependencyGraphTransformationContext context)

Method Summary

Modifier and Type	Method	Description
(package private) void	add(DependencyNode node)
private int	depth()
private boolean	deriveOptional(DependencyNode node, Object conflictId)
private String	deriveScope(DependencyNode node, Object conflictId)
(package private) void	finish()
(package private) boolean	loser(DependencyNode node, Object conflictId)
private ConflictResolver.ConflictItem	newConflictItem(DependencyNode parent, DependencyNode node)
private DependencyNode	parent()
(package private) void	pop()
(package private) void	prepare(Object conflictId, Collection<Object> cyclicPredecessors)
(package private) boolean	push(DependencyNode node, Object conflictId)
private String	scope(Dependency dependency)
private void	scopes(int parent, Dependency child)
(package private) void	winner()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

currentId

Object currentId

The conflict id currently processed.

totalConflictItems

int totalConflictItems

Stats counter.

verbosity

final ConflictResolver.Verbosity verbosity

Flag whether we should keep losers in the graph to enable visualization/troubleshooting of conflicts.

resolvedIds

final Map<Object,DependencyNode> resolvedIds

A mapping from conflict id to winner node, helps to recognize nodes that have their effective scopeinvalid input: '&optionality' set or are leftovers from previous removals.

potentialAncestorIds

final Collection<Object> potentialAncestorIds

The set of conflict ids which could apply to ancestors of nodes with the current conflict id, used to avoid recursion early on. This is basically a superset of the key set of resolvedIds, the additional ids account for cyclic dependencies.

conflictIds

final Map<?,?> conflictIds

The output from the conflict marker

items

final List<ConflictResolver.ConflictItem> items

The conflict items we have gathered so far for the current conflict id.

infos

final Map<List<DependencyNode>,ConflictResolver.NodeInfo> infos

The (conceptual) mapping from nodes to extra infos, technically keyed by the node's child list which better captures the identity of a node since we're basically concerned with effects towards children.

stack

final Map<List<DependencyNode>,Object> stack

The set of nodes on the DFS stack to detect cycles, technically keyed by the node's child list to match the dirty graph structure produced by the dependency collector for cycles.

parentNodes

final List<DependencyNode> parentNodes

The stack of parent nodes.

parentScopes

final List<String> parentScopes

The stack of derived scopes for parent nodes.

parentOptionals

final List<Boolean> parentOptionals

The stack of derived optional flags for parent nodes.

parentInfos

final List<ConflictResolver.NodeInfo> parentInfos

The stack of node infos for parent nodes, may contain null which is used to disable creating new conflict items when visiting their parent again (conflict items are meant to be unique by parent-node combo).

conflictCtx

final ConflictResolver.ConflictContext conflictCtx

The conflict context passed to the version/scope/optionality selectors, updated as we move along rather than recreated to avoid tmp objects.

scopeCtx

final ConflictResolver.ScopeContext scopeCtx

The scope context passed to the scope deriver, updated as we move along rather than recreated to avoid tmp objects.

versionSelector

final ConflictResolver.VersionSelector versionSelector

The effective version selector, i.e. after initialization.

scopeSelector

final ConflictResolver.ScopeSelector scopeSelector

The effective scope selector, i.e. after initialization.

scopeDeriver

final ConflictResolver.ScopeDeriver scopeDeriver

The effective scope deriver, i.e. after initialization.

optionalitySelector

final ConflictResolver.OptionalitySelector optionalitySelector

The effective optionality selector, i.e. after initialization.

Constructor Details

State

State(DependencyNode root,
 Map<?,?> conflictIds,
 int conflictIdCount,
 DependencyGraphTransformationContext context)
throws RepositoryException

Throws:

RepositoryException

Method Details

prepare

void prepare(Object conflictId,
 Collection<Object> cyclicPredecessors)

finish

void finish()

winner

void winner()

loser

boolean loser(DependencyNode node,
 Object conflictId)

push

boolean push(DependencyNode node,
 Object conflictId)
      throws RepositoryException

Throws:

RepositoryException

pop

void pop()

add

void add(DependencyNode node)
  throws RepositoryException

Throws:

RepositoryException

newConflictItem

private ConflictResolver.ConflictItem newConflictItem(DependencyNode parent,
 DependencyNode node)
                                               throws RepositoryException

Throws:

RepositoryException

depth

private int depth()

parent

private DependencyNode parent()

deriveScope

private String deriveScope(DependencyNode node,
 Object conflictId)
                    throws RepositoryException

Throws:

RepositoryException

scopes

private void scopes(int parent,
 Dependency child)

scope

private String scope(Dependency dependency)

deriveOptional

private boolean deriveOptional(DependencyNode node,
 Object conflictId)