Java ContainerUtil.intersects方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean isNullabilityAnnotationForTypeQualifierDefault(PsiAnnotation annotation,
                                                                      boolean nullable,
                                                                      PsiAnnotation.TargetType[] targetTypes) {
    PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement();
    PsiElement declaration = element == null ? null : element.resolve();
    if (!(declaration instanceof PsiClass)) {
        return false;
    }

    String fqn = nullable ? JAVAX_ANNOTATION_NULLABLE : JAVAX_ANNOTATION_NONNULL;
    PsiClass classDeclaration = (PsiClass) declaration;
    if (!AnnotationUtil.isAnnotated(classDeclaration, fqn, false, true)) {
        return false;
    }

    PsiAnnotation tqDefault = AnnotationUtil.findAnnotation(classDeclaration, true, TYPE_QUALIFIER_DEFAULT);
    if (tqDefault == null) {
        return false;
    }

    Set<PsiAnnotation.TargetType> required = extractRequiredAnnotationTargets(tqDefault.findAttributeValue(null));
    return required != null
            && (required.isEmpty() || ContainerUtil.intersects(required, Arrays.asList(targetTypes)));
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public boolean accept(File file) {
  final JavaSourceRootDescriptor rd = myBuildRootIndex.findJavaRootDescriptor(myContext, file);
  if (rd == null) {
    return true;
  }
  final ModuleBuildTarget targetOfFile = rd.target;
  if (myChunkTargets.contains(targetOfFile)) {
    return true;
  }
  Set<BuildTarget<?>> targetOfFileWithDependencies = myCache.get(targetOfFile);
  if (targetOfFileWithDependencies == null) {
    targetOfFileWithDependencies = myBuildTargetIndex.getDependenciesRecursively(targetOfFile, myContext);
    myCache.put(targetOfFile, targetOfFileWithDependencies);
  }
  return ContainerUtil.intersects(targetOfFileWithDependencies, myChunkTargets);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean isNullabilityDefault(@NotNull PsiAnnotation annotation, boolean nullable, PsiAnnotation.TargetType[] placeTargetTypes) {
  PsiJavaCodeReferenceElement element = annotation.getNameReferenceElement();
  PsiElement declaration = element == null ? null : element.resolve();
  if (!(declaration instanceof PsiClass)) return false;

  if (!AnnotationUtil.isAnnotated((PsiClass)declaration,
                                   nullable ? JAVAX_ANNOTATION_NULLABLE : JAVAX_ANNOTATION_NONNULL,
                                   false,
                                   true)) {
    return false;
  }

  PsiAnnotation tqDefault = AnnotationUtil.findAnnotation((PsiClass)declaration, true, "javax.annotation.meta.TypeQualifierDefault");
  if (tqDefault == null) return false;

  Set<PsiAnnotation.TargetType> required = AnnotationTargetUtil.extractRequiredAnnotationTargets(tqDefault.findAttributeValue(null));
  if (required == null) return false;
  return required.isEmpty() || ContainerUtil.intersects(required, Arrays.asList(placeTargetTypes));
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public List<Library> getLibraries(@NotNull Set<LibraryKind> kinds, @NotNull Project project, @Nullable StructureConfigurableContext context) {
  List<Library> libraries = new ArrayList<Library>();
  if (context != null) {
    Collections.addAll(libraries, context.getProjectLibrariesProvider().getModifiableModel().getLibraries());
    Collections.addAll(libraries, context.getGlobalLibrariesProvider().getModifiableModel().getLibraries());
  }
  else {
    final LibraryTablesRegistrar registrar = LibraryTablesRegistrar.getInstance();
    Collections.addAll(libraries, registrar.getLibraryTable(project).getLibraries());
    Collections.addAll(libraries, registrar.getLibraryTable().getLibraries());
  }

  final Iterator<Library> iterator = libraries.iterator();
  while (iterator.hasNext()) {
    Library library = iterator.next();
    final List<LibraryKind> libraryKinds = getLibraryKinds(library, context);
    if (!ContainerUtil.intersects(libraryKinds, kinds)) {
      iterator.remove();
    }
  }
  return libraries;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public void setLibraryProvider(@Nullable FrameworkLibraryProvider provider) {
  if (provider != null && !ContainerUtil.intersects(provider.getAvailableLibraryKinds(), myLibraryDescription.getSuitableLibraryKinds())) {
    provider = null;
  }

  if (!Comparing.equal(myLibraryProvider, provider)) {
    myLibraryProvider = provider;

    if (mySettings != null) {
      if (provider != null && !myUseFromProviderRadioButton.isVisible()) {
        myUseFromProviderRadioButton.setSelected(true);
      }
      myUseFromProviderRadioButton.setVisible(provider != null);
      updateState();
    }
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public List<ModuleWizardStep> getSelectedSteps() {
  if (mySelectedSteps == null) {
    mySelectedSteps = new ArrayList<ModuleWizardStep>();
    mySelectedSteps.addAll(myCommonSteps);
    for (String type : myTypes) {
      Collection<ModuleWizardStep> steps = mySpecificSteps.get(type);
      mySelectedSteps.addAll(steps);
    }
    for (Pair<ModuleWizardStep, Set<String>> pair : myCommonFinishingSteps) {
      Set<String> types = pair.getSecond();
      if (types == null || ContainerUtil.intersects(myTypes, types)) {
        mySelectedSteps.add(pair.getFirst());
      }
    }
    ContainerUtil.removeDuplicates(mySelectedSteps);
  }

  return mySelectedSteps;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void removeRedundantAnnotations(PsiModifierListOwner element,
                                        List<String> redundantAnnotations,
                                        Set<PsiAnnotation.TargetType> targetsForDefaultAnnotation) {
    PsiAnnotation.TargetType[] targetTypes = getTargetsForLocation(element.getModifierList());
    boolean isTargeted = targetsForDefaultAnnotation.isEmpty()
            || ContainerUtil.intersects(targetsForDefaultAnnotation, Arrays.asList(targetTypes));
    if (isTargeted) {
        removePhysicalAnnotations(element, ArrayUtil.toStringArray(redundantAnnotations));
    }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void buildModuleDependencies(final Map<File, ModuleDescriptor> contentRootToModules) {
  final Set<File> moduleContentRoots = contentRootToModules.keySet();

  for (File contentRoot : moduleContentRoots) {
    final ModuleDescriptor checkedModule = contentRootToModules.get(contentRoot);
    myProgress.setText2("Building library dependencies for module " + checkedModule.getName());
    buildJarDependencies(checkedModule);

    myProgress.setText2("Building module dependencies for module " + checkedModule.getName());
    for (File aContentRoot : moduleContentRoots) {
      final ModuleDescriptor aModule = contentRootToModules.get(aContentRoot);
      if (checkedModule.equals(aModule)) {
        continue; // avoid self-dependencies
      }
      final Collection<? extends DetectedProjectRoot> aModuleRoots = aModule.getSourceRoots();
      checkModules:
      for (DetectedProjectRoot srcRoot: checkedModule.getSourceRoots()) {
        final Set<String> referencedBySourceRoot = mySourceRootToReferencedPackagesMap.get(srcRoot.getDirectory());
        for (DetectedProjectRoot aSourceRoot : aModuleRoots) {
          if (ContainerUtil.intersects(referencedBySourceRoot, mySourceRootToPackagesMap.get(aSourceRoot.getDirectory()))) {
            checkedModule.addDependencyOn(aModule);
            break checkModules;
          }
        }
      }
    }
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private void buildJarDependencies(final ModuleDescriptor module) {
  for (File jarFile : myJarToPackagesMap.keySet()) {
    final Set<String> jarPackages = myJarToPackagesMap.get(jarFile);
    for (DetectedProjectRoot srcRoot : module.getSourceRoots()) {
      if (ContainerUtil.intersects(mySourceRootToReferencedPackagesMap.get(srcRoot.getDirectory()), jarPackages)) {
        module.addLibraryFile(jarFile);
        break;
      }
    }
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public static Collection<LibraryDescriptor> getLibraryDependencies(ModuleDescriptor module,
                                                                   final List<LibraryDescriptor> allLibraries) {
  final Set<LibraryDescriptor> libs = new HashSet<LibraryDescriptor>();
  for (LibraryDescriptor library : allLibraries) {
    if (ContainerUtil.intersects(library.getJars(), module.getLibraryFiles())) {
      libs.add(library);
    }
  }
  return libs;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public static List<Chunk<Module>> getSortedModuleChunks(Project project, List<Module> modules) {
  final Module[] allModules = ModuleManager.getInstance(project).getModules();
  final List<Chunk<Module>> chunks = getSortedChunks(createModuleGraph(allModules));

  final Set<Module> modulesSet = new HashSet<Module>(modules);
  // leave only those chunks that contain at least one module from modules
  for (Iterator<Chunk<Module>> it = chunks.iterator(); it.hasNext();) {
    final Chunk<Module> chunk = it.next();
    if (!ContainerUtil.intersects(chunk.getNodes(), modulesSet)) {
      it.remove();
    }
  }
  return chunks;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private boolean matchesAnyHead(@NotNull PermanentGraph<Integer> permanentGraph,
                               @NotNull VcsCommitMetadata commit,
                               @Nullable Set<Integer> matchingHeads) {
  if (matchingHeads == null) {
    return true;
  }
  // TODO O(n^2)
  int commitIndex = myHashMap.getCommitIndex(commit.getId());
  return ContainerUtil.intersects(permanentGraph.getContainingBranches(commitIndex), matchingHeads);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public DomFileIndex() {
  myDataIndexer = new DataIndexer<String, Void, FileContent>() {
    @Override
    @NotNull
    public Map<String, Void> map(@NotNull final FileContent inputData) {
      final Set<String> namespaces = new THashSet<String>();
      final XmlFileHeader header = NanoXmlUtil.parseHeader(CharArrayUtil.readerFromCharSequence(inputData.getContentAsText()));
      ContainerUtil.addIfNotNull(header.getPublicId(), namespaces);
      ContainerUtil.addIfNotNull(header.getSystemId(), namespaces);
      ContainerUtil.addIfNotNull(header.getRootTagNamespace(), namespaces);
      final String tagName = header.getRootTagLocalName();
      if (StringUtil.isNotEmpty(tagName)) {
        final THashMap<String, Void> result = new THashMap<String, Void>();
        final DomApplicationComponent component = DomApplicationComponent.getInstance();
        for (final DomFileDescription description : component.getFileDescriptions(tagName)) {
          final String[] strings = description.getAllPossibleRootTagNamespaces();
          if (strings.length == 0 || ContainerUtil.intersects(Arrays.asList(strings), namespaces)) {
            result.put(description.getRootElementClass().getName(), null);
          }
        }
        for (final DomFileDescription description : component.getAcceptingOtherRootTagNameDescriptions()) {
          final String[] strings = description.getAllPossibleRootTagNamespaces();
          if (strings.length == 0 || ContainerUtil.intersects(Arrays.asList(strings), namespaces)) {
            result.put(description.getRootElementClass().getName(), null);
          }
        }
        return result;
      }
      return Collections.emptyMap();
    }
  };
}