/** * {@inheritDoc} */ public boolean accept( DependencyNode node ) { return node.getState() == state; }
/** * Gets whether the all the ancestors of the dependency node currently being processed by this listener have an * included state. * * @return <code>true</code> if all the ancestors of the current dependency node have a state of * <code>INCLUDED</code> */ private boolean isCurrentNodeIncluded() { for ( DependencyNode node : parentNodes ) { if ( node.getState() != DependencyNode.INCLUDED ) { return false; } } return true; }
/** * Gets whether the all the ancestors of the dependency node currently being processed by this listener have an * included state. * * @return <code>true</code> if all the ancestors of the current dependency node have a state of * <code>INCLUDED</code> */ private boolean isCurrentNodeIncluded() { boolean included = true; for ( Iterator iterator = parentNodes.iterator(); included && iterator.hasNext(); ) { DependencyNode node = ( DependencyNode ) iterator.next(); if ( node.getState() != DependencyNode.INCLUDED ) { included = false; } } return included; }
/** * Changes the state of this dependency node to be omitted for a cycle in the dependency tree. * <p> * Omitting this node sets its state to <code>OMITTED_FOR_CYCLE</code> and removes all of its children. * </p> * * @throws IllegalStateException if this dependency node's state is not <code>INCLUDED</code> * @see #OMITTED_FOR_CYCLE * @since 1.1 */ public void omitForCycle() { if ( getState() != INCLUDED ) { throw new IllegalStateException( "Only INCLUDED dependency nodes can be omitted for cycle" ); } state = OMITTED_FOR_CYCLE; removeAllChildren(); }
@Override public String getHtmlDisplayName() { if (node.getState() == DependencyNode.OMITTED_FOR_DUPLICATE) { return "<html><s>" + getDisplayName() + "</s></html>"; } if (node.getState() == DependencyNode.OMITTED_FOR_CONFLICT) { return "<html><font color=\"!nb.errorForeground\"><s>" + getDisplayName() + "</s></font></html>"; } return super.getHtmlDisplayName(); //To change body of generated methods, choose Tools | Templates. }
@Override public boolean visit(DependencyNode node) { if (root == null) { root = node; lst = new ArrayList<DependencyNode>(); } for (DependencyNode ch : node.getChildren()) { if (ch.getState() == DependencyNode.INCLUDED && scopes.contains(ch.getArtifact().getScope())) { lst.add(ch); } } return true; }
protected static DependencyNode getNode(DependencyNode rootNode, String requiredKey, boolean verbose) { for (Iterator<?> itr = rootNode.preorderIterator(); itr.hasNext();) { DependencyNode d = (DependencyNode) itr.next(); Artifact artifact = d.getArtifact(); String key = getArtifactId(artifact); if (log.isDebugEnabled()) { log.debug("key : " + key); } if (requiredKey.equals(key) && d.getState() == DependencyNode.INCLUDED) { return d; } } return null; }
protected static void setNodes(DependencyNode rootNode, Map<String, ArtifactDependencyEntry> dico, Set<String> universe, boolean verbose) { for (Iterator<?> itr = rootNode.preorderIterator(); itr.hasNext();) { DependencyNode d = (DependencyNode) itr.next(); Artifact artifact = d.getArtifact(); String key = getArtifactId(artifact); if (log.isDebugEnabled()) { log.debug("key : " + key); } if (universe.contains(key) && d.getState() == DependencyNode.INCLUDED) { ArtifactDependencyEntry entry = dico.get(key); entry.node = d; // if (d == null) { // // ce cas ne devrait jamais arrive // throw new IllegalStateException( // "on a pas trouve le node pour l'artifact " + // artifact); // } if (log.isDebugEnabled()) { log.debug("detected node : " + d); } } } }
private void collect(final DependencyNode root, final Set<Artifact> artifacts) { Stack<DependencyNode> stack = new Stack<DependencyNode>(); stack.push(root); while (!stack.isEmpty()) { DependencyNode node = stack.pop(); if (node.getState() == DependencyNode.INCLUDED) { final Artifact artifact = node.getArtifact(); if (includedScope(artifact.getScope())) { getLog().info("Adding Artefact: " + artifact.toString()); artifacts.add(artifact); // check children if (!node.getChildren().isEmpty()) { stack.addAll(node.getChildren()); } } } } }
if (d.getState() != DependencyNode.INCLUDED) {
@NbBundle.Messages({ "TIP_Included=Is included", "TIP_Conflict=Is omitted for conflict, version used is {0}", "TIP_Duplicate=Is omitted for duplicate with the same version", "TIP_Cycle=Is omitted for cycle" }) private static String calculateStateTipPart(DependencyNode node) { int s = node.getState(); if (s == DependencyNode.INCLUDED) { return Bundle.TIP_Included(); } else if (s == DependencyNode.OMITTED_FOR_CONFLICT) { return Bundle.TIP_Conflict(node.getRelatedArtifact().getVersion()); } else if (s == DependencyNode.OMITTED_FOR_DUPLICATE) { return Bundle.TIP_Duplicate(); } else if (s == DependencyNode.OMITTED_FOR_CYCLE) { return Bundle.TIP_Cycle(); } throw new IllegalStateException("illegal state:" + s); }
if ( n3.getState() == org.apache.maven.shared.dependency.tree.DependencyNode.INCLUDED )
if ( depNode.getState() == DependencyNode.INCLUDED )
if ( getState() != INCLUDED )
if (node.getState() == DependencyNode.INCLUDED && ! treeRoot.equals(node)){ Artifact artifact = node.getArtifact(); if (artifact != null){
List<ITypeLoader> deps = new ArrayList<>(); for (DependencyNode dependencyNode : nodes) { int state = dependencyNode.getState();
for ( org.apache.maven.shared.dependency.tree.DependencyNode child : node.getChildren() ) if ( child.getState() != org.apache.maven.shared.dependency.tree.DependencyNode.INCLUDED )
/** * {@inheritDoc} */ public boolean visit( DependencyNode node ) { // clone the node DependencyNode newNode = new DependencyNode( node.getArtifact(), node.getState(), node.getRelatedArtifact() ); newNode.setOriginalScope( node.getOriginalScope() ); newNode.setFailedUpdateScope( node.getFailedUpdateScope() ); newNode.setPremanagedVersion( node.getPremanagedVersion() ); newNode.setPremanagedScope( node.getPremanagedScope() ); if ( parentNodes.empty() ) { rootNode = newNode; } else { DependencyNode parentNode = parentNodes.peek(); parentNode.addChild( newNode ); } parentNodes.push( newNode ); return true; }
/** * {@inheritDoc} */ public int hashCode() { // TODO: probably better using commons-lang HashCodeBuilder int hashCode = 1; hashCode = hashCode * HASH_PRIME + getArtifact().hashCode(); // DefaultArtifact.hashCode does not consider scope hashCode = hashCode * HASH_PRIME + nullHashCode( getArtifact().getScope() ); // TODO: use parent's artifact to prevent recursion - how can we improve this? hashCode = hashCode * HASH_PRIME + nullHashCode( nullGetArtifact( getParent() ) ); hashCode = hashCode * HASH_PRIME + getChildren().hashCode(); hashCode = hashCode * HASH_PRIME + getState(); hashCode = hashCode * HASH_PRIME + nullHashCode( getRelatedArtifact() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getPremanagedVersion() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getPremanagedScope() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getOriginalScope() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getFailedUpdateScope() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getVersionSelectedFromRange() ); hashCode = hashCode * HASH_PRIME + nullHashCode( getAvailableVersions() ); return hashCode; }
@Override public boolean equals( Object object ) { // TODO: probably better using commons-lang EqualsBuilder boolean equal; if ( object instanceof DependencyNode ) { DependencyNode node = (DependencyNode) object; equal = getArtifact().equals( node.getArtifact() ); // DefaultArtifact.hashCode does not consider scope equal &= nullEquals( getArtifact().getScope(), node.getArtifact().getScope() ); // TODO: use parent's artifact to prevent recursion - how can we improve this? equal &= nullEquals( nullGetArtifact( getParent() ), nullGetArtifact( node.getParent() ) ); equal &= getChildren().equals( node.getChildren() ); equal &= getState() == node.getState(); equal &= nullEquals( getRelatedArtifact(), node.getRelatedArtifact() ); equal &= nullEquals( getPremanagedVersion(), node.getPremanagedVersion() ); equal &= nullEquals( getPremanagedScope(), node.getPremanagedScope() ); equal &= nullEquals( getOriginalScope(), node.getOriginalScope() ); equal &= nullEquals( getFailedUpdateScope(), node.getFailedUpdateScope() ); equal &= nullEquals( getVersionSelectedFromRange(), node.getVersionSelectedFromRange() ); equal &= nullEquals( getAvailableVersions(), node.getAvailableVersions() ); } else { equal = false; } return equal; }