Java Stack类代码示例

import com.intellij.util.containers.Stack; //导入依赖的package包/类
protected DfaMemoryStateImpl(DfaMemoryStateImpl toCopy) {
  myFactory = toCopy.myFactory;
  myEphemeral = toCopy.myEphemeral;
  myDefaultVariableStates = toCopy.myDefaultVariableStates; // shared between all states
  
  myStack = new Stack<DfaValue>(toCopy.myStack);
  myDistinctClasses = new TLongHashSet(toCopy.myDistinctClasses.toArray());
  myUnknownVariables = ContainerUtil.newLinkedHashSet(toCopy.myUnknownVariables);

  myEqClasses = ContainerUtil.newArrayList(toCopy.myEqClasses);
  myIdToEqClassesIndices = new MyIdMap(toCopy.myIdToEqClassesIndices.size());
  toCopy.myIdToEqClassesIndices.forEachEntry(new TIntObjectProcedure<int[]>() {
    @Override
    public boolean execute(int id, int[] set) {
      myIdToEqClassesIndices.put(id, set);
      return true;
    }
  });
  myVariableStates = ContainerUtil.newLinkedHashMap(toCopy.myVariableStates);
  
  myCachedDistinctClassPairs = toCopy.myCachedDistinctClassPairs;
  myCachedNonTrivialEqClasses = toCopy.myCachedNonTrivialEqClasses;
  myCachedHash = toCopy.myCachedHash;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@Nullable
public ControlFlow buildControlFlow() {
  myCatchStack = new Stack<CatchDescriptor>();
  myCurrentFlow = new ControlFlow(myFactory);
  try {
    myCodeFragment.accept(this);
  }
  catch (CannotAnalyzeException e) {
    return null;
  }

  PsiElement parent = myCodeFragment.getParent();
  if (parent instanceof PsiLambdaExpression && myCodeFragment instanceof PsiExpression) {
    generateBoxingUnboxingInstructionFor((PsiExpression)myCodeFragment,
                                         LambdaUtil.getFunctionalInterfaceReturnType((PsiLambdaExpression)parent));
    addInstruction(new CheckReturnValueInstruction(myCodeFragment));
  }

  addInstruction(new ReturnInstruction(false, null));

  if (Registry.is("idea.dfa.live.variables.analysis")) {
    new LiveVariablesAnalyzer(myCurrentFlow, myFactory).flushDeadVariablesOnStatementFinish();
  }

  return myCurrentFlow;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
public static boolean allOperandsAreLiterals(@Nullable final PsiExpression expression) {
  if (expression == null) return false;
  if (expression instanceof PsiLiteralExpression) return true;
  if (expression instanceof PsiPolyadicExpression) {
    Stack<PsiExpression> stack = new Stack<PsiExpression>();
    stack.add(expression);
    while (!stack.isEmpty()) {
      PsiExpression psiExpression = stack.pop();
      if (psiExpression instanceof PsiPolyadicExpression) {
        PsiPolyadicExpression binaryExpression = (PsiPolyadicExpression)psiExpression;
        for (PsiExpression op : binaryExpression.getOperands()) {
          stack.push(op);
        }
      }
      else if (!(psiExpression instanceof PsiLiteralExpression)) {
        return false;
      }
    }
    return true;
  }
  return false;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
public static Set<PsiMethod> calculateSiblingMethods(PsiMethod method) {
    final Set<PsiMethod> siblingMethods = new HashSet<PsiMethod>();
    final Stack<PsiMethod> pendingMethods = new Stack<PsiMethod>();
    pendingMethods.add(method);
    while(!pendingMethods.isEmpty())
    {
        final PsiMethod methodToAnalyze = pendingMethods.pop();
        siblingMethods.add(methodToAnalyze);
      final Iterable<PsiMethod> overridingMethods = OverridingMethodsSearch.search(methodToAnalyze, false);
        for (PsiMethod overridingMethod : overridingMethods) {
            if (!siblingMethods.contains(overridingMethod) &&
                    !pendingMethods.contains(overridingMethod)) {
                pendingMethods.add(overridingMethod);
            }
        }
        final PsiMethod[] superMethods = methodToAnalyze.findSuperMethods();
        for (PsiMethod superMethod : superMethods) {
            if (!siblingMethods.contains(superMethod) &&
                    !pendingMethods.contains(superMethod)) {
                pendingMethods.add(superMethod);
            }
        }
    }
    return siblingMethods;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@Override
public synchronized void initStateFrom(@NotNull final ProgressIndicator indicator) {
  myRunning = indicator.isRunning();
  myCanceled = indicator.isCanceled();
  myFraction = indicator.getFraction();
  myIndeterminate = indicator.isIndeterminate();
  myText = indicator.getText();

  myText2 = indicator.getText2();

  myFraction = indicator.getFraction();

  if (indicator instanceof ProgressIndicatorStacked) {
    ProgressIndicatorStacked stacked = (ProgressIndicatorStacked)indicator;

    myNonCancelableCount = stacked.getNonCancelableCount();

    myTextStack = new Stack<String>(stacked.getTextStack());

    myText2Stack = new Stack<String>(stacked.getText2Stack());

    myFractionStack = new DoubleArrayList(stacked.getFractionStack());
  }
  myShouldStartActivity = false;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@Override
public void visitPyParenthesizedExpression(final PyParenthesizedExpression expression) {
  final Stack<PsiElement> stack = new Stack<PsiElement>();
  stack.push(expression);
  while (!stack.isEmpty()) {
    PsiElement element = stack.pop();
    if (!(element instanceof PyTupleExpression)) {
      findProblem(element);
      if (element != null) {
        for (PsiElement psiElement : element.getChildren()) {
          stack.push(psiElement);
        }
      }
    }
  }
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
private static boolean isExceptionUsed(PyExceptPart node, String text) {
  Stack<PsiElement> stack = new Stack<PsiElement>();
  PyStatementList statementList = node.getStatementList();
  if (statementList != null) {
    for (PyStatement st : statementList.getStatements()) {
      stack.push(st);
      while (!stack.isEmpty()) {
        PsiElement e = stack.pop();
        if (e instanceof PyReferenceExpression) {
          PsiReference reference = e.getReference();
          if (reference != null) {
            PsiElement resolved = reference.resolve();
            if (resolved != null) {
              if (resolved.getText().equals(text))
                return true;
            }
          }
        }
        for (PsiElement psiElement : e.getChildren()) {
          stack.push(psiElement);
        }
      }
    }
  }
  return false;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
public static void removeBackSlash(PsiElement parent) {
  if (parent != null) {
    Stack<PsiElement> stack = new Stack<PsiElement>();
    if (parent instanceof PyParenthesizedExpression)
      stack.push(((PyParenthesizedExpression)parent).getContainedExpression());
    else
      stack.push(parent);
    while (!stack.isEmpty()) {
      PsiElement el = stack.pop();
      PsiWhiteSpace[] children = PsiTreeUtil.getChildrenOfType(el, PsiWhiteSpace.class);
      if (children != null) {
        for (PsiWhiteSpace ws : children) {
          if (ws.getText().contains("\\")) {
            ws.delete();
          }
        }
      }
      for (PsiElement psiElement : el.getChildren()) {
        stack.push(psiElement);
      }
    }
  }
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
private static boolean hasAssertOrYield(PyStatementList list) {
  Stack<PsiElement> stack = new Stack<PsiElement>();
    if (list != null) {
      for (PyStatement st : list.getStatements()) {
        stack.push(st);
        while (!stack.isEmpty()) {
          PsiElement e = stack.pop();
          if (e instanceof PyAssertStatement || e instanceof PyYieldExpression) return true;
          for (PsiElement psiElement : e.getChildren()) {
            stack.push(psiElement);
          }
        }
      }
    }
  return false;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@NotNull
@Override
protected List<RedmineProjectItem> fetch(@NotNull ProgressIndicator indicator) throws Exception {
  // Seems that Redmine always return its project hierarchy in DFS order.
  // So it's easy to find level of each project using stack of parents.
  Stack<RedmineProject> parents = new Stack<RedmineProject>();
  List<RedmineProjectItem> items = new ArrayList<RedmineProjectItem>();
  for (RedmineProject project : myRepository.fetchProjects()) {
    RedmineProject parentProject = project.getParent();
    if (parentProject == null) {
      items.add(new RedmineProjectItem(project, 0));
      parents.clear();
    }
    else {
      while (!parents.isEmpty() && !parents.peek().equals(parentProject)) {
        parents.pop();
      }
      items.add(new RedmineProjectItem(project, parents.size()));
    }
    parents.push(project);
  }
  return items;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private <T> void ensureTheDataIsReadyToUse(@NotNull Collection<DataNode<T>> nodes) {
  Map<Key<?>, List<ProjectDataService<?, ?>>> servicesByKey = myServices.getValue();
  Stack<DataNode<T>> toProcess = ContainerUtil.newStack(nodes);
  while (!toProcess.isEmpty()) {
    DataNode<T> node = toProcess.pop();
    List<ProjectDataService<?, ?>> services = servicesByKey.get(node.getKey());
    if (services != null) {
      for (ProjectDataService<?, ?> service : services) {
        node.prepareData(service.getClass().getClassLoader());
      }
    }

    for (DataNode<?> dataNode : node.getChildren()) {
      toProcess.push((DataNode<T>)dataNode);
    }
  }
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@Override
public synchronized void initStateFrom(@NotNull final ProgressIndicator indicator) {
  myRunning = indicator.isRunning();
  myCanceled = indicator.isCanceled();
  myFraction = indicator.getFraction();
  myIndeterminate = indicator.isIndeterminate();
  myText = indicator.getText();

  myText2 = indicator.getText2();

  myFraction = indicator.getFraction();

  if (indicator instanceof ProgressIndicatorStacked) {
    ProgressIndicatorStacked stacked = (ProgressIndicatorStacked)indicator;

    myNonCancelableCount = stacked.getNonCancelableCount();

    myTextStack = new Stack<String>(stacked.getTextStack());

    myText2Stack = new Stack<String>(stacked.getText2Stack());

    myFractionStack = new DoubleArrayList(stacked.getFractionStack());
  }
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
private boolean reevaluate(Project context) {
  this.context = context;
  boolean ret = false;
  if (isComplete()) {
    try {
      Stack<ASTNode> rpn = infixToRPN();
      String rpnString = LOG.isDebugEnabled() ? tokensToString(rpn) : null;
      ret = objectIsTrue(calculateRPN(rpn));
      if (LOG.isDebugEnabled()) {  // Don't create the strings unless we are debugging them...
        LOG.debug(toString() + " --> " + rpnString + " ==> " + (ret ? "true" : "false"));
      }
      if (!rpn.isEmpty()) {
        throw new CalculationException("Invalid Expression: Tokens left after calculating: " + rpn.toString());
      }
    } catch (CalculationException e) {
      String msg = "Error calculating conditional compiler expression '" + toString() + "'";
      // Add stack info if in debug mode.
      LOG.info( msg, LOG.isDebugEnabled() ? e : null );
    }
  }
  return ret;
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private <T> void ensureTheDataIsReadyToUse(@Nonnull Collection<DataNode<T>> nodes) {
  Map<Key<?>, List<ProjectDataService<?, ?>>> servicesByKey = myServices.getValue();
  Stack<DataNode<T>> toProcess = ContainerUtil.newStack(nodes);
  while (!toProcess.isEmpty()) {
    DataNode<T> node = toProcess.pop();
    List<ProjectDataService<?, ?>> services = servicesByKey.get(node.getKey());
    if (services != null) {
      for (ProjectDataService<?, ?> service : services) {
        node.prepareData(service.getClass().getClassLoader());
      }
    }

    for (DataNode<?> dataNode : node.getChildren()) {
      toProcess.push((DataNode<T>)dataNode);
    }
  }
}
 

import com.intellij.util.containers.Stack; //导入依赖的package包/类
public static void enterModal(Project project, Dialog dialog) {
  LOG.assertTrue(isDispatchThread(), "enterModal() should be invoked in event-dispatch thread");

  if (LOG.isDebugEnabled()) {
    LOG.debug("enterModal:" + dialog.getName() + " ; for project: " + project.getName());
  }

  if (project == null) {
    enterModal(dialog);
    return;
  }

  ourModalityStateMulticaster.getMulticaster().beforeModalityStateChanged(true);

  List<Dialog> modalEntitiesList = projectToModalEntities.getOrDefault(project, ContainerUtil.createLockFreeCopyOnWriteList());
  projectToModalEntities.put(project, modalEntitiesList);
  modalEntitiesList.add(dialog);

  Stack<ModalityState> modalEntitiesStack = projectToModalEntitiesStack.getOrDefault(project, new Stack<>(ModalityState.NON_MODAL));
  projectToModalEntitiesStack.put(project, modalEntitiesStack);
  modalEntitiesStack.push(new ModalityStateEx(ArrayUtil.toObjectArray(ourModalEntities)));
}