return AbstractFileIndex.this.queryNeededFiles(myIncludeChangedFiles, myFileTypesToRefresh);
}
+ public int getNumberOfPendingUpdateJobs() {
+ return 0;
+ }
+
public void processFile(FileContent fileContent) {
updateIndexEntry(fileContent.getVirtualFile());
}
}
}
+ public int getNumberOfPendingUpdateJobs() {
+ return 0;
+ }
+
public VirtualFile[] queryNeededFiles() {
return VfsUtil.toVirtualFileArray(myChangedFiles);
}
return pair != null? pair.getSecond() : null;
}
+ public int getNumberOfPendingInvalidations() {
+ return myChangedFilesCollector.getNumberOfPendingInvalidations();
+ }
+
public Collection<VirtualFile> getFilesToUpdate(final Project project) {
final ProjectFileIndex projectIndex = ProjectRootManager.getInstance(project).getFileIndex();
return ContainerUtil.findAll(myChangedFilesCollector.getAllFilesToUpdate(), new Condition<VirtualFile>() {
}
}
+ public int getNumberOfPendingInvalidations() {
+ r.lock();
+ try {
+ return myFutureInvalidations.size();
+ }
+ finally {
+ r.unlock();
+ }
+ }
+
public void ensureAllInvalidateTasksCompleted() {
final int size;
r.lock();
}
private class RefreshCacheUpdater implements CacheUpdater {
+ public int getNumberOfPendingUpdateJobs() {
+ return myIndex.getNumberOfPendingInvalidations();
+ }
+
public VirtualFile[] queryNeededFiles() {
Collection<VirtualFile> files = myIndex.getFilesToUpdate(myProject);
return VfsUtil.toVirtualFileArray(files);
import com.intellij.ide.caches.CacheUpdater;
import com.intellij.ide.caches.FileContent;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.*;
+import com.intellij.openapi.roots.CollectingContentIterator;
import com.intellij.openapi.vfs.VfsUtil;
import com.intellij.openapi.vfs.VirtualFile;
myProject = project;
}
+ public int getNumberOfPendingUpdateJobs() {
+ return myIndex.getNumberOfPendingInvalidations();
+ }
+
public VirtualFile[] queryNeededFiles() {
CollectingContentIterator finder = myIndex.createContentIterator();
FileBasedIndex.iterateIndexableFiles(finder, myProject);
import com.intellij.history.core.Paths;
import com.intellij.history.core.tree.Entry;
import com.intellij.history.utils.LocalHistoryLog;
-import com.intellij.ide.caches.FileContent;
import com.intellij.ide.caches.CacheUpdater;
+import com.intellij.ide.caches.FileContent;
import com.intellij.openapi.command.CommandEvent;
import com.intellij.openapi.command.CommandListener;
import com.intellij.openapi.vfs.*;
return myRefreshDepth > 0;
}
+ public int getNumberOfPendingUpdateJobs() {
+ return 0;
+ }
+
public VirtualFile[] queryNeededFiles() {
return getOrInitProcessor().queryNeededFiles();
}
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.containers.ContainerUtil;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
public class LocalHistoryCacheUpdater implements CacheUpdater {
private final LocalVcs myVcs;
myProcessor.processFile(c);
}
+ public int getNumberOfPendingUpdateJobs() {
+ return 0;
+ }
+
public void updatingDone() {
myVcs.endChangeSet(myChangeSetName);
myVfsRoots = null;
import com.intellij.openapi.vfs.VirtualFile;
public interface CacheUpdater {
+ int getNumberOfPendingUpdateJobs();
+
VirtualFile[] queryNeededFiles();
+
void processFile(FileContent fileContent);
+
void updatingDone();
+
void canceled();
}
if (project == null) return;
CacheUpdater updater = new CacheUpdater() {
+ public int getNumberOfPendingUpdateJobs() {
+ return 0;
+ }
+
public VirtualFile[] queryNeededFiles() {
while (myDumb) {
try {
return mySession.getFilesToUpdate().size();
}
+ public int getNumberOfPendingUpdateJobs(ProgressIndicator indicator) {
+ if (mySession == null) {
+ mySession = new CacheUpdateSession(myUpdaters, indicator);
+ }
+ return mySession.getNumberOfPendingUpdateJobs();
+ }
+
public void processFiles(final ProgressIndicator indicator, boolean processInReadAction) {
try {
indicator.checkCanceled();
private static final Logger LOG = Logger.getInstance("#" + CacheUpdateSession.class.getName());
private static final Key<Boolean> FAILED_TO_INDEX = Key.create(CacheUpdateSession.class.getSimpleName() + ".FAILED_TO_INDEX");
private final Collection<VirtualFile> myFilesToUpdate;
+ private final int myJobsToDo;
private final List<Pair<CacheUpdater, Collection<VirtualFile>>> myUpdatersWithFiles =
new ArrayList<Pair<CacheUpdater, Collection<VirtualFile>>>();
myFilesToUpdate = new LinkedHashSet<VirtualFile>();
try {
+ int jobsCount = 0;
for (CacheUpdater each : updaters) {
indicator.checkCanceled();
try {
+ jobsCount += each.getNumberOfPendingUpdateJobs();
List<VirtualFile> updaterFiles = Arrays.asList(each.queryNeededFiles());
processedUpdaters.add(each);
myFilesToUpdate.addAll(updaterFiles);
LOG.error(e);
}
}
+ myJobsToDo = jobsCount;
}
catch (ProcessCanceledException e) {
for (CacheUpdater each : processedUpdaters) {
}
}
+ public int getNumberOfPendingUpdateJobs() {
+ return myJobsToDo;
+ }
+
public Collection<VirtualFile> getFilesToUpdate() {
return myFilesToUpdate;
}
}
try {
final int size = runner.queryNeededFiles(indicator);
- if (size < 50) {
- // if not that many files found, process them on the spot, avoiding entering dumb mode
+ if ((size + runner.getNumberOfPendingUpdateJobs(indicator)) < 50) {
+ // If not that many files found, process them on the spot, avoiding entering dumb mode
+ // Consider number of pending tasks as well, becase they may take noticeable time to process even if the number of files is small
if (size > 0) {
runner.processFiles(indicator, false);
}