private void flushParents(List<Record> willReturn){ Stack<RepeatedRecordInfo> reverseStack = new Stack<>(); while(!stack.isEmpty()){ reverseStack.push(stack.pop()); } while(!reverseStack.isEmpty()){ RepeatedRecordInfo info = reverseStack.pop(); info.timesSeen -= 1; flush(info, willReturn); stack.push(info); } }
@Test public void testGetCurrentStackTrace() throws Exception { final Stack<Class<?>> classes = StackLocatorUtil.getCurrentStackTrace(); final Stack<Class<?>> reversed = new Stack<>(); reversed.ensureCapacity(classes.size()); while (!classes.empty()) { reversed.push(classes.pop()); } while (reversed.peek() != StackLocatorUtil.class) { reversed.pop(); } reversed.pop(); // ReflectionUtil assertSame(StackLocatorUtilTest.class, reversed.pop()); }
private static List<SQLSelectQueryBlock> splitSQLSelectQuery(SQLSelectQuery x) { List<SQLSelectQueryBlock> groupList = new ArrayList<SQLSelectQueryBlock>(); Stack<SQLSelectQuery> stack = new Stack<SQLSelectQuery>(); stack.push(x); do { SQLSelectQuery query = stack.pop(); if (query instanceof SQLSelectQueryBlock) { groupList.add((SQLSelectQueryBlock) query); } else if (query instanceof SQLUnionQuery) { SQLUnionQuery unionQuery = (SQLUnionQuery) query; stack.push(unionQuery.getLeft()); stack.push(unionQuery.getRight()); } } while (!stack.empty()); return groupList; }
private void visit(N p) throws CycleDetectedException { if (!visited.add(p)) return; visiting.add(p); path.push(p); for (N q : getEdges(p)) { if (q==null) continue; // ignore unresolved references if (visiting.contains(q)) detectedCycle(q); visit(q); } visiting.remove(p); path.pop(); topologicalOrder.add(p); }
private Set<AbstractProject> getTransitive(Map<AbstractProject, List<DependencyGroup>> direction, AbstractProject src, boolean up) { Set<AbstractProject> visited = new HashSet<AbstractProject>(); Stack<AbstractProject> queue = new Stack<AbstractProject>(); queue.add(src); while(!queue.isEmpty()) { AbstractProject p = queue.pop(); for (AbstractProject child : get(direction,p,up)) { if(visited.add(child)) queue.add(child); } } return visited; }
private void validateRootExists(CaseInsensitiveString root, PipelineDependencyState pipelineDependencyState, Stack<CaseInsensitiveString> visiting) throws Exception { if (!pipelineDependencyState.hasPipeline(root)) { StringBuffer sb = new StringBuffer("Pipeline \""); sb.append(root); sb.append("\" does not exist."); visiting.pop(); if (!visiting.empty()) { CaseInsensitiveString parent = visiting.peek(); sb.append(" It is used from pipeline \""); sb.append(parent); sb.append("\"."); } throw new Exception(sb.toString()); } }
/** * Returns true if a project has a non-direct dependency to another project. * <p> * A non-direct dependency is a path of dependency "edge"s from the source to the destination, * where the length is greater than 1. */ public boolean hasIndirectDependencies(AbstractProject src, AbstractProject dst) { Set<AbstractProject> visited = new HashSet<AbstractProject>(); Stack<AbstractProject> queue = new Stack<AbstractProject>(); queue.addAll(getDownstream(src)); queue.remove(dst); while(!queue.isEmpty()) { AbstractProject p = queue.pop(); if(p==dst) return true; if(visited.add(p)) queue.addAll(getDownstream(p)); } return false; }
@Test public void testDataIntegrityWithBufferedReader() throws URISyntaxException, IOException { final File testFileIso = new File(this.getClass().getResource("/" + fileName).toURI()); reversedLinesFileReader = new ReversedLinesFileReader(testFileIso, buffSize, encoding); final Stack<String> lineStack = new Stack<>(); bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(testFileIso), encoding)); String line = null; // read all lines in normal order while ((line = bufferedReader.readLine()) != null) { lineStack.push(line); } // read in reverse order and compare with lines from stack while ((line = reversedLinesFileReader.readLine()) != null) { final String lineFromBufferedReader = lineStack.pop(); assertEquals(lineFromBufferedReader, line); } }
private Set<Class> findAllInterfacesInHierarchy(Class candidateGoExtensionClass) { Stack<Class> classesInHierarchy = new Stack<>(); classesInHierarchy.add(candidateGoExtensionClass); Set<Class> interfaces = new HashSet<>(); while (!classesInHierarchy.empty()) { Class classToCheckFor = classesInHierarchy.pop(); if (classToCheckFor.isInterface()) { interfaces.add(classToCheckFor); } classesInHierarchy.addAll(Arrays.asList(classToCheckFor.getInterfaces())); if (classToCheckFor.getSuperclass() != null) { classesInHierarchy.add(classToCheckFor.getSuperclass()); } } return interfaces; }
public TableNestChecker() { elements.push(ALL_ALLOWED); }
public FileSequentialCollectionIterator() { // log.info("Coll is " + coll); roots = coll.toArray(); rootsIndex = 0; fileArrayStack = new Stack<>(); fileArrayStackIndices = new Stack<>(); if (roots.length > 0) { fileArrayStack.add(roots[rootsIndex]); fileArrayStackIndices.push(Integer.valueOf(0)); } next = primeNextFile(); }
public void moveUp() { pointers.pop(); }