src/jdk.jdeps/share/classes/com/sun/tools/jdeps/Graph.java

*** 1,7 ****
  /*
!  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
--- 1,7 ----
  /*
!  * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
*** 23,44 ****
   * questions.
   */
  package com.sun.tools.jdeps;
  
  import java.io.PrintWriter;
! import java.lang.module.ModuleDescriptor;
! import java.lang.module.ModuleFinder;
! import java.lang.module.ModuleReference;
  import java.util.Collections;
  import java.util.Deque;
  import java.util.HashMap;
  import java.util.HashSet;
- import java.util.LinkedList;
  import java.util.Map;
  import java.util.Set;
  import java.util.function.Consumer;
- import java.util.function.Predicate;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  
  public final class Graph<T> {
      private final Set<T> nodes;
--- 23,40 ----
   * questions.
   */
  package com.sun.tools.jdeps;
  
  import java.io.PrintWriter;
! import java.util.ArrayDeque;
  import java.util.Collections;
  import java.util.Deque;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import java.util.function.Consumer;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  
  public final class Graph<T> {
      private final Set<T> nodes;
*** 159,169 ****
  
      /**
       * Returns all nodes reachable from the given set of roots.
       */
      public Set<T> dfs(Set<T> roots) {
!         Deque<T> deque = new LinkedList<>(roots);
          Set<T> visited = new HashSet<>();
          while (!deque.isEmpty()) {
              T u = deque.pop();
              if (!visited.contains(u)) {
                  visited.add(u);
--- 155,165 ----
  
      /**
       * Returns all nodes reachable from the given set of roots.
       */
      public Set<T> dfs(Set<T> roots) {
!         Deque<T> deque = new ArrayDeque<>(roots);
          Set<T> visited = new HashSet<>();
          while (!deque.isEmpty()) {
              T u = deque.pop();
              if (!visited.contains(u)) {
                  visited.add(u);
*** 195,205 ****
              return false;
          }
          if (includeAdjacent && isAdjacent(u, v)) {
              return true;
          }
!         Deque<T> stack = new LinkedList<>();
          Set<T> visited = new HashSet<>();
          stack.push(u);
          while (!stack.isEmpty()) {
              T node = stack.pop();
              if (node.equals(v)) {
--- 191,201 ----
              return false;
          }
          if (includeAdjacent && isAdjacent(u, v)) {
              return true;
          }
!         Deque<T> stack = new ArrayDeque<>();
          Set<T> visited = new HashSet<>();
          stack.push(u);
          while (!stack.isEmpty()) {
              T node = stack.pop();
              if (node.equals(v)) {
*** 290,305 ****
  
      /**
       * Topological sort
       */
      static class TopoSorter<T> {
!         final Deque<T> result = new LinkedList<>();
!         final Deque<T> nodes;
          final Graph<T> graph;
          TopoSorter(Graph<T> graph) {
              this.graph = graph;
-             this.nodes = new LinkedList<>(graph.nodes);
              sort();
          }
  
          public void ordered(Consumer<T> action) {
              result.iterator().forEachRemaining(action);
--- 286,299 ----
  
      /**
       * Topological sort
       */
      static class TopoSorter<T> {
!         final Deque<T> result = new ArrayDeque<>();
          final Graph<T> graph;
          TopoSorter(Graph<T> graph) {
              this.graph = graph;
              sort();
          }
  
          public void ordered(Consumer<T> action) {
              result.iterator().forEachRemaining(action);
*** 308,328 ****
          public void reverse(Consumer<T> action) {
              result.descendingIterator().forEachRemaining(action);
          }
  
          private void sort() {
!             Deque<T> visited = new LinkedList<>();
!             Deque<T> done = new LinkedList<>();
!             T node;
!             while ((node = nodes.poll()) != null) {
                  if (!visited.contains(node)) {
                      visit(node, visited, done);
                  }
              }
          }
  
!         private void visit(T node, Deque<T> visited, Deque<T> done) {
              if (visited.contains(node)) {
                  if (!done.contains(node)) {
                      throw new IllegalArgumentException("Cyclic detected: " +
                          node + " " + graph.edges().get(node));
                  }
--- 302,321 ----
          public void reverse(Consumer<T> action) {
              result.descendingIterator().forEachRemaining(action);
          }
  
          private void sort() {
!             Set<T> visited = new HashSet<>();
!             Set<T> done = new HashSet<>();
!             for (T node : graph.nodes()) {
                  if (!visited.contains(node)) {
                      visit(node, visited, done);
                  }
              }
          }
  
!         private void visit(T node, Set<T> visited, Set<T> done) {
              if (visited.contains(node)) {
                  if (!done.contains(node)) {
                      throw new IllegalArgumentException("Cyclic detected: " +
                          node + " " + graph.edges().get(node));
                  }