public GitVcs(
@NotNull Project project,
@NotNull Git git,
@NotNull final ProjectLevelVcsManager gitVcsManager,
@NotNull final GitAnnotationProvider gitAnnotationProvider,
@NotNull final GitDiffProvider gitDiffProvider,
@NotNull final GitHistoryProvider gitHistoryProvider,
@NotNull final GitRollbackEnvironment gitRollbackEnvironment,
@NotNull final GitVcsApplicationSettings gitSettings,
@NotNull final GitVcsSettings gitProjectSettings,
@NotNull GitSharedSettings sharedSettings) {
super(project, NAME);
myGit = git;
myVcsManager = gitVcsManager;
myAppSettings = gitSettings;
myChangeProvider =
project.isDefault() ? null : ServiceManager.getService(project, GitChangeProvider.class);
myCheckinEnvironment =
project.isDefault()
? null
: ServiceManager.getService(project, GitCheckinEnvironment.class);
myAnnotationProvider = gitAnnotationProvider;
myDiffProvider = gitDiffProvider;
myHistoryProvider = gitHistoryProvider;
myRollbackEnvironment = gitRollbackEnvironment;
myRevSelector = new GitRevisionSelector();
myConfigurable = new GitVcsConfigurable(myProject, gitProjectSettings, sharedSettings);
myUpdateEnvironment = new GitUpdateEnvironment(myProject, gitProjectSettings);
myCommittedChangeListProvider = new GitCommittedChangeListProvider(myProject);
myOutgoingChangesProvider = new GitOutgoingChangesProvider(myProject);
myTreeDiffProvider = new GitTreeDiffProvider(myProject);
myCommitAndPushExecutor = new GitCommitAndPushExecutor(myCheckinEnvironment);
myExecutableValidator = new GitExecutableValidator(myProject);
}
@Nullable
public List<Module> addModule(Component parent, boolean anImport) {
if (myProject.isDefault()) return null;
final ProjectBuilder builder = runModuleWizard(parent, anImport);
if (builder != null) {
final List<Module> modules = new ArrayList<Module>();
final List<Module> commitedModules;
if (builder instanceof ProjectImportBuilder<?>) {
final ModifiableArtifactModel artifactModel =
ProjectStructureConfigurable.getInstance(myProject)
.getArtifactsStructureConfigurable()
.getModifiableArtifactModel();
commitedModules =
((ProjectImportBuilder<?>) builder)
.commit(myProject, myModuleModel, this, artifactModel);
} else {
commitedModules = builder.commit(myProject, myModuleModel, this);
}
if (commitedModules != null) {
modules.addAll(commitedModules);
}
ApplicationManager.getApplication()
.runWriteAction(
new Runnable() {
@Override
public void run() {
for (Module module : modules) {
getOrCreateModuleEditor(module);
}
}
});
return modules;
}
return null;
}
@Override
public void initComponent() {
if (myProject.isDefault()) {
return;
}
super.initComponent();
}
@SuppressWarnings("unchecked")
private void executeAndRestoreDefaultProjectSettings(
@NotNull Project project, @NotNull Runnable task) {
if (!project.isDefault()) {
task.run();
return;
}
AbstractExternalSystemSettings systemSettings =
ExternalSystemApiUtil.getSettings(project, myExternalSystemId);
Object systemStateToRestore = null;
if (systemSettings instanceof PersistentStateComponent) {
systemStateToRestore = ((PersistentStateComponent) systemSettings).getState();
}
systemSettings.copyFrom(myControl.getSystemSettings());
Collection projectSettingsToRestore = systemSettings.getLinkedProjectsSettings();
systemSettings.setLinkedProjectsSettings(
Collections.singleton(getCurrentExternalProjectSettings()));
try {
task.run();
} finally {
if (systemStateToRestore != null) {
((PersistentStateComponent) systemSettings).loadState(systemStateToRestore);
} else {
systemSettings.setLinkedProjectsSettings(projectSettingsToRestore);
}
}
}
public static void notifyMessages(
Project project,
@Nullable String title,
@Nullable String description,
NotificationType type,
boolean important,
@Nullable Collection<String> messages) {
if (title == null) {
title = "";
}
String desc = (description != null ? description.replace("\n", "<br/>") : "");
if (messages != null && !messages.isEmpty()) {
desc += "<hr/>" + StringUtil.join(messages, "<br/>");
}
if (StringUtil.isEmptyOrSpaces(desc)) {
desc =
StringUtil.isEmptyOrSpaces(title)
? "Error"
: title; // description is not allowed to be empty, title is => moving title text to
// description
title = "";
}
NotificationGroup group =
important ? GitVcs.IMPORTANT_ERROR_NOTIFICATION : GitVcs.NOTIFICATION_GROUP_ID;
group.createNotification(title, desc, type, null).notify(project.isDefault() ? null : project);
}
public ReadonlyStatusHandlerImpl(Project project) {
myProject = project;
myAccessProviders =
project.isDefault()
? new WritingAccessProvider[0]
: Extensions.getExtensions(WritingAccessProvider.EP_NAME, project);
}
@Nullable
public CvsTabbedWindow openTabbedWindow(final CvsHandler output) {
if (ApplicationManager.getApplication().isUnitTestMode()) return null;
if (myProject != null && myProject.isDefault()) return null;
if (myProject != null) {
if (myConfiguration != null && myConfiguration.SHOW_OUTPUT && !myIsQuietOperation) {
if (ApplicationManager.getApplication().isDispatchThread()) {
connectToOutput(output);
} else {
ApplicationManager.getApplication()
.invokeAndWait(
new Runnable() {
public void run() {
connectToOutput(output);
}
},
ModalityState.defaultModalityState());
}
}
if (!myProject.isDisposed()) {
return CvsTabbedWindow.getInstance(myProject);
}
}
return null;
}
public SvnVcs(
final Project project,
MessageBus bus,
SvnConfiguration svnConfiguration,
final SvnLoadedBrachesStorage storage) {
super(project, VCS_NAME);
myLoadedBranchesStorage = storage;
LOG.debug("ct");
myRootsToWorkingCopies = new RootsToWorkingCopies(this);
myConfiguration = svnConfiguration;
myAuthNotifier = new SvnAuthenticationNotifier(this);
dumpFileStatus(FileStatus.ADDED);
dumpFileStatus(FileStatus.DELETED);
dumpFileStatus(FileStatus.MERGE);
dumpFileStatus(FileStatus.MODIFIED);
dumpFileStatus(FileStatus.NOT_CHANGED);
dumpFileStatus(FileStatus.UNKNOWN);
dumpFileStatus(SvnFileStatus.REPLACED);
dumpFileStatus(SvnFileStatus.EXTERNAL);
dumpFileStatus(SvnFileStatus.OBSTRUCTED);
final ProjectLevelVcsManager vcsManager = ProjectLevelVcsManager.getInstance(project);
myAddConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.ADD, this);
myDeleteConfirmation =
vcsManager.getStandardConfirmation(VcsConfiguration.StandardConfirmation.REMOVE, this);
myCheckoutOptions =
vcsManager.getStandardOption(VcsConfiguration.StandardOption.CHECKOUT, this);
if (myProject.isDefault()) {
myChangeListListener = null;
myEntriesFileListener = null;
} else {
myEntriesFileListener = new SvnEntriesFileListener(project);
upgradeIfNeeded(bus);
myChangeListListener = new SvnChangelistListener(myProject, this);
myVcsListener =
new VcsListener() {
@Override
public void directoryMappingChanged() {
invokeRefreshSvnRoots(true);
}
};
}
myFrameStateListener =
project.isDefault()
? null
: new MyFrameStateListener(
ChangeListManager.getInstance(project), VcsDirtyScopeManager.getInstance(project));
myWorkingCopiesContent = new WorkingCopiesContent(this);
// remove used some time before old notification group ids
correctNotificationIds();
myChecker = new SvnExecutableChecker(myProject);
}
private static String getPresentableName(final Project project) {
if (project.isDefault()) {
return project.getName();
}
String location = project.getLocation();
if (location == null) return null;
String projectName = FileUtil.toSystemIndependentName(location);
if (projectName.endsWith("/")) {
projectName = projectName.substring(0, projectName.length() - 1);
}
final int lastSlash = projectName.lastIndexOf('/');
if (lastSlash >= 0 && lastSlash + 1 < projectName.length()) {
projectName = projectName.substring(lastSlash + 1);
}
if (StringUtil.endsWithIgnoreCase(projectName, ProjectFileType.DOT_DEFAULT_EXTENSION)) {
projectName =
projectName.substring(
0, projectName.length() - ProjectFileType.DOT_DEFAULT_EXTENSION.length());
}
projectName = projectName.toLowerCase(Locale.US);
return projectName;
}
public void commitSynchronously(
@NotNull Document document, @NotNull Project project, PsiFile excludeFile) {
assert !isDisposed;
if (!project.isInitialized() && !project.isDefault()) {
@NonNls
String s = project + "; Disposed: " + project.isDisposed() + "; Open: " + project.isOpen();
s += "; SA Passed: ";
try {
s += ((StartupManagerImpl) StartupManager.getInstance(project)).startupActivityPassed();
} catch (Exception e) {
s += e;
}
throw new RuntimeException(s);
}
ApplicationManager.getApplication().assertWriteAccessAllowed();
synchronized (documentsToCommit) {
setCommitStage(document, CommitStage.ABOUT_TO_BE_SYNC_COMMITTED, true);
removeCommitFromQueue(document);
}
ProgressIndicatorBase indicator = new ProgressIndicatorBase();
indicator.start();
log("About to commit sync", document, true, indicator);
Runnable finish = commit(document, project, excludeFile, indicator, true, "Sync commit");
log("Committed sync", document, true, finish, indicator);
assert finish != null;
finish.run();
}
public void focusTable() {
final Project project = myModel.getProject();
final IdeFocusManager focusManager =
project == null || project.isDefault()
? IdeFocusManager.getGlobalInstance()
: IdeFocusManager.getInstance(project);
focusManager.requestFocus(myTable, true);
}
public void update(AnActionEvent e) {
final Project project = e.getData(CommonDataKeys.PROJECT);
if (project == null || project.isDefault()) {
setVisibleEnabled(e, false, false);
return;
}
setVisibleEnabled(e, true, true);
}
private RemoteRevisionsCache(final Project project) {
myProject = project;
myLock = new Object();
myRemoteRevisionsNumbersCache = new RemoteRevisionsNumbersCache(myProject);
myRemoteRevisionsStateCache = new RemoteRevisionsStateCache(myProject);
myChangeDecorator = new RemoteStatusChangeNodeDecorator(this);
myVcsManager = ProjectLevelVcsManager.getInstance(project);
myVcsManager.addVcsListener(this);
myKinds = new HashMap<String, RemoteDifferenceStrategy>();
Disposer.register(
project,
new Disposable() {
public void dispose() {
myVcsManager.removeVcsListener(RemoteRevisionsCache.this);
}
});
final VcsConfiguration vcsConfiguration = VcsConfiguration.getInstance(myProject);
myControlledCycle =
new ControlledCycle(
project,
new Getter<Boolean>() {
@Override
public Boolean get() {
final boolean shouldBeDone =
vcsConfiguration.isChangedOnServerEnabled() && myVcsManager.hasActiveVcss();
if (shouldBeDone) {
boolean somethingChanged = myRemoteRevisionsNumbersCache.updateStep();
somethingChanged |= myRemoteRevisionsStateCache.updateStep();
if (somethingChanged) {
myProject.getMessageBus().syncPublisher(REMOTE_VERSION_CHANGED).run();
}
}
return shouldBeDone;
}
},
"Finishing \"changed on server\" update",
DEFAULT_REFRESH_INTERVAL);
updateRoots();
if ((!myProject.isDefault()) && vcsConfiguration.isChangedOnServerEnabled()) {
((ProjectLevelVcsManagerImpl) myVcsManager)
.addInitializationRequest(
VcsInitObject.REMOTE_REVISIONS_CACHE,
new Runnable() {
public void run() {
// do not start if there're no vcses
if (!myVcsManager.hasActiveVcss() || !vcsConfiguration.isChangedOnServerEnabled())
return;
myControlledCycle.startIfNotStarted(-1);
}
});
}
}
/**
* Get name of the file in the last commit. If file was renamed, returns the previous name.
*
* @param project the context project
* @param path the path to check
* @return the name of file in the last commit or argument
*/
public static FilePath getLastCommitName(final Project project, FilePath path) {
if (project.isDefault()) return path;
final ChangeListManager changeManager = ChangeListManager.getInstance(project);
final Change change = changeManager.getChange(path);
if (change != null && change.getType() == Change.Type.MOVED) {
// GitContentRevision r = (GitContentRevision)change.getBeforeRevision();
assert change.getBeforeRevision() != null : "Move change always have beforeRevision";
path = change.getBeforeRevision().getFile();
}
return path;
}
public ShelveChangesManager(final Project project, final MessageBus bus) {
myProject = project;
myBus = bus;
if (!project.isDefault()) {
myFileProcessor = new CompoundShelfFileProcessor("shelf");
} else {
myFileProcessor =
new CompoundShelfFileProcessor(
new StreamProvider[] {}, PathManager.getConfigPath() + File.separator + "shelf");
}
}
private FileScope(@NotNull Project project, @Nullable VirtualFile virtualFile) {
super(project);
myVirtualFile = virtualFile;
final FileIndexFacade facade = FileIndexFacade.getInstance(project);
myModule =
virtualFile == null || project.isDefault() ? null : facade.getModuleForFile(virtualFile);
mySearchOutsideContent =
virtualFile != null
&& myModule == null
&& !facade.isInLibraryClasses(virtualFile)
&& !facade.isInLibrarySource(virtualFile);
}
private void manageAlarm() {
final VcsConfiguration vcsConfiguration = VcsConfiguration.getInstance(myProject);
if ((!myProject.isDefault())
&& myVcsManager.hasActiveVcss()
&& vcsConfiguration.isChangedOnServerEnabled()) {
// will check whether is already started inside
// interval is checked further, this is small and constant
myControlledCycle.startIfNotStarted(-1);
} else {
myControlledCycle.stop();
}
}
@Override
@NotNull
public ProcessingItem[] getProcessingItems(final CompileContext context) {
final Project project = context.getProject();
if (project.isDefault() || !ValidationConfiguration.shouldValidate(this, context)) {
return ProcessingItem.EMPTY_ARRAY;
}
final ExcludesConfiguration excludesConfiguration =
ValidationConfiguration.getExcludedEntriesConfiguration(project);
final List<ProcessingItem> items =
DumbService.getInstance(project)
.runReadActionInSmartMode(
new Computable<List<ProcessingItem>>() {
@Override
public List<ProcessingItem> compute() {
final CompileScope compileScope = context.getCompileScope();
if (!myValidator.isAvailableOnScope(compileScope)) return null;
final ArrayList<ProcessingItem> items = new ArrayList<ProcessingItem>();
final Processor<VirtualFile> processor =
new Processor<VirtualFile>() {
@Override
public boolean process(VirtualFile file) {
if (!file.isValid()) {
return true;
}
if (myCompilerManager.isExcludedFromCompilation(file)
|| excludesConfiguration.isExcluded(file)) {
return true;
}
final Module module = context.getModuleByFile(file);
if (module != null) {
final PsiFile psiFile = myPsiManager.findFile(file);
if (psiFile != null) {
items.add(new MyValidatorProcessingItem(psiFile));
}
}
return true;
}
};
ContainerUtil.process(
myValidator.getFilesToProcess(myPsiManager.getProject(), context),
processor);
return items;
}
});
if (items == null) return ProcessingItem.EMPTY_ARRAY;
return items.toArray(new ProcessingItem[items.size()]);
}
@NotNull
@Override
public List<DeploymentSource> createArtifactDeploymentSources(
Project project, ArtifactType... artifactTypes) {
if (project.isDefault()) return Collections.emptyList();
Artifact[] artifacts = ArtifactManager.getInstance(project).getArtifacts();
List<Artifact> supportedArtifacts = new ArrayList<>();
Set<ArtifactType> typeSet = ContainerUtil.set(artifactTypes);
for (Artifact artifact : artifacts) {
if (typeSet.contains(artifact.getArtifactType())) {
supportedArtifacts.add(artifact);
}
}
return createArtifactDeploymentSources(project, supportedArtifacts);
}
private boolean hasFilesOutOfProjectRoots() {
if (myHasFilesOutOfProjectRoots == null) {
myHasFilesOutOfProjectRoots = false;
Project project = getProject();
if (project != null && !project.isDefault()) {
for (VirtualFile file : myFiles) {
if (FileIndexFacade.getInstance(project).getModuleForFile(file) == null) {
myHasFilesOutOfProjectRoots = true;
break;
}
}
}
}
return myHasFilesOutOfProjectRoots;
}
public static boolean isInjectable(@Nullable final PsiType type, final Project project) {
if (type == null) return false;
if (type instanceof PsiPrimitiveType) return false;
if (project.isDefault()) {
@NonNls final String text = type.getPresentableText();
if (text == null) return false;
return text.equals("java.lang.String")
|| text.equals("java.lang.String...")
|| text.equals("java.lang.String[]");
} else {
return type.equalsToText("java.lang.String")
|| type.equalsToText("java.lang.String...")
|| type.equalsToText("java.lang.String[]");
}
}
public DebuggerManagerImpl(
Project project, StartupManager startupManager, EditorColorsManager colorsManager) {
myProject = project;
myBreakpointManager = new BreakpointManager(myProject, startupManager, this);
if (!project.isDefault()) {
colorsManager.addEditorColorsListener(
new EditorColorsListener() {
@Override
public void globalSchemeChange(EditorColorsScheme scheme) {
getBreakpointManager().updateBreakpointsUI();
}
},
project);
}
}
public ProjectLevelVcsManagerImpl(
Project project,
final FileStatusManager manager,
MessageBus messageBus,
final FileIndexFacade excludedFileIndex) {
myProject = project;
myMessageBus = messageBus;
mySerialization = new ProjectLevelVcsManagerSerialization();
myOptionsAndConfirmations = new OptionsAndConfirmations();
myDefaultVcsRootPolicy = DefaultVcsRootPolicy.getInstance(project);
myBackgroundableActionHandlerMap =
new EnumMap<VcsBackgroundableActions, BackgroundableActionEnabledHandler>(
VcsBackgroundableActions.class);
myInitialization = new VcsInitialization(myProject);
myMappings = new NewMappings(myProject, myMessageBus, this, manager);
myMappingsToRoots = new MappingsToRoots(myMappings, myProject);
if (!myProject.isDefault()) {
myVcsEventListenerManager = new VcsEventsListenerManagerImpl();
}
myVcsHistoryCache = new VcsHistoryCache();
myContentRevisionCache = new ContentRevisionCache();
myConnect = myMessageBus.connect();
myVcsFileListenerContextHelper = VcsFileListenerContextHelper.getInstance(myProject);
VcsListener vcsListener =
new VcsListener() {
@Override
public void directoryMappingChanged() {
myVcsHistoryCache.clear();
myVcsFileListenerContextHelper.possiblySwitchActivation(hasActiveVcss());
}
};
myExcludedIndex = excludedFileIndex;
myConnect.subscribe(ProjectLevelVcsManager.VCS_CONFIGURATION_CHANGED, vcsListener);
myConnect.subscribe(ProjectLevelVcsManager.VCS_CONFIGURATION_CHANGED_IN_PLUGIN, vcsListener);
myConnect.subscribe(
UpdatedFilesListener.UPDATED_FILES,
new UpdatedFilesListener() {
@Override
public void consume(Set<String> strings) {
myContentRevisionCache.clearCurrent(strings);
}
});
myAnnotationLocalChangesListener = new VcsAnnotationLocalChangesListenerImpl(myProject, this);
}
@Override
public void executeWriteAction(final Editor editor, final DataContext dataContext) {
final Project project = PlatformDataKeys.PROJECT.getData(dataContext);
if (project != null && !project.isDefault()) {
PostprocessReformattingAspect.getInstance(project)
.disablePostprocessFormattingInside(
new Runnable() {
@Override
public void run() {
executeWriteActionInner(editor, dataContext, project);
}
});
} else {
executeWriteActionInner(editor, dataContext, project);
}
}
@Override
public void disposeComponent() {
LibraryInitializer.getInstance().removeContributor(this);
Application application = ApplicationManager.getApplication();
if (myProject.isDefault()
|| application.isUnitTestMode() && application.isDisposeInProgress()) {
return;
}
// Temporary HACK for MPS 3.1: LibraryInitializer.getInstance().update() moved to
// MPSProject.disposeComponent()
// ModelAccess.instance().runWriteAction(new Runnable() {
// @Override
// public void run() {
// LibraryInitializer.getInstance().update();
// }
// });
}
private void showErrorNotification(boolean hasErrors) {
NotificationsManager manager = NotificationsManager.getNotificationsManager();
ErrorsFoundNotification[] notifications =
manager.getNotificationsOfType(ErrorsFoundNotification.class, myProject);
if (hasErrors) {
// do not show notification if it is already shown
if (notifications.length == 0) {
new ErrorsFoundNotification(myProject).notify(myProject.isDefault() ? null : myProject);
}
} else {
// expire notification
for (ErrorsFoundNotification notification : notifications) {
notification.expire();
}
}
}
@Override
@NotNull
public PsiFile[] getFilesWithWord(
@NotNull final String word,
final short occurenceMask,
@NotNull final GlobalSearchScope scope,
final boolean caseSensitively) {
if (myProject.isDefault()) {
return PsiFile.EMPTY_ARRAY;
}
CommonProcessors.CollectProcessor<PsiFile> processor =
new CommonProcessors.CollectProcessor<PsiFile>();
processFilesWithWord(processor, word, occurenceMask, scope, caseSensitively);
return processor.getResults().isEmpty()
? PsiFile.EMPTY_ARRAY
: processor.toArray(PsiFile.EMPTY_ARRAY);
}
private void runAutoMake() {
if (ApplicationManager.getApplication().isUnitTestMode()) {
return;
}
final Project[] openProjects = myProjectManager.getOpenProjects();
if (openProjects.length > 0) {
final List<RequestFuture> futures = new ArrayList<RequestFuture>();
for (final Project project : openProjects) {
if (project.isDefault() || project.isDisposed()) {
continue;
}
final CompilerWorkspaceConfiguration config =
CompilerWorkspaceConfiguration.getInstance(project);
if (!config.useOutOfProcessBuild() || !config.MAKE_PROJECT_ON_SAVE) {
continue;
}
final List<String> emptyList = Collections.emptyList();
final RequestFuture future =
scheduleBuild(
project,
false,
true,
emptyList,
emptyList,
emptyList,
Collections.<String, String>emptyMap(),
new AutoMakeMessageHandler(project));
if (future != null) {
futures.add(future);
synchronized (myAutomakeFutures) {
myAutomakeFutures.put(future, project);
}
}
}
try {
for (RequestFuture future : futures) {
future.waitFor();
}
} finally {
synchronized (myAutomakeFutures) {
myAutomakeFutures.keySet().removeAll(futures);
}
}
}
}
public static CodeStyleSettingsManager getInstance(@Nullable Project project) {
if (project == null || project.isDefault()) return getInstance();
ProjectCodeStyleSettingsManager projectSettingsManager =
ServiceManager.getService(project, ProjectCodeStyleSettingsManager.class);
if (!projectSettingsManager.isLoaded()) {
synchronized (projectSettingsManager) {
if (!projectSettingsManager.isLoaded()) {
LegacyCodeStyleSettingsManager legacySettingsManager =
ServiceManager.getService(project, LegacyCodeStyleSettingsManager.class);
if (legacySettingsManager != null && legacySettingsManager.getState() != null) {
projectSettingsManager.loadState(legacySettingsManager.getState());
LOG.info("Imported old project code style settings.");
}
}
}
}
return projectSettingsManager;
}
// IMPORTANT!!!
// Since implementation of virtualFileProcessor.process() may call indices directly or indirectly,
// we cannot call it inside FileBasedIndex.processValues() method except in collecting form
// If we do, deadlocks are possible (IDEADEV-42137). Process the files without not holding
// indices' read lock.
private boolean collectVirtualFilesWithWord(
@NotNull final Processor<VirtualFile> fileProcessor,
@NotNull final String word,
final short occurrenceMask,
@NotNull final GlobalSearchScope scope,
final boolean caseSensitively) {
if (myProject.isDefault()) {
return true;
}
try {
return ApplicationManager.getApplication()
.runReadAction(
new Computable<Boolean>() {
@Override
public Boolean compute() {
return FileBasedIndex.getInstance()
.processValues(
IdIndex.NAME,
new IdIndexEntry(word, caseSensitively),
null,
new FileBasedIndex.ValueProcessor<Integer>() {
final FileIndexFacade index = FileIndexFacade.getInstance(myProject);
@Override
public boolean process(final VirtualFile file, final Integer value) {
ProgressIndicatorProvider.checkCanceled();
final int mask = value.intValue();
if ((mask & occurrenceMask) != 0
&& index.shouldBeFound(scope, file)) {
if (!fileProcessor.process(file)) return false;
}
return true;
}
},
scope);
}
});
} catch (IndexNotReadyException e) {
throw new ProcessCanceledException();
}
}