mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-08-04 14:55:41 +02:00
Code Issues Wiki Activity

2004-05-06 Chris Wiebe

Browse source 
Creating a new Job to handle the changes, instead
	of reusing the same job.
This commit is contained in:
Alain Magloire 2004-05-06 18:37:54 +00:00
parent c29caac4d0
commit 37c1ca7b3a
3 changed files with 43 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
core/org.eclipse.cdt.core/browser/ChangeLog
View file

@ -1,6 +1,10 @@
2004-04-06 Chris Wiebe 2004-05-06 Chris Wiebe
initial placement of non-ui code into org.eclipse.cdt.core.browser Creating a new Job to handle the changes, instead
of reusing the same job.
2004-04-20 Chris Wiebe 2004-04-20 Chris Wiebe
refactored TypeCacheDeltaListener into standalone class refactored TypeCacheDeltaListener into standalone class
added option in Work In Progress prefs page to disable background cache added option in Work In Progress prefs page to disable background cache
2004-04-06 Chris Wiebe
initial placement of non-ui code into org.eclipse.cdt.core.browser

43
core/org.eclipse.cdt.core/browser/org/eclipse/cdt/core/browser/AllTypesCache.java
View file

@ -45,7 +45,7 @@ public class AllTypesCache {
private static final int INITIAL_DELAY= 5000; private static final int INITIAL_DELAY= 5000;
private static TypeCache fgCache; private static TypeCache fgCache;
private static TypeCacherJob fgJob; private static IWorkingCopyProvider fWorkingCopyProvider;
private static TypeCacheDeltaListener fgDeltaListener; private static TypeCacheDeltaListener fgDeltaListener;
private static IPropertyChangeListener fgPropertyChangeListener; private static IPropertyChangeListener fgPropertyChangeListener;
private static boolean fBackgroundJobEnabled; private static boolean fBackgroundJobEnabled;
@ -81,8 +81,8 @@ public class AllTypesCache {
} }
fgCache= new TypeCache(); fgCache= new TypeCache();
fgJob= new TypeCacherJob(fgCache, provider); fWorkingCopyProvider = provider;
fgDeltaListener= new TypeCacheDeltaListener(fgCache, fBackgroundJobEnabled, fgJob); fgDeltaListener= new TypeCacheDeltaListener(fgCache, fWorkingCopyProvider, fBackgroundJobEnabled);
fgPropertyChangeListener= new IPropertyChangeListener() { fgPropertyChangeListener= new IPropertyChangeListener() {
public void propertyChange(PropertyChangeEvent event) { public void propertyChange(PropertyChangeEvent event) {
@ -102,17 +102,14 @@ public class AllTypesCache {
// add property change listener // add property change listener
prefs.addPropertyChangeListener(fgPropertyChangeListener); prefs.addPropertyChangeListener(fgPropertyChangeListener);
if (fBackgroundJobEnabled) {
TypeCacherJob typeCacherJob = new TypeCacherJob(fgCache, fWorkingCopyProvider);
typeCacherJob.setSearchPaths(null);
typeCacherJob.setPriority(Job.BUILD);
typeCacherJob.schedule(INITIAL_DELAY);
}
// add delta listener // add delta listener
CoreModel.getDefault().addElementChangedListener(fgDeltaListener); CoreModel.getDefault().addElementChangedListener(fgDeltaListener);
if (fBackgroundJobEnabled) {
// schedule job to run after INITIAL_DELAY
if (fgJob.getState() != Job.RUNNING) {
fgJob.setSearchPaths(null);
fgJob.setPriority(Job.BUILD);
fgJob.schedule(INITIAL_DELAY);
}
}
} }
/** /**
@ -122,8 +119,9 @@ public class AllTypesCache {
// remove delta listener // remove delta listener
CoreModel.getDefault().removeElementChangedListener(fgDeltaListener); CoreModel.getDefault().removeElementChangedListener(fgDeltaListener);
// terminate background job // terminate all background jobs
fgJob.cancel(); IJobManager jobMgr = Platform.getJobManager();
jobMgr.cancel(TypeCacherJob.FAMILY);
} }
/* /*
@ -151,16 +149,23 @@ public class AllTypesCache {
public static void getTypes(ICSearchScope scope, int[] kinds, IProgressMonitor monitor, Collection typesFound) { public static void getTypes(ICSearchScope scope, int[] kinds, IProgressMonitor monitor, Collection typesFound) {
if (!isCacheUpToDate()) { if (!isCacheUpToDate()) {
// start job if not already running // start job if not already running
if (fgJob.getState() != Job.RUNNING) { IJobManager jobMgr = Platform.getJobManager();
Job[] jobs = jobMgr.find(TypeCacherJob.FAMILY);
if (jobs.length == 0) {
// boost priority since action was user-initiated // boost priority since action was user-initiated
fgJob.setSearchPaths(null); TypeCacherJob typeCacherJob = new TypeCacherJob(fgCache, fWorkingCopyProvider);
fgJob.setPriority(Job.SHORT); typeCacherJob.setSearchPaths(null);
fgJob.schedule(); typeCacherJob.setPriority(Job.SHORT);
typeCacherJob.schedule();
} }
// wait for job to finish // wait for job to finish
jobs = jobMgr.find(TypeCacherJob.FAMILY);
try { try {
fgJob.join(monitor); for (int i = 0; i < jobs.length; ++i) {
TypeCacherJob job = (TypeCacherJob) jobs[i];
job.join(monitor);
}
if (monitor != null) if (monitor != null)
monitor.done(); monitor.done();
} catch (InterruptedException ex) { } catch (InterruptedException ex) {

29
core/org.eclipse.cdt.core/browser/org/eclipse/cdt/internal/core/browser/cache/TypeCacheDeltaListener.java vendored
View file

@ -10,11 +10,14 @@ import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
import java.util.Set; import java.util.Set;
import org.eclipse.cdt.core.browser.AllTypesCache.IWorkingCopyProvider;
import org.eclipse.cdt.core.model.ElementChangedEvent; import org.eclipse.cdt.core.model.ElementChangedEvent;
import org.eclipse.cdt.core.model.ICElement; import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.model.ICElementDelta; import org.eclipse.cdt.core.model.ICElementDelta;
import org.eclipse.cdt.core.model.IElementChangedListener; import org.eclipse.cdt.core.model.IElementChangedListener;
import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job; import org.eclipse.core.runtime.jobs.Job;
@ -26,15 +29,15 @@ import org.eclipse.core.runtime.jobs.Job;
public class TypeCacheDeltaListener implements IElementChangedListener { public class TypeCacheDeltaListener implements IElementChangedListener {
private TypeCache fTypeCache; private TypeCache fTypeCache;
private TypeCacherJob fTypeCacherJob; private IWorkingCopyProvider fWorkingCopyProvider;
private Set fPaths= new HashSet(5); private Set fPaths= new HashSet(5);
private Set fPrefixes= new HashSet(5); private Set fPrefixes= new HashSet(5);
private boolean fFlushAll= false; private boolean fFlushAll= false;
private boolean fCreateBackgroundJob= true; private boolean fCreateBackgroundJob= true;
public TypeCacheDeltaListener(TypeCache cache, boolean createBackgroundJob, TypeCacherJob job) { public TypeCacheDeltaListener(TypeCache cache, IWorkingCopyProvider workingCopyProvider, boolean createBackgroundJob) {
fTypeCache= cache; fTypeCache= cache;
fTypeCacherJob= job; fWorkingCopyProvider = workingCopyProvider;
fCreateBackgroundJob= createBackgroundJob; fCreateBackgroundJob= createBackgroundJob;
} }
@ -53,32 +56,26 @@ public class TypeCacheDeltaListener implements IElementChangedListener {
boolean needsFlushing= processDelta(event.getDelta()); boolean needsFlushing= processDelta(event.getDelta());
if (needsFlushing) { if (needsFlushing) {
// cancel background job // cancel background job
if (fTypeCacherJob.getState() == Job.RUNNING) { IJobManager jobMgr = Platform.getJobManager();
// wait for job to finish? jobMgr.cancel(TypeCacherJob.FAMILY);
try { TypeCacherJob typeCacherJob = new TypeCacherJob(fTypeCache, fWorkingCopyProvider);
fTypeCacherJob.cancel();
fTypeCacherJob.join();
} catch (InterruptedException ex) {
}
}
if (fFlushAll) { if (fFlushAll) {
// flush the entire cache // flush the entire cache
fTypeCacherJob.setSearchPaths(null); typeCacherJob.setSearchPaths(null);
fTypeCache.flushAll(); fTypeCache.flushAll();
} else { } else {
// flush affected files from cache // flush affected files from cache
Set searchPaths= new HashSet(10); Set searchPaths= new HashSet(10);
getPrefixMatches(fPrefixes, searchPaths); getPrefixMatches(fPrefixes, searchPaths);
searchPaths.addAll(fPaths); searchPaths.addAll(fPaths);
fTypeCacherJob.setSearchPaths(searchPaths); typeCacherJob.setSearchPaths(searchPaths);
fTypeCache.flush(searchPaths); fTypeCache.flush(searchPaths);
} }
// restart the background job // restart the background job
if (fCreateBackgroundJob) { if (fCreateBackgroundJob) {
fTypeCacherJob.setPriority(Job.BUILD); typeCacherJob.setPriority(Job.BUILD);
fTypeCacherJob.schedule(); typeCacherJob.schedule();
} }
} }
} }