public void visitOutgoingDependencies(Collection<DependencyEdge> target) {
      // If this configuration's version is in conflict, don't do anything
      // If not traversed before, add all selected outgoing edges
      // If traversed before, and the selected modules have changed, remove previous outgoing edges
      // and add outgoing edges again with
      //    the new selections.
      // If traversed before, and the selected modules have not changed, ignore
      // If none of the incoming edges are transitive, then the node has no outgoing edges

      if (moduleRevision.state != ModuleState.Selected) {
        LOGGER.debug("version for {} is not selected. ignoring.", this);
        return;
      }

      List<DependencyEdge> transitiveIncoming = new ArrayList<DependencyEdge>();
      for (DependencyEdge edge : incomingEdges) {
        if (edge.isTransitive()) {
          transitiveIncoming.add(edge);
        }
      }

      if (transitiveIncoming.isEmpty() && this != resolveState.root) {
        if (previousTraversal != null) {
          removeOutgoingEdges();
        }
        if (incomingEdges.isEmpty()) {
          LOGGER.debug("{} has no incoming edges. ignoring.", this);
        } else {
          LOGGER.debug("{} has no transitive incoming edges. ignoring outgoing edges.", this);
        }
        return;
      }

      ModuleResolutionFilter resolutionFilter = getSelector(transitiveIncoming);
      if (previousTraversal != null) {
        if (previousTraversal.acceptsSameModulesAs(resolutionFilter)) {
          LOGGER.debug(
              "Changed edges for {} selects same versions as previous traversal. ignoring", this);
          // Don't need to traverse again, but hang on to the new filter as the set of artifact may
          // have changed
          previousTraversal = resolutionFilter;
          return;
        }
        removeOutgoingEdges();
      }

      for (DependencyMetaData dependency : metaData.getDependencies()) {
        ModuleIdentifier targetModuleId =
            DefaultModuleIdentifier.newId(
                dependency.getRequested().getGroup(), dependency.getRequested().getName());
        if (isExcluded(resolutionFilter, targetModuleId)) {
          continue;
        }
        DependencyEdge dependencyEdge =
            new DependencyEdge(this, dependency, resolutionFilter, resolveState);
        outgoingEdges.add(dependencyEdge);
        target.add(dependencyEdge);
      }
      previousTraversal = resolutionFilter;
    }
 @Override
 public String toString() {
   return String.format(
       "%s -> %s(%s)",
       from.toString(),
       dependencyMetaData.getRequested(),
       Joiner.on(',').join(dependencyMetaData.getModuleConfigurations()));
 }
 private void transformDependencies(BuildableModuleVersionMetaDataResolveResult result) {
   MutableModuleVersionMetaData metaData = result.getMetaData();
   List<DependencyMetaData> transformed = new ArrayList<DependencyMetaData>();
   for (DependencyMetaData dependency : metaData.getDependencies()) {
     transformed.add(
         dependency.withRequestedVersion(
             dependency.getDescriptor().getDynamicConstraintDependencyRevisionId().getRevision()));
   }
   metaData.setDependencies(transformed);
 }
 public void resolve(DependencyMetaData dependency, BuildableComponentIdResolveResult result) {
   if (dependency.getSelector() instanceof ProjectComponentSelector) {
     ProjectComponentSelector selector = (ProjectComponentSelector) dependency.getSelector();
     String projectPath = selector.getProjectPath();
     LocalComponentMetaData componentMetaData = projectComponentRegistry.getProject(projectPath);
     if (componentMetaData == null) {
       result.failed(
           new ModuleVersionResolveException(
               selector, "project '" + projectPath + "' not found."));
     } else {
       result.resolved(componentMetaData.toResolveMetaData());
     }
   }
 }
 public ModuleVersionSelectorResolveState getSelector(DependencyMetaData dependencyMetaData) {
   ModuleVersionSelector requested = dependencyMetaData.getRequested();
   ModuleVersionSelectorResolveState resolveState = selectors.get(requested);
   if (resolveState == null) {
     resolveState = new ModuleVersionSelectorResolveState(dependencyMetaData, idResolver, this);
     selectors.put(requested, resolveState);
   }
   return resolveState;
 }
 private ModuleVersionSelectorResolveState(
     DependencyMetaData dependencyMetaData,
     DependencyToComponentIdResolver resolver,
     ResolveState resolveState) {
   this.dependencyMetaData = dependencyMetaData;
   this.resolver = resolver;
   this.resolveState = resolveState;
   targetModule =
       resolveState.getModule(
           new DefaultModuleIdentifier(
               dependencyMetaData.getRequested().getGroup(),
               dependencyMetaData.getRequested().getName()));
 }
 @Override
 public String toString() {
   return dependencyMetaData.toString();
 }
 public Set<ComponentArtifactMetaData> getArtifacts(ConfigurationMetaData metaData1) {
   return dependencyMetaData.getArtifacts(from.metaData, metaData1);
 }
 // TODO This should be replaced by getRequested()
 public ModuleVersionSelector getRequestedModuleVersion() {
   return dependencyMetaData.getRequested();
 }
 public ComponentSelector getRequested() {
   return dependencyMetaData.getSelector();
 }
 public ModuleResolutionFilter getSelector() {
   Set<String> hierarchy = from.metaData.getHierarchy();
   ModuleResolutionFilter selector =
       DefaultModuleResolutionFilter.excludeAny(dependencyMetaData.getExcludeRules(hierarchy));
   return selector.intersect(resolutionFilter);
 }
 public boolean isTransitive() {
   return from.isTransitive() && dependencyMetaData.isTransitive();
 }