Java ProjectFileIndex类代码示例

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
@CheckReturnValue
@VisibleForTesting
@SuppressWarnings("WeakerAccess")
static boolean isAvailable(@Nonnull AnActionEvent event) {
    final Project project = event.getProject();
    if (project == null) {
        return false;
    }

    final IdeView view = event.getData(LangDataKeys.IDE_VIEW);
    if (view == null) {
        return false;
    }

    final ProjectRootManager rootManager = ProjectRootManager.getInstance(project);
    final ProjectFileIndex fileIndex = rootManager.getFileIndex();
    final Optional<PsiDirectory> sourceDirectory = Stream.of(view.getDirectories())
            .filter(directory -> {
                final VirtualFile virtualFile = directory.getVirtualFile();
                return fileIndex.isUnderSourceRootOfType(virtualFile, JavaModuleSourceRootTypes.SOURCES);
            })
            .findFirst();
    return sourceDirectory.isPresent();
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
/**
 * Checked whether or not this action can be enabled.
 *
 * <p>Requirements to be enabled: * User must be in a Java source folder.
 *
 * @param dataContext to figure out where the user is.
 * @return {@code true} when the action is available, {@code false} when the action is not
 *     available.
 */
private boolean isAvailable(DataContext dataContext) {
  final Project project = CommonDataKeys.PROJECT.getData(dataContext);
  if (project == null) {
    return false;
  }

  final IdeView view = LangDataKeys.IDE_VIEW.getData(dataContext);
  if (view == null || view.getDirectories().length == 0) {
    return false;
  }

  ProjectFileIndex projectFileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  for (PsiDirectory dir : view.getDirectories()) {
    if (projectFileIndex.isUnderSourceRootOfType(
            dir.getVirtualFile(), JavaModuleSourceRootTypes.SOURCES)
        && checkPackageExists(dir)) {
      return true;
    }
  }

  return false;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
private void createUIComponents() {
    testTargetTextField = new EditorTextField("", getProject(), FileTypes.PLAIN_TEXT);
    namespaceComboBox = new PhpNamespaceComboBox(getProject(), "", getDisposable());
    directoryComboBox = new PhpPsrDirectoryComboBox(getProject()) {
        @Override
        public void init(@NotNull VirtualFile baseDir, @NotNull String namespace) {
            super.init(baseDir, namespace);
            ProjectFileIndex index = ProjectRootManager.getInstance(TesterNewTestCaseDialog.this.getProject()).getFileIndex();
            this.setDirectoriesFilter(index::isInTestSourceContent);

            this.updateDirectories(TesterNewTestCaseDialog.this.getNamespace());
        }
    };

    classToTestLabel = new JBLabel(TesterBundle.message("dialog.newTestCase.label.classToTest"));
    testClassLabel = new JBLabel(TesterBundle.message("dialog.newTestCase.label.testClass"));
    namespaceLabel = new JBLabel(TesterBundle.message("dialog.newTestCase.label.namespace"));
    fileNameLabel = new JBLabel(TesterBundle.message("dialog.newTestCase.label.fileName"));
    directoryLabel = new JBLabel(TesterBundle.message("dialog.newTestCase.label.directory"));

    testTargetCompletionHint = new JBLabel(UIUtil.ComponentStyle.MINI);
    namespaceCompletionHint = new JBLabel(UIUtil.ComponentStyle.MINI);
    directoryCompletionHint = new JBLabel(UIUtil.ComponentStyle.MINI);
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
public static String getReferencePath(Project project, VirtualFile file) {
  final LogicalRoot logicalRoot = LogicalRootsManager.getLogicalRootsManager(project).findLogicalRoot(file);
  if (logicalRoot != null) {
    return getRelativePath(file, logicalRoot.getVirtualFile());
  }

  ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  VirtualFile sourceRoot = fileIndex.getSourceRootForFile(file);
  if (sourceRoot != null) {
    return getRelativePath(file, sourceRoot);
  }

  VirtualFile root = fileIndex.getContentRootForFile(file);
  if (root != null) {
    return getRelativePath(file, root);
  }

  return file.getPath();
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
@Override
public void addCompletions(@NotNull CompletionParameters parameters, @NotNull ProcessingContext context, @NotNull CompletionResultSet resultSet, @NotNull String[] query) {
    Project project = parameters.getOriginalFile().getManager().getProject();

    List<VirtualFile> resourceRoots = ProjectRootManager.getInstance(project).getModuleSourceRoots(JavaModuleSourceRootTypes.PRODUCTION);
    resourceRoots.addAll(ProjectRootManager.getInstance(project).getModuleSourceRoots(JavaModuleSourceRootTypes.TESTS));
    ProjectFileIndex projectFileIndex = ProjectRootManager.getInstance(project).getFileIndex();
    for (final VirtualFile sourceRoot : resourceRoots) {
        if (sourceRoot.isValid() && sourceRoot.getCanonicalFile() != null) {
            VfsUtil.processFilesRecursively(sourceRoot.getCanonicalFile(), virtualFile -> {
                propertyCompletionProviders.stream()
                    .filter(p -> p.isValidExtension(virtualFile.getCanonicalPath()) && !projectFileIndex.isExcluded(sourceRoot))
                    .forEach(p -> p.buildResultSet(resultSet, virtualFile));
                return true;
            });
        }
    }
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
@Override
public String toString() {
  if (myText == null) {
    Module module = ModuleUtilCore.findModuleForPsiElement(myClass);
    if (module != null) {
      myText = module.getName();
    }
    else {
      VirtualFile virtualFile = myClass.getContainingFile().getVirtualFile();
      final ProjectFileIndex index = ProjectRootManager.getInstance(myClass.getProject()).getFileIndex();
      VirtualFile root = index.getSourceRootForFile(virtualFile);
      if (root == null) {
        root = index.getClassRootForFile(virtualFile);
      }
      if (root != null) {
        myText = root.getName();
      }
      else {
        myText = virtualFile.getPath();
      }
    }
  }
  return myText;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
@Nullable
static HighlightInfo checkPackageAndClassConflict(@NotNull PsiJavaCodeReferenceElement ref, @NotNull PsiFile containingFile) {
  if (ref.isQualified() && isInsidePackageStatement(ref)) {
    VirtualFile file = containingFile.getVirtualFile();
    if (file != null) {
      Module module = ProjectFileIndex.SERVICE.getInstance(ref.getProject()).getModuleForFile(file);
      if (module != null) {
        GlobalSearchScope scope = module.getModuleWithDependenciesAndLibrariesScope(false);
        PsiClass aClass = JavaPsiFacade.getInstance(ref.getProject()).findClass(ref.getCanonicalText(), scope);
        if (aClass != null) {
          String message = JavaErrorMessages.message("package.clashes.with.class", ref.getText());
          return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(ref).descriptionAndTooltip(message).create();
        }
      }
    }
  }

  return null;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
@Nullable
public static Module findContainingMavenizedModule(@NotNull PsiFile psiFile) {
  VirtualFile file = psiFile.getVirtualFile();
  if (file == null) return null;

  Project project = psiFile.getProject();

  MavenProjectsManager manager = MavenProjectsManager.getInstance(project);
  if (!manager.isMavenizedProject()) return null;

  ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();

  Module module = index.getModuleForFile(file);
  if (module == null || !manager.isMavenizedModule(module)) return null;
  return module;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
public MoveClassToModuleFix(String referenceName, Module currentModule, PsiDirectory root, PsiElement psiElement) {
  myReferenceName = referenceName;
  myCurrentModule = currentModule;
  mySourceRoot = root;
  final Project project = psiElement.getProject();
  final PsiClass[] classes = PsiShortNamesCache.getInstance(project).getClassesByName(referenceName, GlobalSearchScope.allScope(project));
  final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  for (final PsiClass aClass : classes) {
    if (!facade.getResolveHelper().isAccessible(aClass, psiElement, aClass)) continue;
    final PsiFile psiFile = aClass.getContainingFile();
    if (!(psiFile instanceof PsiJavaFile)) continue;
    if (aClass.getQualifiedName() == null) continue;
    VirtualFile virtualFile = psiFile.getVirtualFile();
    if (virtualFile == null) continue;
    final Module classModule = fileIndex.getModuleForFile(virtualFile);
    if (classModule != null && classModule != currentModule && !ModuleRootManager.getInstance(currentModule).isDependsOn(classModule)) {
      myModules.put(aClass, classModule);
    }
  }
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
private boolean elementHasSourceCode() {
  PsiFileSystemItem[] items;
  if (myElement instanceof PsiDirectory) {
    final PsiPackage aPackage = JavaDirectoryService.getInstance().getPackage((PsiDirectory)myElement);
    if (aPackage == null) return false;
    items = aPackage.getDirectories(new EverythingGlobalScope(myProject));
  }
  else if (myElement instanceof PsiPackage) {
    items = ((PsiPackage)myElement).getDirectories(new EverythingGlobalScope(myProject));
  }
  else {
    PsiFile containingFile = myElement.getNavigationElement().getContainingFile();
    if (containingFile == null) return false;
    items = new PsiFileSystemItem[] {containingFile};
  }
  ProjectFileIndex projectFileIndex = ProjectFileIndex.SERVICE.getInstance(myProject);
  for (PsiFileSystemItem item : items) {
    VirtualFile file = item.getVirtualFile();
    if (file != null && projectFileIndex.isInSource(file)) return true;
  }
  return false;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
static boolean isUnsynced(Project project, VirtualFile virtualFile) {
  if (!virtualFile.isInLocalFileSystem()) {
    return false;
  }
  if (ProjectFileIndex.SERVICE.getInstance(project).getModuleForFile(virtualFile) == null) {
    return false;
  }
  OCWorkspace workspace = OCWorkspaceProvider.getWorkspace(project);
  if (!(workspace instanceof BlazeCWorkspace)) {
    // Skip if the project isn't a Blaze project or doesn't have C support enabled anyway.
    return false;
  }
  if (workspace.getConfigurations().isEmpty()) {
    // The workspace configurations may not have been loaded yet.
    return false;
  }
  SourceToTargetMap sourceToTargetMap = SourceToTargetMap.getInstance(project);
  return sourceToTargetMap
      .getRulesForSourceFile(VfsUtilCore.virtualToIoFile(virtualFile))
      .isEmpty();
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
private static boolean isAvailable(DataContext dataContext) {
  final Module module = LangDataKeys.MODULE.getData(dataContext);
  final IdeView view = LangDataKeys.IDE_VIEW.getData(dataContext);

  if (module == null ||
      view == null ||
      view.getDirectories().length == 0) {
    return false;
  }
  final AndroidFacet facet = AndroidFacet.getInstance(module);

  if (facet == null || facet.isGradleProject()) {
    return false;
  }
  final ProjectFileIndex projectIndex = ProjectRootManager.getInstance(module.getProject()).getFileIndex();
  final JavaDirectoryService dirService = JavaDirectoryService.getInstance();

  for (PsiDirectory dir : view.getDirectories()) {
    if (projectIndex.isUnderSourceRootOfType(dir.getVirtualFile(), JavaModuleSourceRootTypes.SOURCES) &&
        dirService.getPackage(dir) != null) {
      return true;
    }
  }
  return false;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
static boolean isUnsynced(Project project, VirtualFile virtualFile) {
  if (!virtualFile.isInLocalFileSystem()) {
    return false;
  }
  if (ProjectFileIndex.SERVICE.getInstance(project).getModuleForFile(virtualFile) == null) {
    return false;
  }
  Set<File> syncedJavaFiles =
      SyncCache.getInstance(project)
          .get(SyncStatusHelper.class, SyncStatusHelper::getSyncedJavaFiles);
  if (syncedJavaFiles == null) {
    return false;
  }
  File file = new File(virtualFile.getPath());
  return !syncedJavaFiles.contains(file);
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
@Nullable
private static VirtualFile findTarget(@NotNull AnActionEvent e, @NotNull Project project) {
  VirtualFile[] virtualFiles = VIRTUAL_FILE_ARRAY.getData(e.getDataContext());
  if (virtualFiles != null && virtualFiles.length == 1) {
    VirtualFile target = virtualFiles[0];
    if (isModuleSourceRoot(target, project) || project.getBaseDir().equals(target)) {
      // Module folders and project folder are ignored.
      return null;
    }
    ProjectFileIndex projectIndex = ProjectRootManager.getInstance(project).getFileIndex();
    if (projectIndex.isExcluded(target)) {
      // Excluded folders are ignored.
      return null;
    }
    return target;
  }
  return null;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入依赖的package包/类
static boolean processResources(Project project,
                                VirtualFile sourceRoot,
                                VirtualFile file,
                                List<Pattern> includes,
                                List<Pattern> excludes,
                                String resOutputDir,
                                ResourceProcessor processor) {
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  if (!fileIndex.isExcluded(file)) {
    String relPath = VfsUtilCore.getRelativePath(file, sourceRoot, '/');
    if (relPath != null && MavenUtil.isIncluded(relPath, includes, excludes)) {
      if (processor.process(file, resOutputDir + "/" + relPath)) {
        return true;
      }
    }
  }
  if (file.isDirectory()) {
    for (VirtualFile child : file.getChildren()) {
      if (processResources(project, sourceRoot, child, includes, excludes, resOutputDir, processor)) {
        return true;
      }
    }
  }
  return false;
}