Java Stack.pop方法代码示例

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 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包/类
@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包/类
@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包/类
private boolean isCalledOnlyFrom(RefJavaElement refElement, Stack<RefJavaElement> callStack) {
  if (callStack.contains(this)) return refElement == this;
  if (getInReferences().isEmpty()) return false;

  if (refElement instanceof RefMethod) {
    RefMethod refMethod = (RefMethod) refElement;
    for (RefMethod refSuper : refMethod.getSuperMethods()) {
      if (!refSuper.getInReferences().isEmpty()) return false;
    }
    if (refMethod.isConstructor()){
      boolean unreachable = true;
      for (RefElement refOut : refMethod.getOutReferences()){
        unreachable &= !refOut.isReachable();
      }
      if (unreachable) return true;
    }
  }

  callStack.push(this);
  for (RefElement refCaller : getInReferences()) {
    if (!((RefElementImpl)refCaller).isSuspicious() || !((RefJavaElementImpl)refCaller).isCalledOnlyFrom(refElement, callStack)) {
      callStack.pop();
      return false;
    }
  }

  callStack.pop();
  return true;
}
 

import com.intellij.util.containers.Stack; //导入方法依赖的package包/类
@Nullable
private ArrangementEntryDependencyInfo buildMethodDependencyInfo(@NotNull final PsiMethod method,
                                                                 @NotNull Map<PsiMethod, ArrangementEntryDependencyInfo> cache) {
  JavaElementArrangementEntry entry = myMethodEntriesMap.get(method);
  if (entry == null) {
    return null;
  }
  ArrangementEntryDependencyInfo result = new ArrangementEntryDependencyInfo(entry);
  Stack<Pair<PsiMethod, ArrangementEntryDependencyInfo>> toProcess
    = new Stack<Pair<PsiMethod, ArrangementEntryDependencyInfo>>();
  toProcess.push(Pair.create(method, result));
  Set<PsiMethod> usedMethods = ContainerUtilRt.newHashSet();
  while (!toProcess.isEmpty()) {
    Pair<PsiMethod, ArrangementEntryDependencyInfo> pair = toProcess.pop();
    Set<PsiMethod> dependentMethods = myMethodDependencies.get(pair.first);
    if (dependentMethods == null) {
      continue;
    }
    usedMethods.add(pair.first);
    for (PsiMethod dependentMethod : dependentMethods) {
      if (usedMethods.contains(dependentMethod)) {
        // Prevent cyclic dependencies.
        return null;
      }
      JavaElementArrangementEntry dependentEntry = myMethodEntriesMap.get(dependentMethod);
      if (dependentEntry == null) {
        continue;
      }
      ArrangementEntryDependencyInfo dependentMethodInfo = cache.get(dependentMethod);
      if (dependentMethodInfo == null) {
        cache.put(dependentMethod, dependentMethodInfo = new ArrangementEntryDependencyInfo(dependentEntry));
      }
      Pair<PsiMethod, ArrangementEntryDependencyInfo> dependentPair = Pair.create(dependentMethod, dependentMethodInfo);
      pair.second.addDependentEntryInfo(dependentPair.second);
      toProcess.push(dependentPair);
    }
  }
  return result;
}
 

import com.intellij.util.containers.Stack; //导入方法依赖的package包/类
public static void visit(@Nullable DataNode node, @NotNull Consumer<DataNode<?>> consumer) {
  if(node == null) return;

  Stack<DataNode> toProcess = ContainerUtil.newStack(node);
  while (!toProcess.isEmpty()) {
    DataNode<?> node0 = toProcess.pop();
    consumer.consume(node0);
    for (DataNode<?> child : node0.getChildren()) {
      toProcess.push(child);
    }
  }
}
 

import com.intellij.util.containers.Stack; //导入方法依赖的package包/类
@NotNull
protected StubElement buildStubTreeFor(@NotNull ASTNode root, @NotNull StubElement parentStub) {
  Stack<StubElement> parentStubs = new Stack<StubElement>();
  Stack<ASTNode> parentNodes = new Stack<ASTNode>();
  parentNodes.push(root);
  parentStubs.push(parentStub);

  while (!parentStubs.isEmpty()) {
    StubElement stub = parentStubs.pop();
    ASTNode node = parentNodes.pop();
    IElementType nodeType = node.getElementType();

    if (nodeType instanceof IStubElementType) {
      final IStubElementType type = (IStubElementType)nodeType;

      if (type.shouldCreateStub(node)) {
        PsiElement element = node.getPsi();
        if (!(element instanceof StubBasedPsiElement)) {
          LOG.error("Non-StubBasedPsiElement requests stub creation. Stub type: " + type + ", PSI: " + element);
        }
        @SuppressWarnings("unchecked") StubElement s = type.createStub(element, stub);
        stub = s;
        LOG.assertTrue(stub != null, element);
      }
    }

    for (ASTNode childNode = node.getLastChildNode(); childNode != null; childNode = childNode.getTreePrev()) {
      if (!skipChildProcessingWhenBuildingStubs(node, childNode)) {
        parentNodes.push(childNode);
        parentStubs.push(stub);
      }
    }
  }

  return parentStub;
}
 

import com.intellij.util.containers.Stack; //导入方法依赖的package包/类
public static int findLeftmostLParen(HighlighterIterator iterator,
                                     IElementType lparenTokenType,
                                     CharSequence fileText,
                                     FileType fileType) {
  int lastLbraceOffset = -1;

  Stack<IElementType> braceStack = new Stack<IElementType>();
  for (; !iterator.atEnd(); iterator.retreat()) {
    final IElementType tokenType = iterator.getTokenType();

    if (isLBraceToken(iterator, fileText, fileType)) {
      if (!braceStack.isEmpty()) {
        IElementType topToken = braceStack.pop();
        if (!isPairBraces(tokenType, topToken, fileType)) {
          break; // unmatched braces
        }
      }
      else {
        if (tokenType == lparenTokenType) {
          lastLbraceOffset = iterator.getStart();
        }
        else {
          break;
        }
      }
    }
    else if (isRBraceToken(iterator, fileText, fileType)) {
      braceStack.push(iterator.getTokenType());
    }
  }

  return lastLbraceOffset;
}
 

import com.intellij.util.containers.Stack; //导入方法依赖的package包/类
public static int findLeftLParen(HighlighterIterator iterator,
                                     IElementType lparenTokenType,
                                     CharSequence fileText,
                                     FileType fileType) {
  int lastLbraceOffset = -1;

  Stack<IElementType> braceStack = new Stack<IElementType>();
  for (; !iterator.atEnd(); iterator.retreat()) {
    final IElementType tokenType = iterator.getTokenType();

    if (isLBraceToken(iterator, fileText, fileType)) {
      if (!braceStack.isEmpty()) {
        IElementType topToken = braceStack.pop();
        if (!isPairBraces(tokenType, topToken, fileType)) {
          break; // unmatched braces
        }
      }
      else {
        if (tokenType == lparenTokenType) {
          return iterator.getStart();
        }
        else {
          break;
        }
      }
    }
    else if (isRBraceToken(iterator, fileText, fileType)) {
      braceStack.push(iterator.getTokenType());
    }
  }

  return lastLbraceOffset;
}
 

import com.intellij.util.containers.Stack; //导入方法依赖的package包/类
public static int findRightmostRParen(HighlighterIterator iterator,
                                      IElementType rparenTokenType,
                                      CharSequence fileText,
                                      FileType fileType) {
  int lastRbraceOffset = -1;

  Stack<IElementType> braceStack = new Stack<IElementType>();
  for (; !iterator.atEnd(); iterator.advance()) {
    final IElementType tokenType = iterator.getTokenType();

    if (isRBraceToken(iterator, fileText, fileType)) {
      if (!braceStack.isEmpty()) {
        IElementType topToken = braceStack.pop();
        if (!isPairBraces(tokenType, topToken, fileType)) {
          break; // unmatched braces
        }
      }
      else {
        if (tokenType == rparenTokenType) {
          lastRbraceOffset = iterator.getStart();
        }
        else {
          break;
        }
      }
    }
    else if (isLBraceToken(iterator, fileText, fileType)) {
      braceStack.push(iterator.getTokenType());
    }
  }

  return lastRbraceOffset;
}