/** * Depth-first search on the dependency graph. The correctness of this algorithm follows from the * invariant that a function is only added to the output after all its dependencies have been * added. * * @param n name of the function to be visited * @param refs adjacency map * @param marked already visited nodes * @param stack stack of current nodes * @param out output list * @param equiv equivalence classes */ private void visit( final Name n, final Map<Name, Set<Name>> refs, final Set<Name> marked, final Stack<Name> stack, final List<Name> out, final Map<Name, Set<Name>> equiv) { if (marked.add(n)) { // name wasn't marked stack.push(n); for (final Name name : refs.get(n)) { visit(name, refs, marked, stack, out, equiv); } out.add(stack.pop()); } else { final int pos = stack.lastIndexOf(n); if (pos >= 0) { final Set<Name> eqClass = new HashSet<Name>(); for (final Name eq : stack.subList(pos, stack.size())) { eqClass.add(eq); final Set<Name> old = equiv.get(eq); if (old != null) { eqClass.addAll(old); } } for (final Name nm : eqClass) { equiv.put(nm, eqClass); } } } }
private String listItem(ParserInput parserInput, String raw) { Stack listOpenStack = retrieveStack(parserInput, LIST_OPEN_STACK); Stack listCloseStack = retrieveStack(parserInput, LIST_CLOSE_STACK); StringBuffer output = new StringBuffer(); // build a stack of html tags based on current values passed to lexer Stack currentOpenStack = tagsToStack(raw); String currentItemOpenTag = (String) currentOpenStack.peek(); String currentItemCloseTag = (String) listCloseHash.get(currentItemOpenTag); // if list was previously open to a greater depth, close the old list while (listOpenStack.size() > currentOpenStack.size()) { listOpenStack.pop(); output.append(listCloseStack.pop()); } if (this.listStackEquals(currentOpenStack, listOpenStack)) { // if continuing same list close previous list item & open new item output.append(listCloseStack.pop()); listCloseStack.push(currentItemCloseTag); output.append(currentItemOpenTag); } else { // look for differences in the old list stack and the new list stack int pos = 0; while (pos < listOpenStack.size()) { if (!this.listStackEquals( currentOpenStack.subList(0, pos + 1), listOpenStack.subList(0, pos + 1))) { break; } pos++; } // if any differences found process them while (listOpenStack.size() > pos) { listOpenStack.pop(); output.append(listCloseStack.pop()); } // continue processing differences for (int i = pos; i < currentOpenStack.size(); i++) { String openTag = (String) currentOpenStack.elementAt(i); String closeTag = (String) listCloseHash.get(openTag); listOpenStack.push(openTag); listCloseStack.push(closeTag); output.append(openTag); } } updateStack(parserInput, listOpenStack, LIST_OPEN_STACK); updateStack(parserInput, listCloseStack, LIST_CLOSE_STACK); return output.toString(); }
public void execute(ExecutionContext context) { Stack<Object> stack = context.getStack(); int n = ((Number) stack.pop()).intValue(); if (n > 0) { int size = stack.size(); // Need to copy to a new list to avoid ConcurrentModificationException List<Object> copy = new java.util.ArrayList<Object>(stack.subList(size - n, size)); stack.addAll(copy); } }
private void readVector(Stack<String> stack) { int start = getListStart(stack); int end = getListEnd(stack); List<String> subList = stack.subList(start, end); for (String item : subList) { if (item.equals(LIST_START) || item.equals(LIST_END)) continue; list.add(new FieldElement("", item)); } subList.clear(); }
private void readScalarList(Stack<String> stack) { int start = 1; int end = stack.size() - 1; List<String> subList = stack.subList(start, end); for (String item : subList) { if (item.equals(LIST_START) || item.equals(LIST_END)) continue; list.add(new FieldElement("", item)); } subList.clear(); }
@Test public void testStackPartialEq() { Stack<String> s1 = new Stack<String>(); Stack<String> s2 = new Stack<String>(); for (String s : MapLinkGeoJsonParseContext.Data_Feature.getPath()) { s1.push(s); } for (String s : MapLinkGeoJsonParseContext.Data_Feature.getPath()) { s2.push(new String(s)); } s2.push("[#]"); assertTrue(s1.equals(s2.subList(0, s1.size()))); assertTrue(!s1.equals(s2)); }
private static <T> void processDependencyMap( T selected, Stack<T> callStack, Map<T, Set<T>> dependencies, Set<T> processed, Processor<T> processor, SubMonitor subMonitor) throws CoreException, CircularDependencyException { if (processed.contains(selected)) return; // Check for cycles int stackIndex = callStack.indexOf(selected); if (stackIndex != -1) { List<T> subList = callStack.subList(stackIndex, callStack.size()); List<T> cycle = new ArrayList<T>(subList.size() + 1); cycle.addAll(subList); cycle.add(selected); throw new CircularDependencyException(cycle); } try { callStack.push(selected); Set<T> selectedDeps = dependencies.get(selected); // Process dependencies first if (selectedDeps != null) { for (T dep : selectedDeps) { processDependencyMap(dep, callStack, dependencies, processed, processor, subMonitor); } } // Process the selection processor.process(selected, subMonitor.newChild(1)); processed.add(selected); } finally { callStack.pop(); } }
/** @return The collection of persistence units that we have parsed */ public List<PersistenceUnitImpl> getPersistenceUnits() { return persistenceUnits.subList(0, persistenceUnits.size()); }