public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) { Graph<String> g = new Graph<String>(); List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>(); for (String fileName : fileNames) { g.addEdge(grammarName, vocabName); g.addEdge(grammarName, grammarName); List<String> sortedGrammarNames = g.sort();
public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) { Graph<String> g = new Graph<String>(); List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>(); for (String fileName : fileNames) { g.addEdge(grammarName, vocabName); g.addEdge(grammarName, grammarName); List<String> sortedGrammarNames = g.sort();
public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) { Graph<String> g = new Graph<String>(); List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>(); for (String fileName : fileNames) { vocabName = vocabName.substring(lastSlash + 1); g.addEdge(grammarName, vocabName); g.addEdge(grammarName, grammarName); List<String> sortedGrammarNames = g.sort();
public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) { Graph<String> g = new Graph<String>(); List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>(); for (String fileName : fileNames) { vocabName = vocabName.substring(lastSlash + 1); g.addEdge(grammarName, vocabName); g.addEdge(grammarName, grammarName); List<String> sortedGrammarNames = g.sort();
public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) { Graph<String> g = new Graph<String>(); List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>(); for (String fileName : fileNames) { vocabName = vocabName.substring(lastSlash + 1); g.addEdge(grammarName, vocabName); g.addEdge(grammarName, grammarName); List<String> sortedGrammarNames = g.sort();
public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
public void DFS(Node<T> n, Set<Node<T>> visited, ArrayList<T> sorted) { if ( visited.contains(n) ) return; visited.add(n); if ( n.edges!=null ) { for (Node<T> target : n.edges) { DFS(target, visited, sorted); } } sorted.add(n.payload); } }
/** DFS-based topological sort. A valid sort is the reverse of * the post-order DFA traversal. Amazingly simple but true. * For sorting, I'm not following convention here since ANTLR * needs the opposite. Here's what I assume for sorting: * * If there exists an edge u -> v then u depends on v and v * must happen before u. * * So if this gives nonreversed postorder traversal, I get the order * I want. */ public List<T> sort() { Set<Node<T>> visited = new OrderedHashSet<Node<T>>(); ArrayList<T> sorted = new ArrayList<T>(); while ( visited.size() < nodes.size() ) { // pick any unvisited node, n Node<T> n = null; for (Node<T> tNode : nodes.values()) { n = tNode; if ( !visited.contains(n) ) break; } if (n!=null) { // if at least one unvisited DFS(n, visited, sorted); } } return sorted; }
private void explore(String grammarName, Collection<String> result) { for (Graph.Node<String> node : graph.getNode(grammarName).edges) { result.add(node.payload); explore(node.payload, result); } }
/** DFS-based topological sort. A valid sort is the reverse of * the post-order DFA traversal. Amazingly simple but true. * For sorting, I'm not following convention here since ANTLR * needs the opposite. Here's what I assume for sorting: * * If there exists an edge u -> v then u depends on v and v * must happen before u. * * So if this gives nonreversed postorder traversal, I get the order * I want. */ public List<T> sort() { Set<Node<T>> visited = new OrderedHashSet<Node<T>>(); ArrayList<T> sorted = new ArrayList<T>(); while ( visited.size() < nodes.size() ) { // pick any unvisited node, n Node<T> n = null; for (Node<T> tNode : nodes.values()) { n = tNode; if ( !visited.contains(n) ) break; } if (n!=null) { // if at least one unvisited DFS(n, visited, sorted); } } return sorted; }