You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@ant.apache.org by hi...@apache.org on 2014/12/22 18:37:20 UTC
[4/6] ant-ivy git commit: use java 5 constructs
use java 5 constructs
Project: http://git-wip-us.apache.org/repos/asf/ant-ivy/repo
Commit: http://git-wip-us.apache.org/repos/asf/ant-ivy/commit/6d2e199e
Tree: http://git-wip-us.apache.org/repos/asf/ant-ivy/tree/6d2e199e
Diff: http://git-wip-us.apache.org/repos/asf/ant-ivy/diff/6d2e199e
Branch: refs/heads/master
Commit: 6d2e199e31f8109d21b3865cbc45b34d8b725a03
Parents: ee94e6d
Author: Nicolas Lalevée <ni...@hibnet.org>
Authored: Sun Dec 21 19:56:12 2014 +0100
Committer: Nicolas Lalevée <ni...@hibnet.org>
Committed: Sun Dec 21 23:43:30 2014 +0100
----------------------------------------------------------------------
.../org/apache/ivy/core/resolve/IvyNode.java | 228 +++++++++----------
.../apache/ivy/core/resolve/IvyNodeCallers.java | 71 +++---
.../ivy/core/resolve/IvyNodeEviction.java | 160 ++++++-------
.../apache/ivy/core/resolve/IvyNodeUsage.java | 99 ++++----
.../ivy/util/filter/ArtifactTypeFilter.java | 14 +-
src/java/org/apache/ivy/util/filter/Filter.java | 4 +-
.../apache/ivy/util/filter/FilterHelper.java | 18 +-
.../org/apache/ivy/util/filter/NoFilter.java | 6 +
8 files changed, 290 insertions(+), 310 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/core/resolve/IvyNode.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/core/resolve/IvyNode.java b/src/java/org/apache/ivy/core/resolve/IvyNode.java
index dec51d5..3764c47 100644
--- a/src/java/org/apache/ivy/core/resolve/IvyNode.java
+++ b/src/java/org/apache/ivy/core/resolve/IvyNode.java
@@ -28,6 +28,7 @@ import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.Stack;
import java.util.regex.Matcher;
@@ -59,7 +60,7 @@ import org.apache.ivy.util.StringUtils;
import org.apache.ivy.util.filter.Filter;
import org.apache.ivy.util.filter.FilterHelper;
-public class IvyNode implements Comparable {
+public class IvyNode implements Comparable<IvyNode> {
private static final Pattern FALLBACK_CONF_PATTERN = Pattern.compile("(.+)\\((.*)\\)");
// //////// CONTEXT
@@ -80,8 +81,7 @@ public class IvyNode implements Comparable {
private ModuleRevisionId id;
// set only when node has been built or updated from a DependencyDescriptor
- // Map(IvyNode parent -> DependencyDescriptor)
- private Map dds = new HashMap();
+ private Map<IvyNode, DependencyDescriptor> dds = new HashMap<IvyNode, DependencyDescriptor>();
// Set when data has been loaded only, or when constructed from a module descriptor
private ModuleDescriptor md;
@@ -95,18 +95,18 @@ public class IvyNode implements Comparable {
private boolean searched = false;
- private Collection confsToFetch = new HashSet();
+ private Collection<String> confsToFetch = new HashSet<String>();
- private Collection fetchedConfigurations = new HashSet();
+ private Collection<String> fetchedConfigurations = new HashSet<String>();
- private Collection loadedRootModuleConfs = new HashSet();
+ private Collection<String> loadedRootModuleConfs = new HashSet<String>();
// //////// USAGE DATA
private IvyNodeUsage usage = new IvyNodeUsage(this);
// usage information merged from evicted nodes this node is "replacing"
- private Map/* <ModuleRevisionId, IvyNodeUsage> */mergedUsages = new LinkedHashMap();
+ private Map<ModuleRevisionId, IvyNodeUsage> mergedUsages = new LinkedHashMap<ModuleRevisionId, IvyNodeUsage>();
public IvyNode(ResolveData data, IvyNode parent, DependencyDescriptor dd) {
id = dd.getDependencyRevisionId();
@@ -289,7 +289,8 @@ public class IvyNode implements Comparable {
}
}
- public Collection getDependencies(String rootModuleConf, String[] confs, String requestedConf) {
+ public Collection<IvyNode> getDependencies(String rootModuleConf, String[] confs,
+ String requestedConf) {
if (md == null) {
throw new IllegalStateException(
"impossible to get dependencies when data has not been loaded");
@@ -301,7 +302,7 @@ public class IvyNode implements Comparable {
confs = md.getPublicConfigurationsNames();
}
}
- Collection deps = new HashSet();
+ Collection<IvyNode> deps = new HashSet<IvyNode>();
for (int i = 0; i < confs.length; i++) {
deps.addAll(getDependencies(rootModuleConf, confs[i], requestedConf));
}
@@ -321,15 +322,15 @@ public class IvyNode implements Comparable {
* the actual node conf requested, possibly extending the <code>conf</code> one.
* @return
*/
- public Collection/* <IvyNode> */getDependencies(String rootModuleConf, String conf,
+ public Collection<IvyNode> getDependencies(String rootModuleConf, String conf,
String requestedConf) {
if (md == null) {
throw new IllegalStateException(
"impossible to get dependencies when data has not been loaded");
}
DependencyDescriptor[] dds = md.getDependencies();
- Map/* <ModuleRevisionId, IvyNode> */dependencies = new LinkedHashMap(); // it's important to
- // respect order
+ // it's important to respect order => LinkedHashMap
+ Map<ModuleRevisionId, IvyNode> dependencies = new LinkedHashMap<ModuleRevisionId, IvyNode>();
for (int i = 0; i < dds.length; i++) {
DependencyDescriptor dd = data.mediate(dds[i]);
String[] dependencyConfigurations = dd.getDependencyConfigurations(conf, requestedConf);
@@ -347,7 +348,7 @@ public class IvyNode implements Comparable {
}
// check if not already loaded here
- IvyNode depNode = (IvyNode) dependencies.get(requestedDependencyRevisionId);
+ IvyNode depNode = dependencies.get(requestedDependencyRevisionId);
if (depNode == null) {
// check if not already loaded during the resolve session
depNode = data.getNode(requestedDependencyRevisionId);
@@ -364,7 +365,7 @@ public class IvyNode implements Comparable {
}
String[] confsArray = depNode.resolveSpecialConfigurations(dependencyConfigurations);
- Collection confs = Arrays.asList(confsArray);
+ Collection<String> confs = Arrays.asList(confsArray);
depNode.updateConfsToFetch(confs);
depNode.addRootModuleConfigurations(depNode.usage, rootModuleConf, confsArray);
depNode.usage.setRequiredConfs(this, conf, confs);
@@ -381,7 +382,7 @@ public class IvyNode implements Comparable {
}
public DependencyDescriptor getDependencyDescriptor(IvyNode parent) {
- return (DependencyDescriptor) dds.get(parent);
+ return dds.get(parent);
}
private boolean isDependencyModuleExcluded(DependencyDescriptor dd, String rootModuleConf,
@@ -390,14 +391,14 @@ public class IvyNode implements Comparable {
if (isRoot()) {
// no callers, but maybe some exclude
Boolean exclude = doesExclude(md, rootModuleConf, new String[] {rootModuleConf}, dd, a,
- new Stack());
+ new Stack<ModuleRevisionId>());
return exclude == null ? false : exclude.booleanValue();
}
return callers.doesCallersExclude(rootModuleConf, a);
}
Boolean doesExclude(ModuleDescriptor md, String rootModuleConf, String[] moduleConfs,
- DependencyDescriptor dd, Artifact artifact, Stack callersStack) {
+ DependencyDescriptor dd, Artifact artifact, Stack<ModuleRevisionId> callersStack) {
// artifact is excluded if it match any of the exclude pattern for this dependency...
if (dd != null) {
if (dd.doesExclude(moduleConfs, artifact.getId().getArtifactId())) {
@@ -494,7 +495,7 @@ public class IvyNode implements Comparable {
}
}
- public void updateConfsToFetch(Collection confs) {
+ public void updateConfsToFetch(Collection<String> confs) {
confsToFetch.addAll(confs);
confsToFetch.removeAll(fetchedConfigurations);
}
@@ -510,12 +511,13 @@ public class IvyNode implements Comparable {
return getDescriptor().getPublicConfigurationsNames();
}
// there are exclusions in the configuration
- List exclusions = Arrays.asList(conf.substring(2).split("\\!"));
+ List<String> exclusions = Arrays.asList(conf.substring(2).split("\\!"));
- List ret = new ArrayList(Arrays.asList(getDescriptor().getPublicConfigurationsNames()));
+ List<String> ret = new ArrayList<String>(Arrays.asList(getDescriptor()
+ .getPublicConfigurationsNames()));
ret.removeAll(exclusions);
- return (String[]) ret.toArray(new String[ret.size()]);
+ return ret.toArray(new String[ret.size()]);
}
return dependencyConfigurations;
}
@@ -527,16 +529,15 @@ public class IvyNode implements Comparable {
* @return
*/
public String[] getRequiredConfigurations(IvyNode in, String inConf) {
- Collection req = new LinkedHashSet();
+ Collection<String> req = new LinkedHashSet<String>();
addAllIfNotNull(req, usage.getRequiredConfigurations(in, inConf));
- for (Iterator iterator = mergedUsages.values().iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
+ for (IvyNodeUsage usage : mergedUsages.values()) {
addAllIfNotNull(req, usage.getRequiredConfigurations(in, inConf));
}
- return req == null ? new String[0] : (String[]) req.toArray(new String[req.size()]);
+ return req == null ? new String[0] : req.toArray(new String[req.size()]);
}
- private void addAllIfNotNull(Collection into, Collection col) {
+ private <T> void addAllIfNotNull(Collection<T> into, Collection<T> col) {
if (col != null) {
into.addAll(col);
}
@@ -548,10 +549,11 @@ public class IvyNode implements Comparable {
* @return
*/
public String[] getRequiredConfigurations() {
- Collection required = new ArrayList(confsToFetch.size() + fetchedConfigurations.size());
+ Collection<String> required = new ArrayList<String>(confsToFetch.size()
+ + fetchedConfigurations.size());
required.addAll(fetchedConfigurations);
required.addAll(confsToFetch);
- return (String[]) required.toArray(new String[required.size()]);
+ return required.toArray(new String[required.size()]);
}
public Configuration getConfiguration(String conf) {
@@ -575,23 +577,22 @@ public class IvyNode implements Comparable {
* @return
*/
public String[] getConfigurations(String rootModuleConf) {
- Set depConfs = new LinkedHashSet();
+ Set<String> depConfs = new LinkedHashSet<String>();
addAllIfNotNull(depConfs, usage.getConfigurations(rootModuleConf));
- for (Iterator iterator = mergedUsages.values().iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
+ for (IvyNodeUsage usage : mergedUsages.values()) {
addAllIfNotNull(depConfs, usage.getConfigurations(rootModuleConf));
}
- return (String[]) depConfs.toArray(new String[depConfs.size()]);
+ return depConfs.toArray(new String[depConfs.size()]);
}
protected boolean isConfRequiredByMergedUsageOnly(String rootModuleConf, String conf) {
- Set confs = usage.getConfigurations(rootModuleConf);
+ Set<String> confs = usage.getConfigurations(rootModuleConf);
return confs == null || !confs.contains(conf);
}
// This is never called. Could we remove it?
public void discardConf(String rootModuleConf, String conf) {
- Set depConfs = usage.addAndGetConfigurations(rootModuleConf);
+ Set<String> depConfs = usage.addAndGetConfigurations(rootModuleConf);
if (md != null) {
// remove all given dependency configurations to the set + extended ones
Configuration c = md.getConfiguration(conf);
@@ -612,7 +613,7 @@ public class IvyNode implements Comparable {
private void addRootModuleConfigurations(IvyNodeUsage usage, String rootModuleConf,
String[] dependencyConfs) {
- Set depConfs = usage.addAndGetConfigurations(rootModuleConf);
+ Set<String> depConfs = usage.addAndGetConfigurations(rootModuleConf);
if (md != null) {
// add all given dependency configurations to the set + extended ones
for (int i = 0; i < dependencyConfs.length; i++) {
@@ -637,8 +638,8 @@ public class IvyNode implements Comparable {
* @return
*/
public String[] getRootModuleConfigurations() {
- Set confs = getRootModuleConfigurationsSet();
- return (String[]) confs.toArray(new String[confs.size()]);
+ Set<String> confs = getRootModuleConfigurationsSet();
+ return confs.toArray(new String[confs.size()]);
}
/**
@@ -646,18 +647,17 @@ public class IvyNode implements Comparable {
*
* @return
*/
- public Set getRootModuleConfigurationsSet() {
- Set confs = new LinkedHashSet();
+ public Set<String> getRootModuleConfigurationsSet() {
+ Set<String> confs = new LinkedHashSet<String>();
addAllIfNotNull(confs, usage.getRootModuleConfigurations());
- for (Iterator iterator = mergedUsages.values().iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
+ for (IvyNodeUsage usage : mergedUsages.values()) {
addAllIfNotNull(confs, usage.getRootModuleConfigurations());
}
return confs;
}
public String[] getConfsToFetch() {
- return (String[]) confsToFetch.toArray(new String[confsToFetch.size()]);
+ return confsToFetch.toArray(new String[confsToFetch.size()]);
}
public String[] getRealConfs(String conf) {
@@ -694,11 +694,11 @@ public class IvyNode implements Comparable {
* @return a collection representing the path, starting with the from node, followed by the list
* of nodes being one path to the current node, excluded
*/
- private Collection findPath(ModuleId from) {
- return findPath(from, this, new LinkedList());
+ private Collection<IvyNode> findPath(ModuleId from) {
+ return findPath(from, this, new LinkedList<IvyNode>());
}
- private Collection findPath(ModuleId from, IvyNode node, List path) {
+ private Collection<IvyNode> findPath(ModuleId from, IvyNode node, List<IvyNode> path) {
IvyNode parent = node.getDirectCallerFor(from);
if (parent == null) {
throw new IllegalArgumentException("no path from " + from + " to " + getId() + " found");
@@ -738,7 +738,7 @@ public class IvyNode implements Comparable {
} else {
// let's copy usage information for the given rootModuleConf, into a separate usage
// object to keep detailed data about where usage comes from
- IvyNodeUsage mergedUsage = (IvyNodeUsage) mergedUsages.get(node.getId());
+ IvyNodeUsage mergedUsage = mergedUsages.get(node.getId());
if (mergedUsage == null) {
mergedUsage = new IvyNodeUsage(node);
mergedUsages.put(node.getId(), mergedUsage);
@@ -751,8 +751,8 @@ public class IvyNode implements Comparable {
updateConfsToFetch(node.confsToFetch);
}
- private Collection/* <IvyNodeUsage> */getAllUsages() {
- Collection usages = new ArrayList();
+ private Collection<IvyNodeUsage> getAllUsages() {
+ Collection<IvyNodeUsage> usages = new ArrayList<IvyNodeUsage>();
usages.add(usage);
usages.addAll(mergedUsages.values());
return usages;
@@ -764,13 +764,11 @@ public class IvyNode implements Comparable {
* @return
*/
public Artifact[] getAllArtifacts() {
- Set ret = new HashSet();
-
- for (Iterator it = getRootModuleConfigurationsSet().iterator(); it.hasNext();) {
- String rootModuleConf = (String) it.next();
+ Set<Artifact> ret = new HashSet<Artifact>();
+ for (String rootModuleConf : getRootModuleConfigurationsSet()) {
ret.addAll(Arrays.asList(getArtifacts(rootModuleConf)));
}
- return (Artifact[]) ret.toArray(new Artifact[ret.size()]);
+ return ret.toArray(new Artifact[ret.size()]);
}
/**
@@ -780,16 +778,15 @@ public class IvyNode implements Comparable {
* @param artifactFilter
* @return
*/
- public Artifact[] getSelectedArtifacts(Filter artifactFilter) {
- Collection ret = new HashSet();
- for (Iterator it = getRootModuleConfigurationsSet().iterator(); it.hasNext();) {
- String rootModuleConf = (String) it.next();
+ public Artifact[] getSelectedArtifacts(Filter<Artifact> artifactFilter) {
+ Collection<Artifact> ret = new HashSet<Artifact>();
+ for (String rootModuleConf : getRootModuleConfigurationsSet()) {
if (!isEvicted(rootModuleConf) && !isBlacklisted(rootModuleConf)) {
ret.addAll(Arrays.asList(getArtifacts(rootModuleConf)));
}
}
ret = FilterHelper.filter(ret, artifactFilter);
- return (Artifact[]) ret.toArray(new Artifact[ret.size()]);
+ return ret.toArray(new Artifact[ret.size()]);
}
/**
@@ -813,19 +810,19 @@ public class IvyNode implements Comparable {
+ this.toString());
}
- Set artifacts = new HashSet(); // the set we fill before returning
+ Set<Artifact> artifacts = new HashSet<Artifact>(); // the set we fill before returning
// we check if we have dependencyArtifacts includes description for this rootModuleConf
- Set dependencyArtifacts = usage.getDependencyArtifactsSet(rootModuleConf);
+ Set<DependencyArtifactDescriptor> dependencyArtifacts = usage
+ .getDependencyArtifactsSet(rootModuleConf);
if (md.isDefault() && dependencyArtifacts != null && !dependencyArtifacts.isEmpty()) {
addArtifactsFromOwnUsage(artifacts, dependencyArtifacts);
addArtifactsFromMergedUsage(rootModuleConf, artifacts);
} else {
- Set includes = new LinkedHashSet();
+ Set<IncludeRule> includes = new LinkedHashSet<IncludeRule>();
addAllIfNotNull(includes, usage.getDependencyIncludesSet(rootModuleConf));
- for (Iterator iterator = mergedUsages.values().iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
+ for (IvyNodeUsage usage : mergedUsages.values()) {
addAllIfNotNull(includes, usage.getDependencyIncludesSet(rootModuleConf));
}
@@ -840,7 +837,7 @@ public class IvyNode implements Comparable {
// first we get all artifacts as defined by the module descriptor
// and classify them by artifact id
- Map allArtifacts = new HashMap();
+ Map<ArtifactId, Artifact> allArtifacts = new HashMap<ArtifactId, Artifact>();
for (int i = 0; i < confs.length; i++) {
Artifact[] arts = md.getArtifacts(confs[i]);
for (int j = 0; j < arts.length; j++) {
@@ -855,9 +852,9 @@ public class IvyNode implements Comparable {
addArtifactsFromMergedUsage(rootModuleConf, artifacts);
// and now we filter according to include rules
- for (Iterator it = includes.iterator(); it.hasNext();) {
- IncludeRule dad = (IncludeRule) it.next();
- Collection arts = findArtifactsMatching(dad, allArtifacts);
+ for (Iterator<IncludeRule> it = includes.iterator(); it.hasNext();) {
+ IncludeRule dad = it.next();
+ Collection<Artifact> arts = findArtifactsMatching(dad, allArtifacts);
if (arts.isEmpty()) {
Message.error("a required artifact is not listed by module descriptor: "
+ dad.getId());
@@ -873,33 +870,33 @@ public class IvyNode implements Comparable {
}
// now excludes artifacts that aren't accepted by any caller
- for (Iterator iter = artifacts.iterator(); iter.hasNext();) {
- Artifact artifact = (Artifact) iter.next();
+ for (Iterator<Artifact> iter = artifacts.iterator(); iter.hasNext();) {
+ Artifact artifact = iter.next();
boolean excluded = callers.doesCallersExclude(rootModuleConf, artifact);
if (excluded) {
Message.debug(this + " in " + rootModuleConf + ": excluding " + artifact);
iter.remove();
}
}
- return (Artifact[]) artifacts.toArray(new Artifact[artifacts.size()]);
+ return artifacts.toArray(new Artifact[artifacts.size()]);
}
- private void addArtifactsFromOwnUsage(Set artifacts, Set dependencyArtifacts) {
- for (Iterator it = dependencyArtifacts.iterator(); it.hasNext();) {
- DependencyArtifactDescriptor dad = (DependencyArtifactDescriptor) it.next();
+ private void addArtifactsFromOwnUsage(Set<Artifact> artifacts,
+ Set<DependencyArtifactDescriptor> dependencyArtifacts) {
+ for (DependencyArtifactDescriptor dad : dependencyArtifacts) {
artifacts.add(new MDArtifact(md, dad.getName(), dad.getType(), dad.getExt(), dad
.getUrl(), dad.getQualifiedExtraAttributes()));
}
}
- private void addArtifactsFromMergedUsage(String rootModuleConf, Set artifacts) {
- for (Iterator iterator = mergedUsages.values().iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
- Set mergedDependencyArtifacts = usage.getDependencyArtifactsSet(rootModuleConf);
+ private void addArtifactsFromMergedUsage(String rootModuleConf, Set<Artifact> artifacts) {
+ for (IvyNodeUsage usage : mergedUsages.values()) {
+ Set<DependencyArtifactDescriptor> mergedDependencyArtifacts = usage
+ .getDependencyArtifactsSet(rootModuleConf);
if (mergedDependencyArtifacts != null) {
- for (Iterator it = mergedDependencyArtifacts.iterator(); it.hasNext();) {
- DependencyArtifactDescriptor dad = (DependencyArtifactDescriptor) it.next();
- Map extraAttributes = new HashMap(dad.getQualifiedExtraAttributes());
+ for (DependencyArtifactDescriptor dad : mergedDependencyArtifacts) {
+ Map<String, String> extraAttributes = new HashMap<String, String>(
+ dad.getQualifiedExtraAttributes());
MDArtifact artifact = new MDArtifact(md, dad.getName(), dad.getType(),
dad.getExt(), dad.getUrl(), extraAttributes);
@@ -914,12 +911,12 @@ public class IvyNode implements Comparable {
}
}
- private static Collection findArtifactsMatching(IncludeRule rule, Map allArtifacts) {
- Collection ret = new ArrayList();
- for (Iterator iter = allArtifacts.keySet().iterator(); iter.hasNext();) {
- ArtifactId aid = (ArtifactId) iter.next();
- if (MatcherHelper.matches(rule.getMatcher(), rule.getId(), aid)) {
- ret.add(allArtifacts.get(aid));
+ private static Collection<Artifact> findArtifactsMatching(IncludeRule rule,
+ Map<ArtifactId, Artifact> allArtifacts) {
+ Collection<Artifact> ret = new ArrayList<Artifact>();
+ for (Entry<ArtifactId, Artifact> entry : allArtifacts.entrySet()) {
+ if (MatcherHelper.matches(rule.getMatcher(), rule.getId(), entry.getKey())) {
+ ret.add(allArtifacts.get(entry.getValue()));
}
}
return ret;
@@ -1059,7 +1056,7 @@ public class IvyNode implements Comparable {
return callers.getCallers(rootModuleConf);
}
- public Collection getAllCallersModuleIds() {
+ public Collection<ModuleId> getAllCallersModuleIds() {
return callers.getAllCallersModuleIds();
}
@@ -1082,16 +1079,16 @@ public class IvyNode implements Comparable {
}
}
- public boolean doesCallersExclude(String rootModuleConf, Artifact artifact, Stack callersStack) {
+ public boolean doesCallersExclude(String rootModuleConf, Artifact artifact,
+ Stack<ModuleRevisionId> callersStack) {
return callers.doesCallersExclude(rootModuleConf, artifact, callersStack);
}
- private ModuleRevisionId[] toMrids(Collection path, IvyNode depNode) {
+ private ModuleRevisionId[] toMrids(Collection<IvyNode> path, IvyNode depNode) {
ModuleRevisionId[] ret = new ModuleRevisionId[path.size() + 1];
int i = 0;
- for (Iterator iter = path.iterator(); iter.hasNext(); i++) {
- IvyNode node = (IvyNode) iter.next();
- ret[i] = node.getId();
+ for (IvyNode node : path) {
+ ret[i++] = node.getId();
}
ret[ret.length - 1] = depNode.getId();
return ret;
@@ -1102,11 +1099,12 @@ public class IvyNode implements Comparable {
// /////////////////////////////////////////////////////////////////////////////
/** A copy of the set of resolved nodes (real nodes) */
- public Set getResolvedNodes(ModuleId moduleId, String rootModuleConf) {
+ public Set<IvyNode> getResolvedNodes(ModuleId moduleId, String rootModuleConf) {
return eviction.getResolvedNodes(moduleId, rootModuleConf);
}
- public Collection getResolvedRevisions(ModuleId moduleId, String rootModuleConf) {
+ public Collection<ModuleRevisionId> getResolvedRevisions(ModuleId moduleId,
+ String rootModuleConf) {
return eviction.getResolvedRevisions(moduleId, rootModuleConf);
}
@@ -1116,22 +1114,21 @@ public class IvyNode implements Comparable {
// bug 105: update selected data with evicted one
if (evictionData.getSelected() != null) {
- for (Iterator iter = evictionData.getSelected().iterator(); iter.hasNext();) {
- IvyNode selected = (IvyNode) iter.next();
+ for (IvyNode selected : evictionData.getSelected()) {
selected.updateDataFrom(this, rootModuleConf, false);
}
}
}
- public Collection getAllEvictingConflictManagers() {
+ public Collection<ConflictManager> getAllEvictingConflictManagers() {
return eviction.getAllEvictingConflictManagers();
}
- public Collection getAllEvictingNodes() {
+ public Collection<IvyNode> getAllEvictingNodes() {
return eviction.getAllEvictingNodes();
}
- public Collection/* <String> */getAllEvictingNodesDetails() {
+ public Collection<String> getAllEvictingNodesDetails() {
return eviction.getAllEvictingNodesDetails();
}
@@ -1143,11 +1140,11 @@ public class IvyNode implements Comparable {
return eviction.getEvictedData(rootModuleConf);
}
- public Collection getEvictedNodes(ModuleId mid, String rootModuleConf) {
+ public Collection<IvyNode> getEvictedNodes(ModuleId mid, String rootModuleConf) {
return eviction.getEvictedNodes(mid, rootModuleConf);
}
- public Collection getEvictedRevisions(ModuleId mid, String rootModuleConf) {
+ public Collection<ModuleRevisionId> getEvictedRevisions(ModuleId mid, String rootModuleConf) {
return eviction.getEvictedRevisions(mid, rootModuleConf);
}
@@ -1164,24 +1161,28 @@ public class IvyNode implements Comparable {
}
public void markEvicted(String rootModuleConf, IvyNode node, ConflictManager conflictManager,
- Collection resolved) {
+ Collection<IvyNode> resolved) {
EvictionData evictionData = new EvictionData(rootModuleConf, node, conflictManager,
resolved);
markEvicted(evictionData);
}
- public void setEvictedNodes(ModuleId moduleId, String rootModuleConf, Collection evicted) {
+ public void setEvictedNodes(ModuleId moduleId, String rootModuleConf,
+ Collection<IvyNode> evicted) {
eviction.setEvictedNodes(moduleId, rootModuleConf, evicted);
}
- public void setResolvedNodes(ModuleId moduleId, String rootModuleConf, Collection resolved) {
+ public void setResolvedNodes(ModuleId moduleId, String rootModuleConf,
+ Collection<IvyNode> resolved) {
eviction.setResolvedNodes(moduleId, rootModuleConf, resolved);
}
+ @Override
public String toString() {
return getResolvedId().toString();
}
+ @Override
public boolean equals(Object obj) {
if (!(obj instanceof IvyNode)) {
return false;
@@ -1190,11 +1191,11 @@ public class IvyNode implements Comparable {
return node.getId().equals(getId());
}
- public int compareTo(Object obj) {
- IvyNode that = (IvyNode) obj;
+ public int compareTo(IvyNode that) {
return this.getModuleId().compareTo(that.getModuleId());
}
+ @Override
public int hashCode() {
return getId().hashCode();
}
@@ -1208,11 +1209,12 @@ public class IvyNode implements Comparable {
* the module id for which pending conflicts should be found
* @return a Collection of IvyNode in pending conflict
*/
- public Collection getPendingConflicts(String rootModuleConf, ModuleId mid) {
+ public Collection<IvyNode> getPendingConflicts(String rootModuleConf, ModuleId mid) {
return eviction.getPendingConflicts(rootModuleConf, mid);
}
- public void setPendingConflicts(ModuleId moduleId, String rootModuleConf, Collection conflicts) {
+ public void setPendingConflicts(ModuleId moduleId, String rootModuleConf,
+ Collection<IvyNode> conflicts) {
eviction.setPendingConflicts(moduleId, rootModuleConf, conflicts);
}
@@ -1239,7 +1241,7 @@ public class IvyNode implements Comparable {
Message.verbose("BLACKLISTING " + bdata);
}
- Stack callerStack = new Stack();
+ Stack<IvyNode> callerStack = new Stack<IvyNode>();
callerStack.push(this);
clearEvictionDataInAllCallers(bdata.getRootModuleConf(), callerStack);
@@ -1247,9 +1249,8 @@ public class IvyNode implements Comparable {
data.blacklist(this);
}
- private void clearEvictionDataInAllCallers(String rootModuleConf,
- Stack/* <IvyNode> */callerStack) {
- IvyNode node = (IvyNode) callerStack.peek();
+ private void clearEvictionDataInAllCallers(String rootModuleConf, Stack<IvyNode> callerStack) {
+ IvyNode node = callerStack.peek();
Caller[] callers = node.getCallers(rootModuleConf);
for (int i = 0; i < callers.length; i++) {
IvyNode callerNode = findNode(callers[i].getModuleRevisionId());
@@ -1332,8 +1333,7 @@ public class IvyNode implements Comparable {
if (mergedUsages == null) {
return false;
}
- for (Iterator iterator = mergedUsages.values().iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
+ for (IvyNodeUsage usage : mergedUsages.values()) {
if (usage.hasTransitiveDepender(rootModuleConf)) {
return true;
}
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/core/resolve/IvyNodeCallers.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/core/resolve/IvyNodeCallers.java b/src/java/org/apache/ivy/core/resolve/IvyNodeCallers.java
index 399a60a..a53262a 100644
--- a/src/java/org/apache/ivy/core/resolve/IvyNodeCallers.java
+++ b/src/java/org/apache/ivy/core/resolve/IvyNodeCallers.java
@@ -21,7 +21,6 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
@@ -39,7 +38,8 @@ public class IvyNodeCallers {
private ModuleRevisionId mrid;
- private Map confs = new HashMap(); // Map (String callerConf -> String[] dependencyConfs)
+ // callerConf -> dependencyConfs
+ private Map<String, String[]> confs = new HashMap<String, String[]>();
private DependencyDescriptor dd;
@@ -69,9 +69,9 @@ public class IvyNodeCallers {
}
private void updateConfs(String callerConf, String[] dependencyConfs) {
- String[] prevDepConfs = (String[]) confs.get(callerConf);
+ String[] prevDepConfs = confs.get(callerConf);
if (prevDepConfs != null) {
- Set newDepConfs = new HashSet(Arrays.asList(prevDepConfs));
+ Set<String> newDepConfs = new HashSet<String>(Arrays.asList(prevDepConfs));
newDepConfs.addAll(Arrays.asList(dependencyConfs));
confs.put(callerConf, newDepConfs.toArray(new String[newDepConfs.size()]));
} else {
@@ -80,13 +80,14 @@ public class IvyNodeCallers {
}
public String[] getCallerConfigurations() {
- return (String[]) confs.keySet().toArray(new String[confs.keySet().size()]);
+ return confs.keySet().toArray(new String[confs.keySet().size()]);
}
public ModuleRevisionId getModuleRevisionId() {
return mrid;
}
+ @Override
public boolean equals(Object obj) {
if (!(obj instanceof Caller)) {
return false;
@@ -95,6 +96,7 @@ public class IvyNodeCallers {
return other.confs.equals(confs) && mrid.equals(other.mrid);
}
+ @Override
public int hashCode() {
// CheckStyle:MagicNumber| OFF
int hash = 31;
@@ -104,6 +106,7 @@ public class IvyNodeCallers {
return hash;
}
+ @Override
public String toString() {
return mrid.toString();
}
@@ -133,15 +136,13 @@ public class IvyNodeCallers {
}
}
- // Map (String rootModuleConf -> Map (ModuleRevisionId -> Caller)): key in second map is used to
- // easily get a caller by its mrid
- private Map callersByRootConf = new HashMap();
+ // key in second map is used to easily get a caller by its mrid
+ private Map<String, Map<ModuleRevisionId, Caller>> callersByRootConf = new HashMap<String, Map<ModuleRevisionId, Caller>>();
// this map contains all the module ids calling this one (including transitively) as keys.
// the mapped nodes (values) correspond to a direct caller from which the transitive caller
// comes
-
- private Map allCallers = new HashMap(); // Map (ModuleId -> IvyNode)
+ private Map<ModuleId, IvyNode> allCallers = new HashMap<ModuleId, IvyNode>();
private IvyNode node;
@@ -166,12 +167,12 @@ public class IvyNodeCallers {
throw new IllegalArgumentException("a module is not authorized to depend on itself: "
+ node.getId());
}
- Map callers = (Map) callersByRootConf.get(rootModuleConf);
+ Map<ModuleRevisionId, Caller> callers = callersByRootConf.get(rootModuleConf);
if (callers == null) {
- callers = new HashMap();
+ callers = new HashMap<ModuleRevisionId, Caller>();
callersByRootConf.put(rootModuleConf, callers);
}
- Caller caller = (Caller) callers.get(mrid);
+ Caller caller = callers.get(mrid);
if (caller == null) {
caller = new Caller(md, mrid, dd, callerNode.canExclude(rootModuleConf));
callers.put(mrid, caller);
@@ -179,8 +180,7 @@ public class IvyNodeCallers {
caller.addConfiguration(requestedConf, dependencyConfs);
IvyNode parent = callerNode.getRealNode();
- for (Iterator iter = parent.getAllCallersModuleIds().iterator(); iter.hasNext();) {
- ModuleId mid = (ModuleId) iter.next();
+ for (ModuleId mid : parent.getAllCallersModuleIds()) {
allCallers.put(mid, parent);
}
allCallers.put(mrid.getModuleId(), callerNode);
@@ -188,57 +188,53 @@ public class IvyNodeCallers {
void removeCaller(String rootModuleConf, ModuleRevisionId callerMrid) {
allCallers.remove(callerMrid.getModuleId());
- Map callers = (Map) callersByRootConf.get(rootModuleConf);
+ Map<ModuleRevisionId, Caller> callers = callersByRootConf.get(rootModuleConf);
if (callers != null) {
callers.remove(callerMrid);
}
}
public Caller[] getCallers(String rootModuleConf) {
- Map callers = (Map) callersByRootConf.get(rootModuleConf);
+ Map<ModuleRevisionId, Caller> callers = callersByRootConf.get(rootModuleConf);
if (callers == null) {
return new Caller[0];
}
- return (Caller[]) callers.values().toArray(new Caller[callers.values().size()]);
+ return callers.values().toArray(new Caller[callers.values().size()]);
}
public Caller[] getAllCallers() {
- Set all = new HashSet();
- for (Iterator iter = callersByRootConf.values().iterator(); iter.hasNext();) {
- Map callers = (Map) iter.next();
+ Set<Caller> all = new HashSet<Caller>();
+ for (Map<ModuleRevisionId, Caller> callers : callersByRootConf.values()) {
all.addAll(callers.values());
}
- return (Caller[]) all.toArray(new Caller[all.size()]);
+ return all.toArray(new Caller[all.size()]);
}
public Caller[] getAllRealCallers() {
- Set all = new HashSet();
- for (Iterator iter = callersByRootConf.values().iterator(); iter.hasNext();) {
- Map callers = (Map) iter.next();
- for (Iterator iterator = callers.values().iterator(); iterator.hasNext();) {
- Caller c = (Caller) iterator.next();
+ Set<Caller> all = new HashSet<Caller>();
+ for (Map<ModuleRevisionId, Caller> callers : callersByRootConf.values()) {
+ for (Caller c : callers.values()) {
if (c.isRealCaller()) {
all.add(c);
}
}
}
- return (Caller[]) all.toArray(new Caller[all.size()]);
+ return all.toArray(new Caller[all.size()]);
}
- public Collection getAllCallersModuleIds() {
+ public Collection<ModuleId> getAllCallersModuleIds() {
return allCallers.keySet();
}
void updateFrom(IvyNodeCallers callers, String rootModuleConf, boolean real) {
- Map nodecallers = (Map) callers.callersByRootConf.get(rootModuleConf);
+ Map<ModuleRevisionId, Caller> nodecallers = callers.callersByRootConf.get(rootModuleConf);
if (nodecallers != null) {
- Map thiscallers = (Map) callersByRootConf.get(rootModuleConf);
+ Map<ModuleRevisionId, Caller> thiscallers = callersByRootConf.get(rootModuleConf);
if (thiscallers == null) {
- thiscallers = new HashMap();
+ thiscallers = new HashMap<ModuleRevisionId, Caller>();
callersByRootConf.put(rootModuleConf, thiscallers);
}
- for (Iterator iter = nodecallers.values().iterator(); iter.hasNext();) {
- Caller caller = (Caller) iter.next();
+ for (Caller caller : nodecallers.values()) {
if (!thiscallers.containsKey(caller.getModuleRevisionId())) {
if (!real) {
caller.setRealCaller(false);
@@ -250,7 +246,7 @@ public class IvyNodeCallers {
}
public IvyNode getDirectCallerFor(ModuleId from) {
- return (IvyNode) allCallers.get(from);
+ return allCallers.get(from);
}
/**
@@ -261,10 +257,11 @@ public class IvyNodeCallers {
* @return
*/
boolean doesCallersExclude(String rootModuleConf, Artifact artifact) {
- return doesCallersExclude(rootModuleConf, artifact, new Stack());
+ return doesCallersExclude(rootModuleConf, artifact, new Stack<ModuleRevisionId>());
}
- boolean doesCallersExclude(String rootModuleConf, Artifact artifact, Stack callersStack) {
+ boolean doesCallersExclude(String rootModuleConf, Artifact artifact,
+ Stack<ModuleRevisionId> callersStack) {
callersStack.push(node.getId());
try {
Caller[] callers = getCallers(rootModuleConf);
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/core/resolve/IvyNodeEviction.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/core/resolve/IvyNodeEviction.java b/src/java/org/apache/ivy/core/resolve/IvyNodeEviction.java
index 5c757ee..c08f94a 100644
--- a/src/java/org/apache/ivy/core/resolve/IvyNodeEviction.java
+++ b/src/java/org/apache/ivy/core/resolve/IvyNodeEviction.java
@@ -46,7 +46,7 @@ public class IvyNodeEviction {
/**
* Can be null in case of transitive eviction.
*/
- private Collection selected; // Collection(IvyNode)
+ private Collection<IvyNode> selected;
private String rootModuleConf;
@@ -67,7 +67,7 @@ public class IvyNodeEviction {
* <tt>null</tt> in case of transitive eviction)
*/
public EvictionData(String rootModuleConf, IvyNode parent, ConflictManager conflictManager,
- Collection selected) {
+ Collection<IvyNode> selected) {
this(rootModuleConf, parent, conflictManager, selected, null);
}
@@ -88,7 +88,7 @@ public class IvyNodeEviction {
* a String detailing the reason why the node was evicted
*/
public EvictionData(String rootModuleConf, IvyNode parent, ConflictManager conflictManager,
- Collection selected, String detail) {
+ Collection<IvyNode> selected, String detail) {
this.rootModuleConf = rootModuleConf;
this.parent = parent;
this.conflictManager = conflictManager;
@@ -96,6 +96,7 @@ public class IvyNodeEviction {
this.detail = detail;
}
+ @Override
public String toString() {
if (selected != null) {
return selected + " in " + parent + (detail == null ? "" : " " + detail) + " ("
@@ -113,7 +114,7 @@ public class IvyNodeEviction {
return parent;
}
- public Collection getSelected() {
+ public Collection<IvyNode> getSelected() {
return selected;
}
@@ -154,6 +155,7 @@ public class IvyNodeEviction {
return moduleId;
}
+ @Override
public boolean equals(Object obj) {
if (!(obj instanceof ModuleIdConf)) {
return false;
@@ -162,6 +164,7 @@ public class IvyNodeEviction {
&& getConf().equals(((ModuleIdConf) obj).getConf());
}
+ @Override
public int hashCode() {
// CheckStyle:MagicNumber| OFF
int hash = 33;
@@ -174,28 +177,21 @@ public class IvyNodeEviction {
private IvyNode node;
- private Map selectedDeps = new HashMap(); // Map (ModuleIdConf -> Set(Node)) // map indicating
+ // map indicating for each dependency which node has been selected
+ private Map<ModuleIdConf, Set<IvyNode>> selectedDeps = new HashMap<ModuleIdConf, Set<IvyNode>>();
- // for each dependency which node has been selected
+ // map indicating for each dependency which nodes are in pending conflict (conflict detected but
+ // not yet resolved)
+ private Map<ModuleIdConf, Set<IvyNode>> pendingConflicts = new HashMap<ModuleIdConf, Set<IvyNode>>();
- private Map pendingConflicts = new HashMap(); // Map (ModuleIdConf -> Set(Node)) // map
+ // map indicating for each dependency which node has been evicted
+ private Map<ModuleIdConf, Set<IvyNode>> evictedDeps = new HashMap<ModuleIdConf, Set<IvyNode>>();
- // indicating for each dependency which nodes
- // are in pending conflict (conflict detected
- // but not yet resolved)
+ // map indicating for each dependency which revision has been evicted
+ private Map<ModuleIdConf, Collection<ModuleRevisionId>> evictedRevs = new HashMap<ModuleIdConf, Collection<ModuleRevisionId>>();
- private Map evictedDeps = new HashMap(); // Map (ModuleIdConf -> Set(Node)) // map indicating
-
- // for each dependency which node has been evicted
-
- private Map evictedRevs = new HashMap(); // Map (ModuleIdConf -> Set(ModuleRevisionId)) //
-
- // map indicating for each dependency which revision
- // has been evicted
-
- private Map evicted = new HashMap(); // Map (root module conf -> EvictionData) // indicates
-
- // if the node is evicted in each root module conf
+ // indicates if the node is evicted in each root module conf
+ private Map<String, EvictionData> evicted = new HashMap<String, EvictionData>();
public IvyNodeEviction(IvyNode node) {
if (node == null) {
@@ -207,26 +203,24 @@ public class IvyNodeEviction {
/**
* @return A copy of the set of resolved nodes (real nodes)
*/
- public Set getResolvedNodes(ModuleId mid, String rootModuleConf) {
- Collection resolved = (Collection) selectedDeps.get(new ModuleIdConf(mid, rootModuleConf));
- Set ret = new HashSet();
+ public Set<IvyNode> getResolvedNodes(ModuleId mid, String rootModuleConf) {
+ Collection<IvyNode> resolved = selectedDeps.get(new ModuleIdConf(mid, rootModuleConf));
+ Set<IvyNode> ret = new HashSet<IvyNode>();
if (resolved != null) {
- for (Iterator iter = resolved.iterator(); iter.hasNext();) {
- IvyNode node = (IvyNode) iter.next();
+ for (IvyNode node : resolved) {
ret.add(node.getRealNode());
}
}
return ret;
}
- public Collection getResolvedRevisions(ModuleId mid, String rootModuleConf) {
- Collection resolved = (Collection) selectedDeps.get(new ModuleIdConf(mid, rootModuleConf));
+ public Collection<ModuleRevisionId> getResolvedRevisions(ModuleId mid, String rootModuleConf) {
+ Collection<IvyNode> resolved = selectedDeps.get(new ModuleIdConf(mid, rootModuleConf));
if (resolved == null) {
- return new HashSet();
+ return new HashSet<ModuleRevisionId>();
} else {
- Collection resolvedRevs = new HashSet();
- for (Iterator iter = resolved.iterator(); iter.hasNext();) {
- IvyNode node = (IvyNode) iter.next();
+ Collection<ModuleRevisionId> resolvedRevs = new HashSet<ModuleRevisionId>();
+ for (IvyNode node : resolved) {
ModuleRevisionId resolvedId = node.getResolvedId();
resolvedRevs.add(node.getId());
resolvedRevs.add(resolvedId);
@@ -242,38 +236,39 @@ public class IvyNodeEviction {
}
}
- public void setResolvedNodes(ModuleId moduleId, String rootModuleConf, Collection resolved) {
+ public void setResolvedNodes(ModuleId moduleId, String rootModuleConf,
+ Collection<IvyNode> resolved) {
ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
- selectedDeps.put(moduleIdConf, new HashSet(resolved));
+ selectedDeps.put(moduleIdConf, new HashSet<IvyNode>(resolved));
}
- public Collection getEvictedNodes(ModuleId mid, String rootModuleConf) {
- Collection resolved = (Collection) evictedDeps.get(new ModuleIdConf(mid, rootModuleConf));
- Set ret = new HashSet();
+ public Collection<IvyNode> getEvictedNodes(ModuleId mid, String rootModuleConf) {
+ Collection<IvyNode> resolved = evictedDeps.get(new ModuleIdConf(mid, rootModuleConf));
+ Set<IvyNode> ret = new HashSet<IvyNode>();
if (resolved != null) {
- for (Iterator iter = resolved.iterator(); iter.hasNext();) {
- IvyNode node = (IvyNode) iter.next();
+ for (IvyNode node : resolved) {
ret.add(node.getRealNode());
}
}
return ret;
}
- public Collection getEvictedRevisions(ModuleId mid, String rootModuleConf) {
- Collection evicted = (Collection) evictedRevs.get(new ModuleIdConf(mid, rootModuleConf));
+ public Collection<ModuleRevisionId> getEvictedRevisions(ModuleId mid, String rootModuleConf) {
+ Collection<ModuleRevisionId> evicted = evictedRevs
+ .get(new ModuleIdConf(mid, rootModuleConf));
if (evicted == null) {
- return new HashSet();
+ return new HashSet<ModuleRevisionId>();
} else {
- return new HashSet(evicted);
+ return new HashSet<ModuleRevisionId>(evicted);
}
}
- public void setEvictedNodes(ModuleId moduleId, String rootModuleConf, Collection evicted) {
+ public void setEvictedNodes(ModuleId moduleId, String rootModuleConf,
+ Collection<IvyNode> evicted) {
ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
- evictedDeps.put(moduleIdConf, new HashSet(evicted));
- Collection evictedRevs = new HashSet();
- for (Iterator iter = evicted.iterator(); iter.hasNext();) {
- IvyNode node = (IvyNode) iter.next();
+ evictedDeps.put(moduleIdConf, new HashSet<IvyNode>(evicted));
+ Collection<ModuleRevisionId> evictedRevs = new HashSet<ModuleRevisionId>();
+ for (IvyNode node : evicted) {
evictedRevs.add(node.getId());
evictedRevs.add(node.getResolvedId());
}
@@ -291,7 +286,8 @@ public class IvyNodeEviction {
}
IvyNode root = node.getRoot();
ModuleId moduleId = node.getId().getModuleId();
- Collection resolvedRevisions = root.getResolvedRevisions(moduleId, rootModuleConf);
+ Collection<ModuleRevisionId> resolvedRevisions = root.getResolvedRevisions(moduleId,
+ rootModuleConf);
return !resolvedRevisions.contains(node.getResolvedId())
|| evictedData.isTransitivelyEvicted();
}
@@ -312,13 +308,12 @@ public class IvyNodeEviction {
private void cleanEvicted() {
// check if it was evicted by a node that we are now the real node for
- for (Iterator iter = evicted.keySet().iterator(); iter.hasNext();) {
- String rootModuleConf = (String) iter.next();
- EvictionData ed = (EvictionData) evicted.get(rootModuleConf);
- Collection sel = ed.getSelected();
+ for (Iterator<String> iter = evicted.keySet().iterator(); iter.hasNext();) {
+ String rootModuleConf = iter.next();
+ EvictionData ed = evicted.get(rootModuleConf);
+ Collection<IvyNode> sel = ed.getSelected();
if (sel != null) {
- for (Iterator iterator = sel.iterator(); iterator.hasNext();) {
- IvyNode n = (IvyNode) iterator.next();
+ for (IvyNode n : sel) {
if (n.getRealNode().equals(node)) {
// yes, we are the real node for a selected one !
// we are no more evicted in this conf !
@@ -335,12 +330,12 @@ public class IvyNodeEviction {
public EvictionData getEvictedData(String rootModuleConf) {
cleanEvicted();
- return (EvictionData) evicted.get(rootModuleConf);
+ return evicted.get(rootModuleConf);
}
public String[] getEvictedConfs() {
cleanEvicted();
- return (String[]) evicted.keySet().toArray(new String[evicted.keySet().size()]);
+ return evicted.keySet().toArray(new String[evicted.keySet().size()]);
}
/**
@@ -349,14 +344,13 @@ public class IvyNodeEviction {
*
* @return
*/
- public Collection getAllEvictingNodes() {
- Collection allEvictingNodes = null;
- for (Iterator iter = evicted.values().iterator(); iter.hasNext();) {
- EvictionData ed = (EvictionData) iter.next();
- Collection selected = ed.getSelected();
+ public Collection<IvyNode> getAllEvictingNodes() {
+ Collection<IvyNode> allEvictingNodes = null;
+ for (EvictionData ed : evicted.values()) {
+ Collection<IvyNode> selected = ed.getSelected();
if (selected != null) {
if (allEvictingNodes == null) {
- allEvictingNodes = new HashSet();
+ allEvictingNodes = new HashSet<IvyNode>();
}
allEvictingNodes.addAll(selected);
}
@@ -364,14 +358,13 @@ public class IvyNodeEviction {
return allEvictingNodes;
}
- public Collection/* <String> */getAllEvictingNodesDetails() {
- Collection ret = null;
- for (Iterator iter = evicted.values().iterator(); iter.hasNext();) {
- EvictionData ed = (EvictionData) iter.next();
- Collection selected = ed.getSelected();
+ public Collection<String> getAllEvictingNodesDetails() {
+ Collection<String> ret = null;
+ for (EvictionData ed : evicted.values()) {
+ Collection<IvyNode> selected = ed.getSelected();
if (selected != null) {
if (ret == null) {
- ret = new HashSet();
+ ret = new HashSet<String>();
}
if (selected.size() == 1) {
ret.add(selected.iterator().next()
@@ -384,10 +377,9 @@ public class IvyNodeEviction {
return ret;
}
- public Collection getAllEvictingConflictManagers() {
- Collection ret = new HashSet();
- for (Iterator iter = evicted.values().iterator(); iter.hasNext();) {
- EvictionData ed = (EvictionData) iter.next();
+ public Collection<ConflictManager> getAllEvictingConflictManagers() {
+ Collection<ConflictManager> ret = new HashSet<ConflictManager>();
+ for (EvictionData ed : evicted.values()) {
ret.add(ed.getConflictManager());
}
return ret;
@@ -403,10 +395,9 @@ public class IvyNodeEviction {
* @return
*/
public EvictionData getEvictionDataInRoot(String rootModuleConf, IvyNode ancestor) {
- Collection selectedNodes = node.getRoot().getResolvedNodes(node.getModuleId(),
+ Collection<IvyNode> selectedNodes = node.getRoot().getResolvedNodes(node.getModuleId(),
rootModuleConf);
- for (Iterator iter = selectedNodes.iterator(); iter.hasNext();) {
- IvyNode node = (IvyNode) iter.next();
+ for (IvyNode node : selectedNodes) {
if (node.getResolvedId().equals(this.node.getResolvedId())) {
// the node is part of the selected ones for the root: no eviction data to return
return null;
@@ -418,22 +409,21 @@ public class IvyNodeEviction {
node.getModuleId()), selectedNodes);
}
- public Collection getPendingConflicts(String rootModuleConf, ModuleId mid) {
- Collection resolved = (Collection) pendingConflicts.get(new ModuleIdConf(mid,
- rootModuleConf));
- Set ret = new HashSet();
+ public Collection<IvyNode> getPendingConflicts(String rootModuleConf, ModuleId mid) {
+ Collection<IvyNode> resolved = pendingConflicts.get(new ModuleIdConf(mid, rootModuleConf));
+ Set<IvyNode> ret = new HashSet<IvyNode>();
if (resolved != null) {
- for (Iterator iter = resolved.iterator(); iter.hasNext();) {
- IvyNode node = (IvyNode) iter.next();
+ for (IvyNode node : resolved) {
ret.add(node.getRealNode());
}
}
return ret;
}
- public void setPendingConflicts(ModuleId moduleId, String rootModuleConf, Collection conflicts) {
+ public void setPendingConflicts(ModuleId moduleId, String rootModuleConf,
+ Collection<IvyNode> conflicts) {
ModuleIdConf moduleIdConf = new ModuleIdConf(moduleId, rootModuleConf);
- pendingConflicts.put(moduleIdConf, new HashSet(conflicts));
+ pendingConflicts.put(moduleIdConf, new HashSet<IvyNode>(conflicts));
}
}
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/core/resolve/IvyNodeUsage.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/core/resolve/IvyNodeUsage.java b/src/java/org/apache/ivy/core/resolve/IvyNodeUsage.java
index 5269558..b6631f2 100644
--- a/src/java/org/apache/ivy/core/resolve/IvyNodeUsage.java
+++ b/src/java/org/apache/ivy/core/resolve/IvyNodeUsage.java
@@ -21,7 +21,6 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.Map;
import java.util.Set;
@@ -64,6 +63,7 @@ public class IvyNodeUsage {
return node;
}
+ @Override
public boolean equals(Object obj) {
if (!(obj instanceof NodeConf)) {
return false;
@@ -72,6 +72,7 @@ public class IvyNodeUsage {
&& getConf().equals(((NodeConf) obj).getConf());
}
+ @Override
public int hashCode() {
// CheckStyle:MagicNumber| OFF
int hash = 33;
@@ -81,6 +82,7 @@ public class IvyNodeUsage {
return hash;
}
+ @Override
public String toString() {
return "NodeConf(" + conf + ")";
}
@@ -96,10 +98,12 @@ public class IvyNodeUsage {
this.dependerConf = dependerConf;
}
+ @Override
public String toString() {
return dd + " [" + dependerConf + "]";
}
+ @Override
public boolean equals(Object obj) {
if (!(obj instanceof Depender)) {
return false;
@@ -108,6 +112,7 @@ public class IvyNodeUsage {
return other.dd == dd && other.dependerConf.equals(dependerConf);
}
+ @Override
public int hashCode() {
int hash = 33;
hash += dd.hashCode() * 13;
@@ -118,29 +123,28 @@ public class IvyNodeUsage {
private IvyNode node;
- // Map (String rootConfName -> Set(String confName))
// used to know which configurations of the dependency are required
// for each root module configuration
- private Map rootModuleConfs = new HashMap();
+ // rootConfName -> confNames
+ private Map<String, Set<String>> rootModuleConfs = new HashMap<String, Set<String>>();
- // Map (NodeConf in -> Set(String conf))
- private Map requiredConfs = new HashMap();
+ private Map<NodeConf, Set<String>> requiredConfs = new HashMap<NodeConf, Set<String>>();
- private Map /* <String, Set<Depender>> */dependers = new HashMap();
+ private Map<String, Set<Depender>> dependers = new HashMap<String, Set<Depender>>();
- // Map (String rootModuleConf -> IvyNodeBlacklist)
- private Map blacklisted = new HashMap();
+ // rootModuleConf -> black list
+ private Map<String, IvyNodeBlacklist> blacklisted = new HashMap<String, IvyNodeBlacklist>();
public IvyNodeUsage(IvyNode node) {
this.node = node;
}
- protected Collection getRequiredConfigurations(IvyNode in, String inConf) {
- return (Collection) requiredConfs.get(new NodeConf(in, inConf));
+ protected Collection<String> getRequiredConfigurations(IvyNode in, String inConf) {
+ return requiredConfs.get(new NodeConf(in, inConf));
}
- protected void setRequiredConfs(IvyNode parent, String parentConf, Collection confs) {
- requiredConfs.put(new NodeConf(parent, parentConf), new HashSet(confs));
+ protected void setRequiredConfs(IvyNode parent, String parentConf, Collection<String> confs) {
+ requiredConfs.put(new NodeConf(parent, parentConf), new HashSet<String>(confs));
}
/**
@@ -149,26 +153,25 @@ public class IvyNodeUsage {
* @param rootModuleConf
* @return
*/
- protected Set getConfigurations(String rootModuleConf) {
- return (Set) rootModuleConfs.get(rootModuleConf);
+ protected Set<String> getConfigurations(String rootModuleConf) {
+ return rootModuleConfs.get(rootModuleConf);
}
- protected Set addAndGetConfigurations(String rootModuleConf) {
- Set depConfs = (Set) rootModuleConfs.get(rootModuleConf);
+ protected Set<String> addAndGetConfigurations(String rootModuleConf) {
+ Set<String> depConfs = rootModuleConfs.get(rootModuleConf);
if (depConfs == null) {
- depConfs = new HashSet();
+ depConfs = new HashSet<String>();
rootModuleConfs.put(rootModuleConf, depConfs);
}
return depConfs;
}
- protected Set /* <String> */getRootModuleConfigurations() {
+ protected Set<String> getRootModuleConfigurations() {
return rootModuleConfs.keySet();
}
- public void updateDataFrom(Collection/* <IvyNodeUsage> */usages, String rootModuleConf) {
- for (Iterator iterator = usages.iterator(); iterator.hasNext();) {
- IvyNodeUsage usage = (IvyNodeUsage) iterator.next();
+ public void updateDataFrom(Collection<IvyNodeUsage> usages, String rootModuleConf) {
+ for (IvyNodeUsage usage : usages) {
updateDataFrom(usage, rootModuleConf);
}
}
@@ -184,39 +187,28 @@ public class IvyNodeUsage {
updateMapOfSetForKey(usage.dependers, dependers, rootModuleConf);
}
- private void updateMapOfSet(Map from, Map to) {
- for (Iterator iter = from.keySet().iterator(); iter.hasNext();) {
- Object key = iter.next();
+ private <K, V> void updateMapOfSet(Map<K, Set<V>> from, Map<K, Set<V>> to) {
+ for (K key : from.keySet()) {
updateMapOfSetForKey(from, to, key);
}
}
- private void updateMapOfSetForKey(Map from, Map to, Object key) {
- Set set = (Set) from.get(key);
+ private <K, V> void updateMapOfSetForKey(Map<K, Set<V>> from, Map<K, Set<V>> to, K key) {
+ Set<V> set = from.get(key);
if (set != null) {
- Set toupdate = (Set) to.get(key);
+ Set<V> toupdate = to.get(key);
if (toupdate != null) {
toupdate.addAll(set);
} else {
- to.put(key, new HashSet(set));
+ to.put(key, new HashSet<V>(set));
}
}
}
- // protected void addDependencyArtifacts(String rootModuleConf,
- // DependencyArtifactDescriptor[] dependencyArtifacts) {
- // addObjectsForConf(rootModuleConf, Arrays.asList(dependencyArtifacts),
- // this.dependencyArtifacts);
- // }
- //
- // protected void addDependencyIncludes(String rootModuleConf, IncludeRule[] rules) {
- // addObjectsForConf(rootModuleConf, Arrays.asList(rules), dependencyIncludes);
- // }
- //
- private void addObjectsForConf(String rootModuleConf, Object objectToAdd, Map map) {
- Set set = (Set) map.get(rootModuleConf);
+ private <K, V> void addObjectsForConf(K rootModuleConf, V objectToAdd, Map<K, Set<V>> map) {
+ Set<V> set = map.get(rootModuleConf);
if (set == null) {
- set = new HashSet();
+ set = new HashSet<V>();
map.put(rootModuleConf, set);
}
set.add(objectToAdd);
@@ -226,14 +218,13 @@ public class IvyNodeUsage {
addObjectsForConf(rootModuleConf, new Depender(dd, parentConf), dependers);
}
- protected Set getDependencyArtifactsSet(String rootModuleConf) {
- Collection dependersInConf = (Collection) dependers.get(rootModuleConf);
+ protected Set<DependencyArtifactDescriptor> getDependencyArtifactsSet(String rootModuleConf) {
+ Collection<Depender> dependersInConf = dependers.get(rootModuleConf);
if (dependersInConf == null) {
return null;
}
- Set dependencyArtifacts = new HashSet();
- for (Iterator iterator = dependersInConf.iterator(); iterator.hasNext();) {
- Depender depender = (Depender) iterator.next();
+ Set<DependencyArtifactDescriptor> dependencyArtifacts = new HashSet<DependencyArtifactDescriptor>();
+ for (Depender depender : dependersInConf) {
DependencyArtifactDescriptor[] dads = depender.dd
.getDependencyArtifacts(depender.dependerConf);
dependencyArtifacts.addAll(Arrays.asList(dads));
@@ -241,14 +232,13 @@ public class IvyNodeUsage {
return dependencyArtifacts;
}
- protected Set getDependencyIncludesSet(String rootModuleConf) {
- Collection dependersInConf = (Collection) dependers.get(rootModuleConf);
+ protected Set<IncludeRule> getDependencyIncludesSet(String rootModuleConf) {
+ Collection<Depender> dependersInConf = dependers.get(rootModuleConf);
if (dependersInConf == null) {
return null;
}
- Set dependencyIncludes = new HashSet();
- for (Iterator iterator = dependersInConf.iterator(); iterator.hasNext();) {
- Depender depender = (Depender) iterator.next();
+ Set<IncludeRule> dependencyIncludes = new HashSet<IncludeRule>();
+ for (Depender depender : dependersInConf) {
IncludeRule[] rules = depender.dd.getIncludeRules(depender.dependerConf);
if (rules == null || rules.length == 0) {
// no include rule in at least one depender -> we must include everything,
@@ -293,7 +283,7 @@ public class IvyNodeUsage {
* @return the blacklist data if any
*/
protected IvyNodeBlacklist getBlacklistData(String rootModuleConf) {
- return (IvyNodeBlacklist) blacklisted.get(rootModuleConf);
+ return blacklisted.get(rootModuleConf);
}
protected IvyNode getNode() {
@@ -310,12 +300,11 @@ public class IvyNodeUsage {
* the given root module conf, <code>false</code> otherwise.
*/
public boolean hasTransitiveDepender(String rootModuleConf) {
- Set/* <Depender> */dependersSet = (Set) dependers.get(rootModuleConf);
+ Set<Depender> dependersSet = dependers.get(rootModuleConf);
if (dependersSet == null) {
return false;
}
- for (Iterator iterator = dependersSet.iterator(); iterator.hasNext();) {
- Depender depender = (Depender) iterator.next();
+ for (Depender depender : dependersSet) {
if (depender.dd.isTransitive()) {
return true;
}
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/util/filter/ArtifactTypeFilter.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/util/filter/ArtifactTypeFilter.java b/src/java/org/apache/ivy/util/filter/ArtifactTypeFilter.java
index 932a891..f3a0165 100644
--- a/src/java/org/apache/ivy/util/filter/ArtifactTypeFilter.java
+++ b/src/java/org/apache/ivy/util/filter/ArtifactTypeFilter.java
@@ -22,18 +22,14 @@ import java.util.Collection;
import org.apache.ivy.core.module.descriptor.Artifact;
-public class ArtifactTypeFilter implements Filter {
- private Collection acceptedTypes;
+public class ArtifactTypeFilter implements Filter<Artifact> {
+ private Collection<String> acceptedTypes;
- public ArtifactTypeFilter(Collection acceptedTypes) {
- this.acceptedTypes = new ArrayList(acceptedTypes);
+ public ArtifactTypeFilter(Collection<String> acceptedTypes) {
+ this.acceptedTypes = new ArrayList<String>(acceptedTypes);
}
- public boolean accept(Object o) {
- if (!(o instanceof Artifact)) {
- return false;
- }
- Artifact art = (Artifact) o;
+ public boolean accept(Artifact art) {
return acceptedTypes.contains(art.getType());
}
}
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/util/filter/Filter.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/util/filter/Filter.java b/src/java/org/apache/ivy/util/filter/Filter.java
index 2950e14..cfcd14a 100644
--- a/src/java/org/apache/ivy/util/filter/Filter.java
+++ b/src/java/org/apache/ivy/util/filter/Filter.java
@@ -17,6 +17,6 @@
*/
package org.apache.ivy.util.filter;
-public interface Filter {
- boolean accept(Object o);
+public interface Filter<T> {
+ boolean accept(T o);
}
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/util/filter/FilterHelper.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/util/filter/FilterHelper.java b/src/java/org/apache/ivy/util/filter/FilterHelper.java
index 9d59ccd..d491e2d 100644
--- a/src/java/org/apache/ivy/util/filter/FilterHelper.java
+++ b/src/java/org/apache/ivy/util/filter/FilterHelper.java
@@ -22,13 +22,15 @@ import java.util.Collection;
import java.util.Iterator;
import java.util.List;
+import org.apache.ivy.core.module.descriptor.Artifact;
+
public final class FilterHelper {
private FilterHelper() {
}
- public static final Filter NO_FILTER = NoFilter.INSTANCE;
+ public static final Filter<Artifact> NO_FILTER = NoFilter.instance();
- public static Filter getArtifactTypeFilter(String types) {
+ public static Filter<Artifact> getArtifactTypeFilter(String types) {
if (types == null || types.trim().equals("*")) {
return NO_FILTER;
}
@@ -36,11 +38,11 @@ public final class FilterHelper {
return getArtifactTypeFilter(t);
}
- public static Filter getArtifactTypeFilter(String[] types) {
+ public static Filter<Artifact> getArtifactTypeFilter(String[] types) {
if (types == null || types.length == 0) {
return NO_FILTER;
}
- List acceptedTypes = new ArrayList(types.length);
+ List<String> acceptedTypes = new ArrayList<String>(types.length);
for (int i = 0; i < types.length; i++) {
String current = types[i].trim();
if ("*".equals(current)) {
@@ -66,13 +68,13 @@ public final class FilterHelper {
* href="http://jakarta.apache.org/commons/collections/">Commons-Collections</a>
* facility for this. If we accepted to add dependencies on third party jars.
*/
- public static Collection filter(Collection col, Filter filter) {
+ public static <T> Collection<T> filter(Collection<T> col, Filter<T> filter) {
if (filter == null) {
return col;
}
- Collection ret = new ArrayList(col);
- for (Iterator iter = ret.iterator(); iter.hasNext();) {
- Object element = iter.next();
+ Collection<T> ret = new ArrayList<T>(col);
+ for (Iterator<T> iter = ret.iterator(); iter.hasNext();) {
+ T element = iter.next();
if (!filter.accept(element)) {
iter.remove();
}
http://git-wip-us.apache.org/repos/asf/ant-ivy/blob/6d2e199e/src/java/org/apache/ivy/util/filter/NoFilter.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/ivy/util/filter/NoFilter.java b/src/java/org/apache/ivy/util/filter/NoFilter.java
index 92dbbe5..cdaf88d 100644
--- a/src/java/org/apache/ivy/util/filter/NoFilter.java
+++ b/src/java/org/apache/ivy/util/filter/NoFilter.java
@@ -18,8 +18,13 @@
package org.apache.ivy.util.filter;
public final class NoFilter implements Filter {
+
public static final Filter INSTANCE = new NoFilter();
+ public static <T> Filter<T> instance() {
+ return INSTANCE;
+ }
+
private NoFilter() {
}
@@ -27,6 +32,7 @@ public final class NoFilter implements Filter {
return true;
}
+ @Override
public String toString() {
return "NoFilter";
}