Java MultiMap.keySet方法代码示例

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
private void analyzeDfaWithNestedClosures(PsiElement scope,
                                          ProblemsHolder holder,
                                          StandardDataFlowRunner dfaRunner,
                                          Collection<DfaMemoryState> initialStates, final boolean onTheFly) {
  final DataFlowInstructionVisitor visitor = new DataFlowInstructionVisitor();
  final RunnerResult rc = dfaRunner.analyzeMethod(scope, visitor, IGNORE_ASSERT_STATEMENTS, initialStates);
  if (rc == RunnerResult.OK) {
    createDescription(dfaRunner, holder, visitor, onTheFly, scope);

    MultiMap<PsiElement,DfaMemoryState> nestedClosures = dfaRunner.getNestedClosures();
    for (PsiElement closure : nestedClosures.keySet()) {
      analyzeDfaWithNestedClosures(closure, holder, dfaRunner, nestedClosures.get(closure), onTheFly);
    }
  }
  else if (rc == RunnerResult.TOO_COMPLEX) {
    if (scope.getParent() instanceof PsiMethod) {
      PsiMethod method = (PsiMethod)scope.getParent();
      final PsiIdentifier name = method.getNameIdentifier();
      if (name != null) { // Might be null for synthetic methods like JSP page.
        holder.registerProblem(name, InspectionsBundle.message("dataflow.too.complex"), ProblemHighlightType.WEAK_WARNING);
      }
    }
  }
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
protected void importFromSources(File dir) {
  myRootDir = dir;
  try {
    myProject = doCreateProject(getIprFile());
    myBuilder.setBaseProjectPath(dir.getAbsolutePath());
    List<DetectedRootData> list = RootDetectionProcessor.detectRoots(dir);
    MultiMap<ProjectStructureDetector,DetectedProjectRoot> map = RootDetectionProcessor.createRootsMap(list);
    myBuilder.setupProjectStructure(map);
    for (ProjectStructureDetector detector : map.keySet()) {
      List<ModuleWizardStep> steps = detector.createWizardSteps(myBuilder, myBuilder.getProjectDescriptor(detector), EmptyIcon.ICON_16);
      for (ModuleWizardStep step : steps) {
        if (step instanceof AbstractStepWithProgress<?>) {
          performStep((AbstractStepWithProgress<?>)step);
        }
      }
    }
    myBuilder.commit(myProject, null, ModulesProvider.EMPTY_MODULES_PROVIDER);
  }
  catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
public static void collectConflicts(final PsiReference reference,
                                    final PsiElement element,
                                    final Map<Language, InlineHandler.Inliner> inliners,
                                    final MultiMap<PsiElement, String> conflicts) {
  final PsiElement referenceElement = reference.getElement();
  if (referenceElement == null) return;
  final Language language = referenceElement.getLanguage();
  final InlineHandler.Inliner inliner = inliners.get(language);
  if (inliner != null) {
    final MultiMap<PsiElement, String> refConflicts = inliner.getConflicts(reference, element);
    if (refConflicts != null) {
      for (PsiElement psiElement : refConflicts.keySet()) {
        conflicts.putValues(psiElement, refConflicts.get(psiElement));
      }
    }
  }
  else {
    conflicts.putValue(referenceElement, "Cannot inline reference from " + language.getDisplayName());
  }
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
@NotNull
@Override
public Set<UsageDescriptor> getProjectUsages(@NotNull Project project) throws CollectUsagesException {
  VcsLogManager logManager = VcsLogContentProvider.findLogManager(project);
  VisiblePack dataPack = getDataPack(logManager);
  if (dataPack != null) {
    PermanentGraph<Integer> permanentGraph = dataPack.getPermanentGraph();
    MultiMap<VcsKey, VirtualFile> groupedRoots = groupRootsByVcs(dataPack.getLogProviders());

    Set<UsageDescriptor> usages = ContainerUtil.newHashSet();
    usages.add(new UsageDescriptor("vcs.log.commit.count", permanentGraph.getAllCommits().size()));
    for (VcsKey vcs : groupedRoots.keySet()) {
      //noinspection StringToUpperCaseOrToLowerCaseWithoutLocale
      usages.add(new UsageDescriptor("vcs.log." + vcs.getName().toLowerCase() + ".root.count", groupedRoots.get(vcs).size()));
    }
    return usages;
  }
  return Collections.emptySet();
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
private boolean processCandidates(@NotNull final Map<RequestWithProcessor, Processor<PsiElement>> localProcessors,
                                  @NotNull final MultiMap<VirtualFile, RequestWithProcessor> candidateFiles,
                                  @NotNull ProgressIndicator progress,
                                  int totalSize,
                                  int alreadyProcessedFiles) {
  List<VirtualFile> files = new ArrayList<VirtualFile>(candidateFiles.keySet());

  return processPsiFileRoots(files, totalSize, alreadyProcessedFiles, progress, new Processor<PsiFile>() {
    @Override
    public boolean process(final PsiFile psiRoot) {
      final VirtualFile vfile = psiRoot.getVirtualFile();
      for (final RequestWithProcessor singleRequest : candidateFiles.get(vfile)) {
        Processor<PsiElement> localProcessor = localProcessors.get(singleRequest);
        if (!localProcessor.process(psiRoot)) {
          return false;
        }
      }
      return true;
    }
  });
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
@NotNull
private static MultiMap<PsiElement, String> convertDescription(
  @NotNull final MultiMap<PyClass, PyMemberInfo<?>> duplicateConflictDescriptions,
  @NotNull final Collection<PyMemberInfo<?>> dependenciesConflicts) {
  final MultiMap<PsiElement, String> result = new MultiMap<PsiElement, String>();
  for (final PyClass aClass : duplicateConflictDescriptions.keySet()) {
    for (final PyMemberInfo<?> pyMemberInfo : duplicateConflictDescriptions.get(aClass)) {
      final String message = RefactoringBundle.message("0.already.contains.a.1",
                                                       RefactoringUIUtil.getDescription(aClass, false),
                                                       RefactoringUIUtil.getDescription(pyMemberInfo.getMember(), false));
      result.putValue(aClass, message);
    }
  }

  for (final PyMemberInfo<?> memberUnderConflict : dependenciesConflicts) {
    result.putValue(memberUnderConflict.getMember(), PyBundle.message(
                      "refactoring.will.not.be.accessible",
                      RefactoringUIUtil.getDescription(memberUnderConflict.getMember(), false)
                    )
    );
  }


  return result;
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
@CalledInAwt
@Override
public void apply(MultiMap<VirtualFile, AbstractFilePatchInProgress> patchGroups,
                  LocalChangeList localList,
                  String fileName,
                  TransparentlyFailedValueI<Map<String, Map<String, CharSequence>>, PatchSyntaxException> additionalInfo) {
  final Collection<PatchApplier> appliers = new LinkedList<PatchApplier>();
  final CommitContext commitContext = new CommitContext();
  applyAdditionalInfoBefore(myProject, additionalInfo, commitContext);

  for (VirtualFile base : patchGroups.keySet()) {
    final PatchApplier patchApplier =
      new PatchApplier<BinaryFilePatch>(myProject, base, ObjectsConvertor.convert(patchGroups.get(base),
                                                                                  new Convertor<AbstractFilePatchInProgress, FilePatch>() {
                                                                                    public FilePatch convert(AbstractFilePatchInProgress o) {
                                                                                    return o.getPatch();
                                                                                  }
                                                                                }), localList, null, commitContext);
    appliers.add(patchApplier);
  }
  if (PatchApplier.executePatchGroup(appliers, localList) != ApplyPatchStatus.ABORT) {
    applyAdditionalInfo(myProject, additionalInfo, commitContext);
  }
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
@Override
public void processIncludingFiles(PsiFile context, Processor<Pair<VirtualFile, FileIncludeInfo>> processor) {
  context = context.getOriginalFile();
  VirtualFile contextFile = context.getVirtualFile();
  if (contextFile == null) return;
  MultiMap<VirtualFile,FileIncludeInfoImpl> infoList = FileIncludeIndex.getIncludingFileCandidates(context.getName(), GlobalSearchScope.allScope(myProject));
  for (VirtualFile candidate : infoList.keySet()) {
    PsiFile psiFile = myPsiManager.findFile(candidate);
    if (psiFile == null || context.equals(psiFile)) continue;
    for (FileIncludeInfo info : infoList.get(candidate)) {
      PsiFileSystemItem item = resolveFileInclude(info, psiFile);
      if (item != null && contextFile.equals(item.getVirtualFile())) {
        if (!processor.process(Pair.create(candidate, info))) {
          return;
        }
      }
    }
  }
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
private void buildSwitchedFiles(final MultiMap<String, VirtualFile> switchedFiles) {
  ChangesBrowserNode baseNode = ChangesBrowserNode.create(myProject, ChangesBrowserNode.SWITCHED_FILES_TAG);
  model.insertNodeInto(baseNode, root, root.getChildCount());
  for(String branchName: switchedFiles.keySet()) {
    final List<VirtualFile> switchedFileList = new ArrayList<VirtualFile>(switchedFiles.get(branchName));
    if (switchedFileList.size() > 0) {
      ChangesBrowserNode branchNode = ChangesBrowserNode.create(myProject, branchName);
      model.insertNodeInto(branchNode, baseNode, baseNode.getChildCount());

      final ChangesGroupingPolicy policy = createGroupingPolicy();
      Collections.sort(switchedFileList, VirtualFileHierarchicalComparator.getInstance());
      for (VirtualFile file : switchedFileList) {
        insertChangeNode(file, policy, branchNode, defaultNodeCreator(file));
      }
    }
  }
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
@Nullable
public List<DfaMemoryStateImpl> mergeByUnknowns(List<DfaMemoryStateImpl> states) {
  MultiMap<Integer, DfaMemoryStateImpl> byHash = new MultiMap<Integer, DfaMemoryStateImpl>();
  for (DfaMemoryStateImpl state : states) {
    ProgressManager.checkCanceled();
    byHash.putValue(state.getPartialHashCode(false, true), state);
  }

  Replacements replacements = new Replacements(states);
  for (Integer key : byHash.keySet()) {
    Collection<DfaMemoryStateImpl> similarStates = byHash.get(key);
    if (similarStates.size() < 2) continue;
    
    for (final DfaMemoryStateImpl state1 : similarStates) {
      ProgressManager.checkCanceled();
      List<DfaMemoryStateImpl> complementary = ContainerUtil.filter(similarStates, new Condition<DfaMemoryStateImpl>() {
        @Override
        public boolean value(DfaMemoryStateImpl state2) {
          return state1.equalsByRelations(state2) && state1.equalsByVariableStates(state2);
        }
      });
      if (mergeUnknowns(replacements, complementary)) break;
    }
  }

  return replacements.getMergeResult();
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
@Nullable
public List<DfaMemoryStateImpl> mergeByNullability(List<DfaMemoryStateImpl> states) {
  MultiMap<Integer, DfaMemoryStateImpl> byHash = new MultiMap<Integer, DfaMemoryStateImpl>();
  for (DfaMemoryStateImpl state : states) {
    ProgressManager.checkCanceled();
    byHash.putValue(state.getPartialHashCode(false, false), state);
  }

  Replacements replacements = new Replacements(states);
  for (Integer key : byHash.keySet()) {
    Collection<DfaMemoryStateImpl> similarStates = byHash.get(key);
    if (similarStates.size() < 2) continue;
    
    groupLoop:
    for (final DfaMemoryStateImpl state1 : similarStates) {
      ProgressManager.checkCanceled();
      for (final DfaVariableValue var : state1.getChangedVariables()) {
        if (state1.getVariableState(var).getNullability() != Nullness.NULLABLE) {
          continue;
        }
        
        List<DfaMemoryStateImpl> complementary = ContainerUtil.filter(similarStates, new Condition<DfaMemoryStateImpl>() {
          @Override
          public boolean value(DfaMemoryStateImpl state2) {
            return state1.equalsByRelations(state2) &&
                   areEquivalentModuloVar(state1, state2, var) &&
                   areVarStatesEqualModuloNullability(state1, state2, var);
          }
        });
        if (mergeUnknowns(replacements, complementary)) break groupLoop;
      }
    }
  }

  return replacements.getMergeResult();
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
  File root = new File("/Users/max/IDEA/out/classes/production/");
  final MultiMap<Couple<Integer>, String> dimToPath = new MultiMap<Couple<Integer>, String>();

  walk(root, dimToPath, root);

  ArrayList<Couple<Integer>> keys = new ArrayList<Couple<Integer>>(dimToPath.keySet());
  Collections.sort(keys, new Comparator<Couple<Integer>>() {
    @Override
    public int compare(Couple<Integer> o1, Couple<Integer> o2) {
      int d0 = dimToPath.get(o2).size() - dimToPath.get(o1).size();
      if (d0 != 0) return d0;
      int d1 = o1.first - o2.first;
      if (d1 != 0) {
        return d1;
      }
      return o1.second - o2.second;
    }
  });

  int total = 0;
  for (Couple<Integer> key : keys) {
    Collection<String> paths = dimToPath.get(key);
    System.out.println("------------------------   " + key.first + "x" + key.second + "  (total " +paths.size() + " icons) --------------------------------");
    for (String path : paths) {
      System.out.println(path);
      total ++;
    }
    System.out.println("");
  }

  System.out.println("Total icons: " + total);
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
private static Collection<String> getAllPackagePrefixes(final GlobalSearchScope scope, final MultiMap<String, Module> map) {
  if (scope == null) return map.keySet();

  List<String> result = new SmartList<String>();
  for (final String prefix : map.keySet()) {
    modules: for (final Module module : map.get(prefix)) {
      if (scope.isSearchInModuleContent(module)) {
        result.add(prefix);
        break modules;
      }
    }
  }
  return result;
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
private static Map<String, PsiMethod[]> convertMap(MultiMap<String, PsiMethod> multiMap) {
  Map<String, PsiMethod[]> res = new HashMap<String, PsiMethod[]>();

  for (String methodName : multiMap.keySet()) {
    Collection<PsiMethod> m = multiMap.get(methodName);
    res.put(methodName, m.toArray(new PsiMethod[m.size()]));
  }

  return res;
}
 

import com.intellij.util.containers.MultiMap; //导入方法依赖的package包/类
private List<TemplateItem> buildItems(MultiMap<TemplatesGroup, ProjectTemplate> map) {
  List<TemplateItem> items = new ArrayList<TemplateItem>();
  List<TemplatesGroup> groups = new ArrayList<TemplatesGroup>(map.keySet());
  Collections.sort(groups);
  for (TemplatesGroup group : groups) {
    for (ProjectTemplate template : map.get(group)) {
      TemplateItem templateItem = new TemplateItem(template, group);
      items.add(templateItem);
    }
  }
  return items;
}