How to use

Stack

in

java.util

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);
  }
}

private GroovySourceAST getParentNode() {
  GroovySourceAST parentNode = null;
  GroovySourceAST currentNode = stack.pop();
  if (!stack.empty()) {
    parentNode = stack.peek();
  }
  stack.push(currentNode);
  return parentNode;
}

private void detectedCycle(N q) throws CycleDetectedException {
  int i = path.indexOf(q);
  path.push(q);
  reactOnCycle(q, path.subList(i, path.size()));
}

 @Override
 void advance() {
  if (searchStack.isEmpty()) {
   next = null;
  } else {
   next = searchStack.pop();
  }
 }
};

private State currentState() {
 if (myStates.size() > 0) {
  return myStates.peek();
 }
 else {
  return myDefaultState;
 }
}

@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;
}

synchronized void push(RunExecution r) {
  Executor e = Executor.currentExecutor();
  Stack<RunExecution> s = stack.get(e);
  if(s==null) stack.put(e,s=new Stack<RunExecution>());
  s.push(r);
}

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;
}

public Object peek(String name) {
 Map<String,Object> vars = threadLocalVariables.get();
 if (vars == null) return null;
 Stack<Object> stack = (Stack<Object>) vars.get(name);
 if (stack == null || stack.isEmpty()) {
  return null;
 } else {
  return stack.peek();
 }
}

@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;
}

@Override
public void initialize() {
 searchStack = new Stack<>();
 for (int i = t.numChildren() - 1; i >= 0; i--) {
  searchStack.push(t.getChild(i));
 }
 if (!searchStack.isEmpty()) {
  advance();
 }
}

public TableNestChecker() {
  elements.push(ALL_ALLOWED);
}

/**
 * Pop the last signal
 */
public Signal signalPop() {
 if (!exec.signals.empty()) {
  return exec.signals.pop();
 }
 return null;
}

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();
}