示例#1
0
 /**
  * Called when a change is made to a configuration node, such that its dependency graph
  * <em>may</em> now be larger than it previously was, and the node should be visited.
  */
 public void onMoreSelected(ConfigurationNode configuration) {
   // Add to the end of the queue, so that we traverse the graph in breadth-wise order to pick up
   // as many conflicts as
   // possible before attempting to resolve them
   if (queued.add(configuration)) {
     queue.addLast(configuration);
   }
 }
示例#2
0
 /**
  * Called when a change is made to a configuration node, such that its dependency graph
  * <em>may</em> now be smaller than it previously was, and the node should be visited.
  */
 public void onFewerSelected(ConfigurationNode configuration) {
   // Add to the front of the queue, to flush out configurations that are no longer required.
   if (queued.add(configuration)) {
     queue.addFirst(configuration);
   }
 }
示例#3
0
 public ConfigurationNode peek() {
   return queue.isEmpty() ? null : queue.getFirst();
 }
示例#4
0
 public ConfigurationNode pop() {
   ConfigurationNode next = queue.removeFirst();
   queued.remove(next);
   return next;
 }
示例#5
0
    private Collection<List<ModuleVersionIdentifier>> calculatePaths(
        BrokenDependency brokenDependency) {
      // Include the shortest path from each version that has a direct dependency on the broken
      // dependency, back to the root

      Map<ModuleVersionResolveState, List<ModuleVersionIdentifier>> shortestPaths =
          new LinkedHashMap<ModuleVersionResolveState, List<ModuleVersionIdentifier>>();
      List<ModuleVersionIdentifier> rootPath = new ArrayList<ModuleVersionIdentifier>();
      rootPath.add(root.moduleRevision.id);
      shortestPaths.put(root.moduleRevision, rootPath);

      Set<ModuleVersionResolveState> directDependees =
          new LinkedHashSet<ModuleVersionResolveState>();
      for (ConfigurationNode node : brokenDependency.requiredBy) {
        directDependees.add(node.moduleRevision);
      }

      Set<ModuleVersionResolveState> seen = new HashSet<ModuleVersionResolveState>();
      LinkedList<ModuleVersionResolveState> queue = new LinkedList<ModuleVersionResolveState>();
      queue.addAll(directDependees);
      while (!queue.isEmpty()) {
        ModuleVersionResolveState version = queue.getFirst();
        if (version == root.moduleRevision) {
          queue.removeFirst();
        } else if (seen.add(version)) {
          for (ConfigurationNode configuration : version.configurations) {
            for (DependencyEdge dependencyEdge : configuration.incomingEdges) {
              queue.add(0, dependencyEdge.from.moduleRevision);
            }
          }
        } else {
          queue.remove();
          List<ModuleVersionIdentifier> shortest = null;
          for (ConfigurationNode configuration : version.configurations) {
            for (DependencyEdge dependencyEdge : configuration.incomingEdges) {
              List<ModuleVersionIdentifier> candidate =
                  shortestPaths.get(dependencyEdge.from.moduleRevision);
              if (candidate == null) {
                continue;
              }
              if (shortest == null) {
                shortest = candidate;
              } else if (shortest.size() > candidate.size()) {
                shortest = candidate;
              }
            }
          }
          if (shortest == null) {
            continue;
          }
          List<ModuleVersionIdentifier> path = new ArrayList<ModuleVersionIdentifier>();
          path.addAll(shortest);
          path.add(version.id);
          shortestPaths.put(version, path);
        }
      }

      List<List<ModuleVersionIdentifier>> paths = new ArrayList<List<ModuleVersionIdentifier>>();
      for (ModuleVersionResolveState version : directDependees) {
        List<ModuleVersionIdentifier> path = shortestPaths.get(version);
        paths.add(path);
      }
      return paths;
    }