Java ContainerUtil.process方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean processSameNamedClasses(Processor<PsiClass> consumer, List<PsiClass> sameNamedClasses, final VirtualFile jarFile) {
  // if there is a class from the same jar, prefer it
  boolean sameJarClassFound = false;

  if (jarFile != null && sameNamedClasses.size() > 1) {
    for (PsiClass sameNamedClass : sameNamedClasses) {
      ProgressManager.checkCanceled();
      boolean fromSameJar = Comparing.equal(getJarFile(sameNamedClass), jarFile);
      if (fromSameJar) {
        sameJarClassFound = true;
        if (!consumer.process(sameNamedClass)) return false;
      }
    }
  }

  return sameJarClassFound || ContainerUtil.process(sameNamedClasses, consumer);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private boolean processAbbreviations(final String pattern, Processor<MatchedValue> consumer, DataContext context) {
  List<String> actions = AbbreviationManager.getInstance().findActions(pattern);
  if (actions.isEmpty()) return true;
  List<ActionWrapper> wrappers = ContainerUtil.newArrayListWithCapacity(actions.size());
  for (String actionId : actions) {
    AnAction action = myActionManager.getAction(actionId);
    wrappers.add(new ActionWrapper(action, myModel.myActionGroups.get(action), MatchMode.NAME, context));
  }
  return ContainerUtil.process(ContainerUtil.map(wrappers, new Function<ActionWrapper, MatchedValue>() {
    @Override
    public MatchedValue fun(@NotNull ActionWrapper w) {
      return new MatchedValue(w, pattern) {
        @Nullable
        @Override
        public String getValueText() {
          return pattern;
        }
      };
    }
  }), consumer);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public int compare(@NotNull final VirtualFile file1, @NotNull final VirtualFile file2) {
  final int[] result = {0};
  ContainerUtil.process(myScopes, new Processor<GlobalSearchScope>() {
    @Override
    public boolean process(GlobalSearchScope scope) {
      int res1 = scope.contains(file1) && scope.contains(file2) ? scope.compare(file1, file2) : 0;
      if (result[0] == 0) {
        result[0] = res1;
        return true;
      }
      if ((result[0] > 0) != (res1 > 0)) {
        result[0] = 0;
        return false;
      }
      return true;
    }
  });
  return result[0];
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private boolean visitMethods(Processor<PyFunction> processor,
                            boolean inherited,
                            boolean skipClassObj, TypeEvalContext context) {
  PyFunction[] methods = getMethods(false);
  if (!ContainerUtil.process(methods, processor)) return false;
  if (inherited) {
    for (PyClass ancestor : getAncestorClasses(context)) {
      if (skipClassObj && PyNames.FAKE_OLD_BASE.equals(ancestor.getName())) {
        continue;
      }
      if (!ancestor.visitMethods(processor, false, null)) {
        return false;
      }
    }
  }
  return true;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean processItems(final String pattern, Collection<? extends Comparable> items, Processor<MatchedValue> consumer) {
  List<MatchedValue> matched = ContainerUtil.map(items, new Function<Comparable, MatchedValue>() {
    @Override
    public MatchedValue fun(Comparable comparable) {
      return new MatchedValue(comparable, pattern);
    }
  });
  Collections.sort(matched);
  return ContainerUtil.process(matched, consumer);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public static boolean processImplementations(final PsiMethod psiMethod, final Processor<PsiElement> consumer,
                                             final SearchScope searchScope) {
  if (!FunctionalExpressionSearch.search(psiMethod, searchScope).forEach(new Processor<PsiFunctionalExpression>() {
    @Override
    public boolean process(PsiFunctionalExpression expression) {
      return consumer.process(expression);
    }
  })) {
    return false;
  }
  List<PsiMethod> methods = new ArrayList<PsiMethod>();
  getOverridingMethods(psiMethod, methods, searchScope);
  return ContainerUtil.process(methods, consumer);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private boolean processDirectories(@NotNull String qualifiedName,
                                   @NotNull final GlobalSearchScope scope,
                                   @NotNull final Processor<VirtualFile> processor) {
  return ContainerUtil.process(getCache(scope).getDirectoriesByPackageName(qualifiedName), new Processor<VirtualFile>() {
    @Override
    public boolean process(VirtualFile file) {
      return !scope.contains(file) || processor.process(file);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public boolean process(final T t) {
  final boolean merged = t instanceof MergedObject;
  if ((!merged || myProcessMerged) && !myProcessor.process(t)) {
    return false;
  }
  if (merged && !ContainerUtil.process(((MergedObject<T>)t).getImplementations(), this)) {
    return false;
  }
  return true;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public boolean visitNestedClasses(Processor<PyClass> processor, boolean inherited) {
  PyClass[] nestedClasses = getNestedClasses();
  if (!ContainerUtil.process(nestedClasses, processor)) return false;
  if (inherited) {
    for (PyClass ancestor : getAncestorClasses(null)) {
      if (!((PyClassImpl)ancestor).visitNestedClasses(processor, false)) {
        return false;
      }
    }
  }
  return true;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public boolean execute(@NotNull final PySuperMethodsSearch.SearchParameters queryParameters, @NotNull final Processor<PsiElement> consumer) {
  PyFunction func = queryParameters.getDerivedMethod();
  PyClass containingClass = func.getContainingClass();
  if (containingClass != null) {
    for (PyClassLikeType type : containingClass.getSuperClassTypes(TypeEvalContext.codeInsightFallback(containingClass.getProject()))) {
      if (type instanceof PyJavaClassType) {
        final PsiClass psiClass = ((PyJavaClassType)type).getPsiClass();
        PsiMethod[] methods = psiClass.findMethodsByName(func.getName(), true);
        // the Python method actually does override/implement all of Java super methods with the same name
        if (!ContainerUtil.process(methods, consumer)) return false;
      }
    }
  }
  return true;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public void updateAllRepositories() {
  ContainerUtil.process(getRepositories(), new Processor<T>() {
    @Override
    public boolean process(T repo) {
      repo.update();
      return true;
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void filterNonValidShelvedChangeLists() {
  final List<ShelvedChangeList> allSchemes = ContainerUtil.newArrayList(mySchemeManager.getAllSchemes());
  ContainerUtil.process(allSchemes, new Processor<ShelvedChangeList>() {

    @Override
    public boolean process(ShelvedChangeList shelvedChangeList) {
      if (!shelvedChangeList.checkValid()) {
        mySchemeManager.removeScheme(shelvedChangeList);
      }
      return true;
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean startMiddleMatchVariants(@NotNull List<Object> qualifierMiddleMatched,
                                                @NotNull Processor<Object> consumer) {
  if (!consumer.process(ChooseByNameBase.NON_PREFIX_SEPARATOR)) return false;
  if (!ContainerUtil.process(qualifierMiddleMatched, consumer)) return false;
  qualifierMiddleMatched.clear();
  return true;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public boolean createReferences(@NotNull final PsiElement psiElement,
                                int offset,
                                String text,
                                @NotNull List<PsiReference> references,
                                boolean soft) {
  FileReferenceSet set = new FileReferenceSet(text, psiElement, offset, null,
                                              true, true,
                                              new FileType[]{XmlFileType.INSTANCE}) {

    private final Condition<PsiFileSystemItem> PLUGIN_XML_CONDITION = new Condition<PsiFileSystemItem>() {
      @Override
      public boolean value(PsiFileSystemItem item) {
        return !item.isDirectory() &&
               !item.equals(getContainingFile()) &&
               (item instanceof XmlFile && DescriptorUtil.isPluginXml((PsiFile)item)) &&
               !isAlreadyUsed((XmlFile)item);
      }
    };

    private boolean isAlreadyUsed(final XmlFile xmlFile) {
      final PsiFile file = getContainingFile();
      if (!(file instanceof XmlFile)) return false;
      final DomFileElement<IdeaPlugin> ideaPlugin = DescriptorUtil.getIdeaPlugin((XmlFile)file);
      if (ideaPlugin == null) return false;
      return !ContainerUtil.process(ideaPlugin.getRootElement().getDependencies(), new Processor<Dependency>() {
        @Override
        public boolean process(Dependency dependency) {
          final GenericAttributeValue<PathReference> configFileAttribute = dependency.getConfigFile();
          if (!DomUtil.hasXml(configFileAttribute)) return true;
          final PathReference pathReference = configFileAttribute.getValue();
          if (pathReference == null) return true;
          return !xmlFile.equals(pathReference.resolve());
        }
      });
    }

    @NotNull
    @Override
    public Collection<PsiFileSystemItem> computeDefaultContexts() {
      final PsiFile containingFile = getContainingFile();
      if (containingFile == null) {
        return Collections.emptyList();
      }

      final Module module = ModuleUtilCore.findModuleForPsiElement(getElement());
      if (module == null) {
        return Collections.emptyList();
      }

      final Set<VirtualFile> roots = new HashSet<VirtualFile>();
      final VirtualFile parent = containingFile.getVirtualFile().getParent();
      roots.add(parent);

      for (VirtualFile sourceRoot : ModuleRootManager.getInstance(module).getSourceRoots(JavaModuleSourceRootTypes.PRODUCTION)) {
        roots.add(sourceRoot.findChild("META-INF"));
      }
      return toFileSystemItems(roots);
    }

    @Override
    protected boolean isSoft() {
      return true;
    }

    @Override
    protected Condition<PsiFileSystemItem> getReferenceCompletionFilter() {
      return PLUGIN_XML_CONDITION;
    }
  };
  Collections.addAll(references, set.getAllReferences());
  return true;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public boolean processAllFieldNames(Processor<String> processor, GlobalSearchScope scope, IdFilter filter) {
  return ContainerUtil.process(getAllFieldNames(), processor);
}