Java ProjectFileIndex.isExcluded方法代码示例

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
private static ExcludedEntriesConfigurable createExcludedConfigurable(final Project project) {
  final ExcludesConfiguration configuration = ValidationConfiguration.getExcludedEntriesConfiguration(project);
  final ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();
  final FileChooserDescriptor descriptor = new FileChooserDescriptor(true, true, false, false, false, true) {
    public boolean isFileVisible(VirtualFile file, boolean showHiddenFiles) {
      return super.isFileVisible(file, showHiddenFiles) && (project.isDefault() || !index.isExcluded(file));
    }
  };

  List<VirtualFile> allContentRoots = new ArrayList<VirtualFile>();
  for (final Module module: ModuleManager.getInstance(project).getModules()) {
    final VirtualFile[] moduleContentRoots = ModuleRootManager.getInstance(module).getContentRoots();
    Collections.addAll(allContentRoots, moduleContentRoots);
  }
  descriptor.setRoots(allContentRoots);
  return new ExcludedEntriesConfigurable(project, descriptor, configuration);
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
public boolean isVersioned(@NotNull VirtualFile f, boolean shouldBeInContent) {
  if (!f.isInLocalFileSystem()) return false;

  if (!f.isDirectory() && StringUtil.endsWith(f.getNameSequence(), ".class")) return false;

  Project[] openProjects = ProjectManager.getInstance().getOpenProjects();
  boolean isInContent = false;
  for (Project each : openProjects) {
    if (each.isDefault()) continue;
    if (!each.isInitialized()) continue;
    if (Comparing.equal(each.getWorkspaceFile(), f)) return false;
    ProjectFileIndex index = ProjectRootManager.getInstance(each).getFileIndex();
    
    if (index.isExcluded(f)) return false;
    isInContent |= index.isInContent(f);
  }
  if (shouldBeInContent && !isInContent) return false;
  
  // optimisation: FileTypeManager.isFileIgnored(f) already checked inside ProjectFileIndex.isIgnored()
  return openProjects.length != 0 || !FileTypeManager.getInstance().isFileIgnored(f);
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
@Override
public boolean contains(@NotNull VirtualFile file) {
  final PsiDirectory value = getValue();
  if (value == null) {
    return false;
  }

  VirtualFile directory = value.getVirtualFile();
  if (directory.getFileSystem() instanceof LocalFileSystem) {
    file = PathUtil.getLocalFile(file);
  }

  if (!VfsUtilCore.isAncestor(directory, file, false)) {
    return false;
  }

  if (Registry.is("ide.hide.excluded.files")) {
    final Project project = value.getProject();
    final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
    return !fileIndex.isExcluded(file);
  }
  else {
    return !FileTypeRegistry.getInstance().isFileIgnored(file);
  }
}
 

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;
}
 

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包/类
private ExcludedEntriesConfigurable createExcludedConfigurable(final Project project) {
  final ExcludesConfiguration configuration = myConfig.getExcludeFromStubGeneration();
  final ProjectFileIndex index = ProjectRootManager.getInstance(project).getFileIndex();
  final FileChooserDescriptor descriptor = new FileChooserDescriptor(true, true, false, false, false, true) {
    @Override
    public boolean isFileVisible(VirtualFile file, boolean showHiddenFiles) {
      return super.isFileVisible(file, showHiddenFiles) && !index.isExcluded(file);
    }
  };
  descriptor.setRoots(ContainerUtil.concat(
    ContainerUtil.map(ModuleManager.getInstance(project).getModules(), new Function<Module, List<VirtualFile>>() {
      @Override
      public List<VirtualFile> fun(final Module module) {
        return ModuleRootManager.getInstance(module).getSourceRoots(JavaModuleSourceRootTypes.SOURCES);
      }
    })));
  return new ExcludedEntriesConfigurable(project, descriptor, configuration);
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
private static boolean isProjectFile(@NotNull VirtualFile file, @NotNull Project project) {
  ProjectFileIndex fileIndex = ProjectFileIndex.SERVICE.getInstance(project);
  if (fileIndex.isInContent(file)) return true;
  if (!Registry.is("ide.hide.excluded.files") && fileIndex.isExcluded(file) && !fileIndex.isUnderIgnored(file)) return true;
  
  if (project instanceof ProjectEx && !project.isDefault()) {
    if (ProjectUtil.isDirectoryBased(project)) {
      VirtualFile baseDir = project.getBaseDir();
      VirtualFile dotIdea = baseDir == null ? null : baseDir.findChild(Project.DIRECTORY_STORE_FOLDER);
      if (dotIdea != null && VfsUtilCore.isAncestor(dotIdea, file, false)) return true;
    }

    IProjectStore store = (IProjectStore)ServiceKt.getStateStore(project);
    String filePath = file.getPath();
    if (FileUtil.namesEqual(filePath, store.getWorkspaceFilePath()) || FileUtil.namesEqual(filePath, store.getProjectFilePath())) {
      return true;
    }
    for (Module module : ModuleManager.getInstance(project).getModules()) {
      if (FileUtil.namesEqual(filePath, module.getModuleFilePath())) {
        return true;
      }
    }
  }

  for (NonProjectFileWritingAccessExtension each : Extensions.getExtensions(NonProjectFileWritingAccessExtension.EP_NAME, project)) {
    if(each.isWritable(file)) return true;
  }

  return false;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
public static List<VirtualFile> filterOutGeneratedAndExcludedFiles(@NotNull Collection<VirtualFile> files, @NotNull Project project) {
  ProjectFileIndex fileIndex = ProjectFileIndex.SERVICE.getInstance(project);
  List<VirtualFile> result = new ArrayList<VirtualFile>(files.size());
  for (VirtualFile file : files) {
    if (!fileIndex.isExcluded(file) && !GeneratedSourcesFilter.isGeneratedSourceByAnyFilter(file, project)) {
      result.add(file);
    }
  }
  return result;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
public Collection<AbstractTreeNode> getDirectoryChildren(final PsiDirectory psiDirectory,
                                                         final ViewSettings settings,
                                                         final boolean withSubDirectories) {
  final List<AbstractTreeNode> children = new ArrayList<AbstractTreeNode>();
  final Project project = psiDirectory.getProject();
  final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
  final Module module = fileIndex.getModuleForFile(psiDirectory.getVirtualFile());
  final ModuleFileIndex moduleFileIndex = module == null ? null : ModuleRootManager.getInstance(module).getFileIndex();
  if (!settings.isFlattenPackages() || skipDirectory(psiDirectory)) {
    processPsiDirectoryChildren(psiDirectory, directoryChildrenInProject(psiDirectory, settings),
                                children, fileIndex, null, settings, withSubDirectories);
  }
  else { // source directory in "flatten packages" mode
    final PsiDirectory parentDir = psiDirectory.getParentDirectory();
    if (parentDir == null || skipDirectory(parentDir) && withSubDirectories) {
      addAllSubpackages(children, psiDirectory, moduleFileIndex, settings);
    }
    if (withSubDirectories) {
      PsiDirectory[] subdirs = psiDirectory.getSubdirectories();
      for (PsiDirectory subdir : subdirs) {
        if (!skipDirectory(subdir)) {
          continue;
        }
        VirtualFile directoryFile = subdir.getVirtualFile();

        if (Registry.is("ide.hide.excluded.files")) {
          if (fileIndex.isExcluded(directoryFile)) continue;
        }
        else {
          if (FileTypeRegistry.getInstance().isFileIgnored(directoryFile)) continue;
        }

        children.add(new PsiDirectoryNode(project, subdir, settings));
      }
    }
    processPsiDirectoryChildren(psiDirectory, psiDirectory.getFiles(), children, fileIndex, moduleFileIndex, settings,
                                withSubDirectories);
  }
  return children;
}
 

import com.intellij.openapi.roots.ProjectFileIndex; //导入方法依赖的package包/类
private static boolean isNotUnderSourceRoot(@NotNull final Project project, @Nullable final PsiFile psiFile) {
  if (psiFile == null) {
    return true;
  }
  final VirtualFile virtualFile = psiFile.getVirtualFile();
  if (virtualFile != null) {
    final ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex();
    if (fileIndex.isExcluded(virtualFile) || (fileIndex.isInLibraryClasses(virtualFile) && !fileIndex.isInContent(virtualFile))) {
      return true;
    }
  }
  return false;
}