Java MultiMap类代码示例

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@Override
protected MultiMap<PsiFile, T> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, T> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass serviceAnnotation = javaPsiFacade.findClass(getAnnotationQName(), GlobalSearchScope.allScope(project));
        if (serviceAnnotation != null) {
            AnnotatedElementsSearch.searchPsiClasses(serviceAnnotation, GlobalSearchScope.allScope(project)).forEach(psiClass -> {
                if (psiClass.isInterface() && isSatisfying(psiClass)) {
                    children.putValue(psiClass.getContainingFile(), createChild(psiClass));
                }
                return true;
            });
        }
    }
    return children;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@Override
protected MultiMap<PsiFile, ClassNode> computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, ClassNode> children = new MultiMap<>();
    children.putValue(aggregateRoot.getContainingFile(), new AggregateRootNode(this, aggregateRoot));
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass entityInterface = javaPsiFacade.findClass(ENTITY_INTERFACE, GlobalSearchScope.allScope(project));
        PsiClass valueObjectInterface = javaPsiFacade.findClass(VO_INTERFACE, GlobalSearchScope.allScope(project));
        if (entityInterface != null && valueObjectInterface != null) {
            for (PsiClass psiClass : psiPackage.getClasses(GlobalSearchScope.allScope(project))) {
                if (psiClass.isInheritor(entityInterface, true) && !psiClass.equals(aggregateRoot)) {
                    children.putValue(psiClass.getContainingFile(), new EntityNode(this, psiClass));
                } else if (psiClass.isInheritor(valueObjectInterface, true)) {
                    children.putValue(psiClass.getContainingFile(), new ValueObjectNode(this, psiClass));
                }
            }
        }
    }
    return children;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@Override
protected MultiMap computeChildren(@Nullable PsiFile psiFile) {
    MultiMap<PsiFile, AggregateNode> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass psiClass = javaPsiFacade.findClass(AGGREGATE_ROOT_INTERFACE, GlobalSearchScope.allScope(project));
        if (psiClass != null) {
            ClassInheritorsSearch.search(psiClass, GlobalSearchScope.allScope(project), true).forEach(candidate -> {
                String qualifiedName = candidate.getQualifiedName();
                if (qualifiedName != null && !qualifiedName.startsWith(BUSINESS_PACKAGE) && !isAbstract(candidate)) {
                    children.putValue(candidate.getContainingFile(), new AggregateNode(this, candidate));
                }
            });
        }

    }
    return children;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@Override
public MultiMap<PsiFile, ResourceNode> computeChildren(PsiFile psiFile) {
    Project project = getProject();
    MultiMap<PsiFile, ResourceNode> children = new MultiMap<>();
    if (project != null) {
        JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(project);
        PsiClass pathAnnotation = javaPsiFacade.findClass(PATH_ANNOTATION, GlobalSearchScope.allScope(project));
        if (pathAnnotation != null) {
            AnnotatedElementsSearch.searchPsiClasses(pathAnnotation, GlobalSearchScope.allScope(project)).forEach(psiClass -> {
                if (!psiClass.isInterface() && !NavigatorUtil.isAbstract(psiClass)) {
                    children.putValue(psiClass.getContainingFile(), new ResourceNode(ResourcesNode.this, pathAnnotation, psiClass));
                }
                return true;
            });
        }
    }
    return children;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
protected MultiMap<PsiFile, ToolNode> computeChildren(PsiFile psiFile) {
    MultiMap<PsiFile, ToolNode> children = new MultiMap<>();
    Project project = getProject();
    if (project != null) {
        PsiClass toolInterface = JavaPsiFacade.getInstance(project).findClass(TOOL_INTERFACE, GlobalSearchScope.allScope(project));
        if (toolInterface != null) {
            ClassInheritorsSearch.search(toolInterface, GlobalSearchScope.allScope(project), true).forEach(psiClass -> {
                PsiFile containingFile = psiClass.getContainingFile();
                if (!isAbstract(psiClass)) {
                    children.putValue(containingFile, new ToolNode(this, psiClass));
                }
            });
        }
    }
    return children;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@Override
public void importData(@NotNull Collection<DataNode<LibraryDependencyData>> toImport,
                       @Nullable ProjectData projectData,
                       @NotNull Project project,
                       @NotNull IdeModifiableModelsProvider modelsProvider) {
  if (toImport.isEmpty()) {
    return;
  }

  MultiMap<DataNode<ModuleData>, DataNode<LibraryDependencyData>> byModule = ExternalSystemApiUtil.groupBy(toImport, MODULE);
  for (Map.Entry<DataNode<ModuleData>, Collection<DataNode<LibraryDependencyData>>> entry : byModule.entrySet()) {
    Module module = modelsProvider.findIdeModule(entry.getKey().getData());
    if (module == null) {
      LOG.warn(String.format(
        "Can't import library dependencies %s. Reason: target module (%s) is not found at the ide and can't be imported",
        entry.getValue(), entry.getKey()
      ));
      continue;
    }
    importData(entry.getValue(), module, modelsProvider);
  }
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
public GroovyInplaceFieldValidator(GrIntroduceContext context) {
  super(context, new ConflictReporter() {
    @Override
    public void check(PsiElement toCheck, MultiMap<PsiElement, String> conflicts, String varName) {
      if (toCheck instanceof GrVariable && varName.equals(((GrVariable)toCheck).getName())) {
        conflicts.putValue(toCheck, GroovyRefactoringBundle.message("field.0.is.already.defined", CommonRefactoringUtil.htmlEmphasize(varName)));
      }
      if (toCheck instanceof GrMethod) {
        if (GroovyPropertyUtils.isSimplePropertyAccessor((PsiMethod)toCheck) &&
            varName.equals(GroovyPropertyUtils.getPropertyNameByAccessorName(((PsiMethod)toCheck).getName()))) {
          conflicts.putValue(toCheck, GroovyRefactoringBundle
            .message("access.to.created.field.0.will.be.overriden.by.method.1", CommonRefactoringUtil.htmlEmphasize(varName),
                                              CommonRefactoringUtil.htmlEmphasize(DescriptiveNameUtil.getDescriptiveName(toCheck))));
        }
      }
    }
  });
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@NotNull
@Override
public PsiElementVisitor buildVisitor(@NotNull ProblemsHolder holder, boolean isOnTheFly) {
  return new SchemaVisitor() {
    @Override
    public void visitImports(@NotNull SchemaImports schemaTypeImports) {
      super.visitImports(schemaTypeImports);

      List<SchemaImportStatement> imports = schemaTypeImports.getImportStatementList();
      MultiMap<Qn, SchemaImportStatement> importsByQn = ImportsManager.getImportsByQn(imports);

      for (Map.Entry<Qn, Collection<SchemaImportStatement>> entry : importsByQn.entrySet()) {
        entry.getValue().stream()
            .filter(is -> DEFAULT_IMPORTS_LIST.contains(entry.getKey()))
            .forEach(is -> holder.registerProblem(is,
                InspectionBundle.message("import.unnecessary.problem.descriptor"),
                ProblemHighlightType.LIKE_UNUSED_SYMBOL,
                OptimizeImportsQuickFix.INSTANCE));
      }
    }
  };
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
boolean stripAndMerge(Collection<DfaMemoryStateImpl> group,
                           Function<DfaMemoryStateImpl, DfaMemoryStateImpl> stripper) {
  if (group.size() <= 1) return false;

  boolean hasMerges = false;
  MultiMap<DfaMemoryStateImpl, DfaMemoryStateImpl> strippedToOriginals = MultiMap.create();
  for (DfaMemoryStateImpl original : group) {
    strippedToOriginals.putValue(stripper.fun(original), original);
  }
  for (Map.Entry<DfaMemoryStateImpl, Collection<DfaMemoryStateImpl>> entry : strippedToOriginals.entrySet()) {
    Collection<DfaMemoryStateImpl> merged = entry.getValue();
    if (merged.size() > 1) {
      myRemovedStates.addAll(merged);
      myMerged.add(entry.getKey());
      hasMerges = true;
    }
  }
  return hasMerges;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
@Override
public TaskInfo[] getAllExistingTasks() {
  List<R> repositories = myRepositoryManager.getRepositories();
  MultiMap<String, String> tasks = new MultiMap<String, String>();
  for (R repository : repositories) {
    for (String branch : getAllBranches(repository)) {
      tasks.putValue(branch, repository.getPresentableUrl());
    }
  }
  return ContainerUtil.map2Array(tasks.entrySet(), TaskInfo.class, new Function<Map.Entry<String, Collection<String>>, TaskInfo>() {
    @Override
    public TaskInfo fun(Map.Entry<String, Collection<String>> entry) {
      return new TaskInfo(entry.getKey(), entry.getValue());
    }
  });
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
private static void walk(File root, MultiMap<Couple<Integer>, String> dimToPath, File file) throws IOException {
  if (file.isDirectory()) {
    for (File child : file.listFiles()) {
      walk(root, dimToPath, child);
    }
  }
  else {
    if (IMAGE_EXTENSIONS.contains(FileUtilRt.getExtension(file.getName()))) {
      String relativePath = file.getAbsolutePath().substring(root.getAbsolutePath().length() + 1);
      Image image = loadImage(file);
      File target;
      int width = image.getWidth(null);
      int height = image.getHeight(null);
      if (height != width && (height > 100 || width > 100)) {
        target = new File("/Users/max/images/other", relativePath);
      }
      else {
        target = new File("/Users/max/images/icons", relativePath);
        dimToPath.putValue(new Couple<Integer>(width, height), relativePath);
      }
      FileUtil.copy(file, target);
    }
  }
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
public Collection<String> getAllPackagePrefixes(@Nullable GlobalSearchScope scope) {
  MultiMap<String, Module> map = myMap;
  if (map != null) {
    return getAllPackagePrefixes(scope, map);
  }

  map = new MultiMap<String, Module>();
  for (final Module module : ModuleManager.getInstance(myProject).getModules()) {
    for (final ContentEntry entry : ModuleRootManager.getInstance(module).getContentEntries()) {
      for (final SourceFolder folder : entry.getSourceFolders(JavaModuleSourceRootTypes.SOURCES)) {
        final String prefix = folder.getPackagePrefix();
        if (StringUtil.isNotEmpty(prefix)) {
          map.putValue(prefix, module);
        }
      }
    }
  }

  synchronized (LOCK) {
    if (myMap == null) {
      myMap = map;
    }
    return getAllPackagePrefixes(scope, myMap);
  }
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
private static OrderEntry[] calcOrderEntries(@NotNull RootInfo info,
                                             @NotNull MultiMap<VirtualFile, OrderEntry> depEntries,
                                             @NotNull MultiMap<VirtualFile, OrderEntry> libClassRootEntries,
                                             @NotNull MultiMap<VirtualFile, OrderEntry> libSourceRootEntries,
                                             @NotNull List<VirtualFile> hierarchy) {
  @Nullable VirtualFile libraryClassRoot = info.findLibraryRootInfo(hierarchy, false);
  @Nullable VirtualFile librarySourceRoot = info.findLibraryRootInfo(hierarchy, true);
  Set<OrderEntry> orderEntries = ContainerUtil.newLinkedHashSet();
  orderEntries
    .addAll(info.getLibraryOrderEntries(hierarchy, libraryClassRoot, librarySourceRoot, libClassRootEntries, libSourceRootEntries));
  for (VirtualFile root : hierarchy) {
    orderEntries.addAll(depEntries.get(root));
  }
  VirtualFile moduleContentRoot = info.findModuleRootInfo(hierarchy);
  if (moduleContentRoot != null) {
    ContainerUtil.addIfNotNull(orderEntries, info.getModuleSourceEntry(hierarchy, moduleContentRoot, libClassRootEntries));
  }
  if (orderEntries.isEmpty()) {
    return null;
  }

  OrderEntry[] array = orderEntries.toArray(new OrderEntry[orderEntries.size()]);
  Arrays.sort(array, BY_OWNER_MODULE);
  return array;
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
private static ModuleIndex getModuleIndex(final Project project) {
  return CachedValuesManager.getManager(project).getCachedValue(project, new CachedValueProvider<ModuleIndex>() {
      @Nullable
      @Override
      public Result<ModuleIndex> compute() {
        ModuleIndex index = new ModuleIndex();
        for (Module module : ModuleManager.getInstance(project).getModules()) {
          for (OrderEntry orderEntry : ModuleRootManager.getInstance(module).getOrderEntries()) {
            if (orderEntry instanceof ModuleOrderEntry) {
              Module referenced = ((ModuleOrderEntry)orderEntry).getModule();
              if (referenced != null) {
                MultiMap<Module, Module> map = ((ModuleOrderEntry)orderEntry).isExported() ? index.exportingUsages : index.plainUsages;
                map.putValue(referenced, module);
              }
            }
          }
        }
        return Result.create(index, ProjectRootManager.getInstance(project));
      }
    });
}
 

import com.intellij.util.containers.MultiMap; //导入依赖的package包/类
public static void analyzeModuleConflicts(final Project project,
                                          final Collection<? extends PsiElement> scopes,
                                          final UsageInfo[] usages,
                                          final PsiElement target,
                                          final MultiMap<PsiElement,String> conflicts) {
  if (scopes == null) return;
  final VirtualFile vFile = PsiUtilCore.getVirtualFile(target);
  if (vFile == null) return;


  List<GroovyPsiElement> groovyScopes =
    ContainerUtil.collect(scopes.iterator(), new FilteringIterator.InstanceOf<GroovyPsiElement>(GroovyPsiElement.class));
  analyzeModuleConflicts(project, groovyScopes, usages, vFile, conflicts);
  scopes.removeAll(groovyScopes);
  RefactoringConflictsUtil.analyzeModuleConflicts(project, scopes, usages, vFile, conflicts);
}