Attachment #177941 for bug #323392

Lines 61-66 Link Here

(-)src/org/eclipse/jst/jsp/core/internal/JSPCoreMessages.java (+3 lines)
61	public static String Initializing;	61	public static String Initializing;
62	public static String Persisting_JSP_Translations;	62	public static String Persisting_JSP_Translations;
63		63
		64	public static String JSPCorePlugin_Initializing_JSP_Tools;
		65	public static String JSPIndexManager;
		66
64	/**	67	/**
65	* @deprecated	68	* @deprecated
66	*/	69	*/

Lines 10-18 Link Here

(-)src/org/eclipse/jst/jsp/core/internal/JSPCorePlugin.java (-47 / +83 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jst.jsp.core.internal;	11	package org.eclipse.jst.jsp.core.internal;
12		12
		13	import org.eclipse.core.resources.IResourceChangeEvent;
		14	import org.eclipse.core.resources.IResourceChangeListener;
13	import org.eclipse.core.resources.ISaveContext;	15	import org.eclipse.core.resources.ISaveContext;
14	import org.eclipse.core.resources.ISaveParticipant;	16	import org.eclipse.core.resources.ISaveParticipant;
15	import org.eclipse.core.resources.ISavedState;	17	import org.eclipse.core.resources.ISavedState;
		18	import org.eclipse.core.resources.IWorkspace;
		19	import org.eclipse.core.resources.IWorkspaceRunnable;
16	import org.eclipse.core.resources.ResourcesPlugin;	20	import org.eclipse.core.resources.ResourcesPlugin;
17	import org.eclipse.core.runtime.CoreException;	21	import org.eclipse.core.runtime.CoreException;
18	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
Lines 24-30 Link Here
24	import org.eclipse.jst.jsp.core.internal.contentmodel.TaglibController;	28	import org.eclipse.jst.jsp.core.internal.contentmodel.TaglibController;
25	import org.eclipse.jst.jsp.core.internal.contentproperties.JSPFContentPropertiesManager;	29	import org.eclipse.jst.jsp.core.internal.contentproperties.JSPFContentPropertiesManager;
26	import org.eclipse.jst.jsp.core.internal.contenttype.DeploymentDescriptorPropertyCache;	30	import org.eclipse.jst.jsp.core.internal.contenttype.DeploymentDescriptorPropertyCache;
27	import org.eclipse.jst.jsp.core.internal.java.JSPTranslatorPersister;
28	import org.eclipse.jst.jsp.core.internal.java.search.JSPIndexManager;	31	import org.eclipse.jst.jsp.core.internal.java.search.JSPIndexManager;
29	import org.eclipse.jst.jsp.core.internal.taglib.TaglibHelperManager;	32	import org.eclipse.jst.jsp.core.internal.taglib.TaglibHelperManager;
30	import org.eclipse.jst.jsp.core.taglib.TaglibIndex;	33	import org.eclipse.jst.jsp.core.taglib.TaglibIndex;
Lines 34-52 Link Here
34	* The main plugin class to be used in the desktop.	37	* The main plugin class to be used in the desktop.
35	*/	38	*/
36	public class JSPCorePlugin extends Plugin {	39	public class JSPCorePlugin extends Plugin {
37	// The shared instance.	40	/** singleton instance of the plugin */
38	private static JSPCorePlugin plugin;	41	private static JSPCorePlugin plugin;
39
40	/** Save participant for this plugin */
41	ISaveParticipant fSaveParticipant;
42		42
43	/**	43	/**
		44	* <p>Job used to finish tasks needed to start up the plugin but that did not have
		45	* to block the plugin start up process.</p>
		46	*/
		47	private Job fPluginInitializerJob;
		48
		49	/**
44	* The constructor.	50	* The constructor.
45	*/	51	*/
46	public JSPCorePlugin() {	52	public JSPCorePlugin() {
47	super();	53	super();
48	plugin = this;	54	plugin = this;
49	fSaveParticipant = new SaveParticipant();	55	this.fPluginInitializerJob = new PluginInitializerJob();
50	}	56	}
51		57
52	/**	58	/**
Lines 65-71 Link Here
65	super.start(context);	71	super.start(context);
66		72
67	/*	73	/*
68	* JSPIndexManager depends on TaglibController, so TaglibController	74	* JSPIndexManager_old depends on TaglibController, so TaglibController
69	* should be started first	75	* should be started first
70	*/	76	*/
71	TaglibIndex.startup();	77	TaglibIndex.startup();
Lines 73-109 Link Here
73		79
74	// listen for classpath changes	80	// listen for classpath changes
75	JavaCore.addElementChangedListener(TaglibHelperManager.getInstance());	81	JavaCore.addElementChangedListener(TaglibHelperManager.getInstance());
76
77	//restore save state and process any events that happened before plugin loaded
78	if (JSPTranslatorPersister.ACTIVATED) {
79	Job persister = new Job(JSPCoreMessages.Initializing) {
80	protected IStatus run(IProgressMonitor monitor) {
81	ISavedState savedState = null;
82	try {
83	savedState = ResourcesPlugin.getWorkspace().addSaveParticipant(plugin.getBundle().getSymbolicName(), fSaveParticipant);
84	}
85	catch (CoreException e) {
86	Logger.logException("Could not load previous save state", e);
87	}
88	if (savedState != null) {
89	try {
90	Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
91	}
92	finally {
93	savedState.processResourceChangeEvents(JSPTranslatorPersister.getDefault());
94	}
95	}
96	return Status.OK_STATUS;
97	}
98	};
99	persister.setUser(false);
100	persister.schedule(2000);
101	// set up persister to listen to resource change events
102	ResourcesPlugin.getWorkspace().addResourceChangeListener(JSPTranslatorPersister.getDefault());
103	}
104		82
105	//init the JSP index	83	//schedule delayed initialization
106	JSPIndexManager.getInstance().initialize();	84	this.fPluginInitializerJob.schedule(2000);
107		85
108	// listen for resource changes to update content properties keys	86	// listen for resource changes to update content properties keys
109	JSPFContentPropertiesManager.startup();	87	JSPFContentPropertiesManager.startup();
Lines 119-140 Link Here
119	public void stop(BundleContext context) throws Exception {	97	public void stop(BundleContext context) throws Exception {
120	DeploymentDescriptorPropertyCache.stop();	98	DeploymentDescriptorPropertyCache.stop();
121		99
122	/*	100	// stop listening for resource changes to update content properties keys
123	* stop listening for resource changes to update content properties
124	* keys
125	*/
126	JSPFContentPropertiesManager.shutdown();	101	JSPFContentPropertiesManager.shutdown();
127		102
128	//remove the plugin save participant	103	//remove the plugin save participant
129	ResourcesPlugin.getWorkspace().removeSaveParticipant(plugin.getBundle().getSymbolicName());	104	ResourcesPlugin.getWorkspace().removeSaveParticipant(plugin.getBundle().getSymbolicName());
130		105
131	//remove the translator persister
132	if(JSPTranslatorPersister.ACTIVATED) {
133	ResourcesPlugin.getWorkspace().removeResourceChangeListener(JSPTranslatorPersister.getDefault());
134	}
135
136	// stop any indexing	106	// stop any indexing
137	JSPIndexManager.getInstance().shutdown();	107	JSPIndexManager.getDefault().stop();
138		108
139	// stop listening for classpath changes	109	// stop listening for classpath changes
140	JavaCore.removeElementChangedListener(TaglibHelperManager.getInstance());	110	JavaCore.removeElementChangedListener(TaglibHelperManager.getInstance());
Lines 147-152 Link Here
147	}	117	}
148		118
149	/**	119	/**
		120	* <p>A {@link Job} used to perform delayed initialization for the plugin</p>
		121	*/
		122	private static class PluginInitializerJob extends Job {
		123	/**
		124	* <p>Default constructor to set up this {@link Job} as a
		125	* long running system {@link Job}</p>
		126	*/
		127	protected PluginInitializerJob() {
		128	super(JSPCoreMessages.JSPCorePlugin_Initializing_JSP_Tools);
		129
		130	this.setUser(false);
		131	this.setSystem(true);
		132	this.setPriority(Job.LONG);
		133	}
		134
		135	/**
		136	* <p>Perform delayed initialization for the plugin</p>
		137	*
		138	* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		139	*/
		140	protected IStatus run(IProgressMonitor monitor) {
		141	IStatus status = Status.OK_STATUS;
		142	final IWorkspace workspace = ResourcesPlugin.getWorkspace();
		143	try {
		144	workspace.run(new IWorkspaceRunnable() {
		145	public void run(final IProgressMonitor worspaceMonitor) throws CoreException {
		146	ISavedState savedState = null;
		147
		148	try {
		149	//add the save participant for this bundle
		150	savedState = ResourcesPlugin.getWorkspace().addSaveParticipant(
		151	JSPCorePlugin.plugin.getBundle().getSymbolicName(), new SaveParticipant());
		152	} catch (CoreException e) {
		153	Logger.logException("JSP Core Plugin failed at loading previously saved state." +
		154	" All componenets dependent on this state will start as if first workspace load.", e);
		155	}
		156
		157	//if there is a saved state start up using that, else start up cold
		158	if(savedState != null) {
		159	try {
		160	Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
		161	} finally {
		162	savedState.processResourceChangeEvents(new IResourceChangeListener() {
		163	/**
		164	* @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
		165	*/
		166	public void resourceChanged(IResourceChangeEvent event) {
		167	JSPIndexManager.getDefault().start(event.getDelta(), worspaceMonitor);
		168	}
		169	});
		170	}
		171	} else {
		172	JSPIndexManager.getDefault().start(null, worspaceMonitor);
		173	}
		174	}
		175	}, monitor);
		176	} catch(CoreException e) {
		177	status = e.getStatus();
		178	}
		179
		180	return status;
		181	}
		182
		183	}
184
185	/**
150	* Used so that all of the IResourceChangeEvents that occurred before	186	* Used so that all of the IResourceChangeEvents that occurred before
151	* this plugin loaded can be processed.	187	* this plugin loaded can be processed.
152	*/	188	*/

Lines 47-50 Link Here

(-)src/org/eclipse/jst/jsp/core/internal/JSPCorePluginResources.properties (-1 / +4 lines)
47	TLDValidator_MissingVariable=The variable class '{0}' was not found on the Java Build Path	47	TLDValidator_MissingVariable=The variable class '{0}' was not found on the Java Build Path
48	TLDValidator_MissingListener=The listener class '{0}' was not found on the Java Build Path	48	TLDValidator_MissingListener=The listener class '{0}' was not found on the Java Build Path
49	Initializing=Processing JSP changes since last activation	49	Initializing=Processing JSP changes since last activation
50	Persisting_JSP_Translations=Persisting JSP Translations	50	Persisting_JSP_Translations=Persisting JSP Translations
		51
		52	JSPCorePlugin_Initializing_JSP_Tools=Initializing JSP Tools
		53	JSPIndexManager=JSP Index Manager




import java.util.Iterator;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;
import org.eclipse.jface.text.Position;

			return null;
		
		final String name = getClassname() + ".java";
		IPackageFragmentRoot packageFragmentRoot = null;
		IPackageFragmentRoot[] packageFragmentRoots = je.getPackageFragmentRoots();
		for (int i = 0; i < packageFragmentRoots.length; i++) {
			if (!packageFragmentRoots[i].isArchive() && !packageFragmentRoots[i].isExternal()) {
				packageFragmentRoot = packageFragmentRoots[i];
				break;
			}
		}
		if (packageFragmentRoot == null) {
			if(DEBUG) {
				System.out.println("** Abort create working copy: cannot create working copy: JSP is not in a Java project with source package fragment root"); //$NON-NLS-1$
			}
			return null;
		}
		final IPackageFragment fragment = packageFragmentRoot.getPackageFragment(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
		ICompilationUnit cu = fragment.getCompilationUnit(name).getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor());
		setContents(cu);

		if(DEBUG) {

Lines 115-121 Link Here

(-)src/org/eclipse/jst/jsp/core/internal/java/JSPTranslationAdapter.java (-1 / +2 lines)
115	fDocumentIsDirty = true;	115	fDocumentIsDirty = true;
116	}	116	}
117		117
118	public void release() {	118	public synchronized void release() {
119		119
120	if (fJspDocument != null)	120	if (fJspDocument != null)
121	fJspDocument.removeDocumentListener(this);	121	fJspDocument.removeDocumentListener(this);
Lines 129-134 Link Here
129	System.out.println("JSPTranslationAdapter releasing:" + fJSPTranslation); //$NON-NLS-1$	129	System.out.println("JSPTranslationAdapter releasing:" + fJSPTranslation); //$NON-NLS-1$
130		130
131	fJSPTranslation.release();	131	fJSPTranslation.release();
		132	fJSPTranslation = null;
132	}	133	}
133	}	134	}
134		135




import java.io.InvalidClassException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.LinkedList;
import java.util.zip.CRC32;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jst.jsp.core.internal.JSPCoreMessages;
import org.eclipse.jst.jsp.core.internal.JSPCorePlugin;
import org.eclipse.jst.jsp.core.internal.Logger;
import org.eclipse.jst.jsp.core.internal.java.search.JSPIndexManager;
import org.eclipse.jst.jsp.core.internal.modelhandler.ModelHandlerForJSP;
import org.eclipse.jst.jsp.core.internal.provisional.contenttype.ContentTypeIdForJSP;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.FileBufferModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;

import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;

/**
 * <p>This is a static class used to persist JSP translations and retrieve the persisted
 * translations.</p>
 * 
 * <p>It is not actually in charge of finding files to persist, rather it provides API
 * for some other mechanism that tracks JSP files to call into to persist the translations.</p>
 * <pre>
 * try {
 *   ISavedState savedState = ResourcesPlugin.getWorkspace().addSaveParticipant(
 *     plugin.getBundle().getSymbolicName(), this.fSaveParticipant);
 *   if (savedState != null) {
 *     savedState.processResourceChangeEvents(JSPTranslatorPersistor.getDefault());
 *   }
 * } catch(CoreException e) {}
 * ResourcesPlugin.getWorkspace().addResourceChangeListener(JSPTranslatorPersistor.getDefault());
 * </pre>
 * <b>Plugin Deactivation:</b>
 * <pre>
 * ResourcesPlugin.getWorkspace().removeSaveParticipant(plugin.getBundle().getSymbolicName());
 * ResourcesPlugin.getWorkspace().removeResourceChangeListener(JSPTranslatorPersistor.getDefault());
 * </pre></p>
 * 
 * <p>This class can be deactivated through the <code>persistJSPTranslations</code> system property,
 * a value of <code>true</code> means the persister is activated (which is the default), value of
 * <code>false</code> means the persister is not activated.</p>
 * 
 * @see JSPIndexManager
 */
public class JSPTranslatorPersister{
	/**
	 * <code>true</code> if the persister is activated, <code>false</code>
	 * otherwise.  This is determined by checking the system property

	/** used to calculate persisted translator file names */
	private static final CRC32 CHECKSUM_CALC = new CRC32();
	
	/** singleton instance of the {@link JSPTranslatorPersister} */
	private static final JSPTranslatorPersister INSTANCE = new JSPTranslatorPersister();
	
	/**
	 * Used to handle resource change events
	 * @see #resourceChanged(IResourceChangeEvent)
	 */
	private IResourceDeltaVisitor fResourceDeltaVisitor;
	
	/** {@link Job} that actually does all the persisting */
	protected PersisterJob fPersisterJob;
	
	/**
	 * <p>Private constructor to prevent creating an instance of this class</p>
	 */
	private JSPTranslatorPersister() {
		this.fResourceDeltaVisitor = new JSPResourceVisitor();
		this.fPersisterJob = new PersisterJob();
	}
	
	/**
	 * <p><b>NOTE: </b><i>This can possible return <code>null</code></i></p>
	 * 
	 * @return Singleton instance of the {@link JSPTranslatorPersister} if
	 * {@link #ACTIVATED} is <code>true</code>, <code>null</code> otherwise.
	 */
	public static JSPTranslatorPersister getDefault() {
		return ACTIVATED ? INSTANCE : null;
	}
	
	/**
	 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
	 */
	public void resourceChanged(IResourceChangeEvent event) {
		switch(event.getType()) {
			case IResourceChangeEvent.PRE_CLOSE:
			case IResourceChangeEvent.PRE_DELETE:
				//pre-close or pre-delete stop the persister job so it does not interfere
				this.fPersisterJob.stop();
				break;
			case IResourceChangeEvent.POST_CHANGE:
				//post change start up the persister job and process the delta
				this.fPersisterJob.start();
				
				// only analyze the full (starting at root) delta hierarchy
				IResourceDelta delta = event.getDelta();
				if (delta != null && delta.getFullPath().toString().equals("/")) { //$NON-NLS-1$
					try {
						//use visitor to visit all children
						delta.accept(this.fResourceDeltaVisitor, false);
					} catch (CoreException e) {
						Logger.logException("Processing resource change event delta failed, " +
								"persisted JSPTranslators may not have been updated.", e);
					}
				}
				break;
		}
	}
	
	/**

	}
	
	/**
	 * @param resource JSP resource who's translation should be persisted
	 */
	public static void persistTranslation(IResource resource) {
		if(ACTIVATED) {
			IPath path = resource.getFullPath();
			String filePath = getPersistedTranslatorFilePath(path.toPortableString());
			IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
	
			JSPTranslator translator = getJSPTranslator(file);
			if(translator != null) {
				persistTranslator(translator, filePath);
			}
		}
	}
	
	/**
	 * @param resource JSP resource who's translation should no longer be persisted
	 */
	public static void removePersistedTranslation(IResource resource) {
		if(ACTIVATED) {
			File file = getPersistedFile(resource.getFullPath());
			deletePersistedTranslator(file);
		}
	}
	
	/**
	 * @param resource JSP resource that has moved and thus its persisted translation should be updated
	 * @param fromPath Path the JSP resource moved from
	 */
	public static void movePersistedTranslation(IResource resource, IPath fromPath) {
		if(ACTIVATED) {
			File from = getPersistedFile(fromPath);
			File to = getPersistedFile(resource.getFullPath());
	
			renamePersistedTranslator(from, to);
		}
	}
	
	/**
	 * <p>Given the path to a JSP file determines the path to its persisted {@link JSPTranslator}</p>
	 * 
	 * @param jspFilePath {@link IPath} to JSP file for which the path to its persisted {@link JSPTranslator}

	 * @return OS file path to the persisted {@link JSPTranslator} associated with the JSP file at
	 * <code>jspFilePath</code>
	 */
	private static String getPersistedTranslatorFilePath(String jspFilePath) {
		CHECKSUM_CALC.reset();
		CHECKSUM_CALC.update(jspFilePath.getBytes());
		String persistedTranslatorFileName = Long.toString(CHECKSUM_CALC.getValue()) + ".translator"; //$NON-NLS-1$

	}
	
	/**
	 * <p>Gets the associated {@link JSPTranslator} for a specific JSP file.</p>
	 * <p><b>NOTE: </b><i>This does not get the persisted translator but rather the
	 * associated translator in memory</i></p>
	 * 
	 * @param jspFile {@link IFile} to the JSP file that the associated {@link JSPTranslator}
	 * is needed for
	 * @return {@link JSPTranslator} associated with the given <code>jspFilePath</code>, or
	 * <code>null</code> if none can be found.
	 */
	private static JSPTranslator getJSPTranslator(IFile jspFile) {
		IStructuredModel model = null;
		JSPTranslator translator = null;
		try {
			model = StructuredModelManager.getModelManager().getModelForRead(jspFile);
			if(model instanceof IDOMModel) {
				IDOMDocument doc = ((IDOMModel)model).getDocument();
				ModelHandlerForJSP.ensureTranslationAdapterFactory(model);
				JSPTranslationAdapter adapter = (JSPTranslationAdapter)doc.getAdapterFor(IJSPTranslation.class);
				
				//don't want to persist a translator that has not already been requested
				if(adapter != null && adapter.hasTranslation()) {
					translator = adapter.getJSPTranslation().getTranslator();
		 */
		public boolean visit(IResourceDelta delta) throws CoreException {
			if(isJSPResource(delta.getResource())) {
				switch (delta.getKind()) {
					case IResourceDelta.CHANGED :
					case IResourceDelta.ADDED : {
						/* if a move, then move the persisted translation
						 * else create a new persisted translation, if its a change then
						 *   the old persisted translation will be overwritten */
						if((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
							final File from = getPersistedFile(delta.getMovedFromPath());
							final File to = getPersistedFile(delta.getFullPath());
							//add the move action to the persister job
							JSPTranslatorPersister.this.fPersisterJob.addAction(new ISafeRunnable() {
								public void run() throws Exception {
									renamePersistedTranslator(from, to);
								}

								public void handleException(Throwable exception) {}
							});
						} else {
							final String filePath = getPersistedTranslatorFilePath(delta.getFullPath().toPortableString());
							final IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(delta.getFullPath());
							//add the add action to the persister job
							JSPTranslatorPersister.this.fPersisterJob.addAction(new ISafeRunnable() {
								public void run() throws Exception {
									JSPTranslator translator = getJSPTranslator(file);
									if(translator != null) {
										persistTranslator(translator, filePath);
									}
								}

								public void handleException(Throwable exception) {}
							});
						}
						
						break;
					}
					case IResourceDelta.REMOVED : {
						/* only remove if its not a move,
						 * if it is a move the added file delta event will move translation */
						if((delta.getFlags() & IResourceDelta.MOVED_TO) == 0) {
							final File file = getPersistedFile(delta.getFullPath());
							//add the delete action to the persister job
							JSPTranslatorPersister.this.fPersisterJob.addAction(new ISafeRunnable() {
								public void run() throws Exception {
									deletePersistedTranslator(file);
								}

								public void handleException(Throwable exception) {}
							});
						}
						break;
					}
				}
			}
			
			//visit children deltas
			return true;
		}
		
		/**
		 * <p>Determines if an {@link IResource} is a JSP resource</p>
		 * 
		 * @param resource determine if this {@link IResource} is a JSP resource
		 * @return <code>true</code> if <code>resource</code> is a JSP resource,
		 * <code>false</code> otherwise.
		 */
		private boolean isJSPResource(IResource resource) {
			boolean isJSP = false;
			
			//general rule for getting files in the workspace
			if(resource.getFullPath().segmentCount() >= 2) {
				IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(resource.getFullPath());
				if(file.getType() == IResource.FILE) {
					//get JSP content type each time because there is a possibility it could change
					IContentType contentTypeJSP = Platform.getContentTypeManager().getContentType(
							ContentTypeIdForJSP.ContentTypeID_JSP);
					
					isJSP = contentTypeJSP.isAssociatedWith(file.getName());
				}
			}
			
			return isJSP;
		}
		
		/**
		 * <p>Gets the associated {@link JSPTranslator} for a specific JSP file.</p>
		 * <p><b>NOTE: </b><i>This does not get the persisted translator but rather the
		 * associated translator in memory</i></p>
		 * 
		 * @param jspFile {@link IFile} to the JSP file that the associated {@link JSPTranslator}
		 * is needed for
		 * @return {@link JSPTranslator} associated with the given <code>jspFilePath</code>, or
		 * <code>null</code> if none can be found.
		 */
		protected JSPTranslator getJSPTranslator(IFile jspFile) {
			IStructuredModel model = null;
			JSPTranslator translator = null;
			try {
				model = StructuredModelManager.getModelManager().getModelForRead(jspFile);
				if(model instanceof IDOMModel) {
					IDOMDocument doc = ((IDOMModel)model).getDocument();
					ModelHandlerForJSP.ensureTranslationAdapterFactory(model);
					JSPTranslationAdapter adapter = (JSPTranslationAdapter)doc.getAdapterFor(IJSPTranslation.class);
					
					//don't want to persist a translator that has not already been requested
					if(adapter != null && adapter.hasTranslation()) {
						translator = adapter.getJSPTranslation().getTranslator();
					}
				}
			} catch (IOException e) {
				Logger.logException("Could not get translator for " + jspFile.getName() + //$NON-NLS-1$
						" because could not read model for same.", e); //$NON-NLS-1$
			} catch (CoreException e) {
				Logger.logException("Could not get translator for " + jspFile.getName() + //$NON-NLS-1$
						" because could not read model for same.", e); //$NON-NLS-1$
			} finally {
				if(model != null) {
					model.releaseFromRead();
				}
			}
		} catch (IOException e) {
			Logger.logException("Could not get translator for " + jspFile.getName() + //$NON-NLS-1$
					" because could not read model for same.", e); //$NON-NLS-1$
		} catch (CoreException e) {
			Logger.logException("Could not get translator for " + jspFile.getName() + //$NON-NLS-1$
					" because could not read model for same.", e); //$NON-NLS-1$
		} finally {
			if(model != null) {
				model.releaseFromRead();
		 */
		protected void persistTranslator(JSPTranslator translator, String filePath) {
			try {
				FileOutputStream fos = new FileOutputStream(filePath);
				ObjectOutputStream out = new ObjectOutputStream(fos);
				out.writeObject(translator);
				out.close();
			} catch (IOException e) {
				Logger.logException("Was unable to externalize JSPTranslator " + translator + //$NON-NLS-1$
						" to " + filePath, e); //$NON-NLS-1$
			}
		}
		
		return translator;
		 * <p>Deletes a persisted translation for a JSP file that has been deleted</p>
		 * 
		 * @param jspFilePath {@link IPath} to the JSP file that has been deleted
		 */
		protected void deletePersistedTranslator(File file) {
			file.delete();
		}
		
		/**
		 * <p>Renames a persisted translation for a JSP file that has moved</p>
		 * 
		 * @param jspPrevFilePath {@link IPath} to the previous location of JSP file</p>
		 * @param jspNewFilePath {@link IPath} to new location of JSP file</p>
		 */
		protected void renamePersistedTranslator(File from, File to) {
			//do the move
			from.renameTo(to);
		}

		private File getPersistedFile(IPath path) {
			return new File(getPersistedTranslatorFilePath(path.toPortableString()));
		}
	}
	
	/**
	 * <p>Persists a {@link JSPTranslator} to disk for a specific JSP file</p>
	 * 
	 * @param translator {@link JSPTranslator} to persist to disk
	 * @param jspFilePath {@link IPath} to the JSP file the given <code>translator</code> is for
	 */
	private static void persistTranslator(JSPTranslator translator, String filePath) {
		try {
			FileOutputStream fos = new FileOutputStream(filePath);
			ObjectOutputStream out = new ObjectOutputStream(fos);
			out.writeObject(translator);
			out.close();
		} catch (IOException e) {
			Logger.logException("Was unable to externalize JSPTranslator " + translator + //$NON-NLS-1$
					" to " + filePath, e); //$NON-NLS-1$
		private LinkedList fActions;
		
		/** Whether this job has been stopped or not */
		private boolean fIsStopped;
		
		/**
		 * <p>Sets job up as a system job</p>
		 */
		protected PersisterJob() {
			super(JSPCoreMessages.Persisting_JSP_Translations);
			this.setUser(false);
			this.setSystem(true);
			this.setPriority(Job.LONG);
			
			this.fActions = new LinkedList();
			this.fIsStopped = false;
		}
		
		/**
		 * <p>Starts this job.  This has no effect if the job is already started.</p>
		 * <p>This should be used in place of {@link Job#schedule()} to reset state
		 * caused by calling {@link #stop()}</p>
		 * 
		 * @see #stop()
		 */
		protected synchronized void start() {
			this.fIsStopped = false;
			
			//get the job running again depending on its current state
			if(this.getState() == Job.SLEEPING) {
				this.wakeUp(DELAY);
			} else {
				this.schedule(DELAY);
			}
		}
		
		/**
		 * <p>Stops this job, even if it is running</p>
		 * <p>This should be used in place of {@link Job#sleep()} because {@link Job#sleep()}
		 * will not stop a job that is already running but calling this will stop this job
		 * even if it is running. {@link #start()} must be used to start this job again</p>
		 * 
		 * @see #start()
		 */
		protected synchronized void stop() {
			//sleep the job if it is waiting to run
			this.sleep();
			
			//if job is already running will force it to stop
			this.fIsStopped = true;
		}
		
		/**
		 * @param action {@link ISafeRunnable} containing a persister action to take
		 * based on an {@link IResourceDelta} processed by {@link JSPResourceVisitor}
		 */
		protected void addAction(ISafeRunnable action) {
			//add the action
			synchronized (this.fActions) {
				this.fActions.addLast(action);
			}
			
			//if job has not been manually stopped, then start it
			if(!this.fIsStopped) {
				this.start();
			}
		}
	}
	
	/**
	 * <p>Deletes a persisted translation for a JSP file that has been deleted</p>
	 * 
	 * @param jspFilePath {@link IPath} to the JSP file that has been deleted
	 */
	private static void deletePersistedTranslator(File file) {
		file.delete();
	}
	
	/**
	 * <p>Renames a persisted translation for a JSP file that has moved</p>
	 * 
	 * @param jspPrevFilePath {@link IPath} to the previous location of JSP file</p>
	 * @param jspNewFilePath {@link IPath} to new location of JSP file</p>
	 */
	private static void renamePersistedTranslator(File from, File to) {
		//do the move
		from.renameTo(to);
	}

	private static File getPersistedFile(IPath path) {
		return new File(getPersistedTranslatorFilePath(path.toPortableString()));
		 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		 */
		protected IStatus run(IProgressMonitor monitor) {
			/*  run so long as job has not been stopped,
			 *monitor canceled, and have actions to process */
			while(!this.fIsStopped && !monitor.isCanceled() && !this.fActions.isEmpty()) {
				ISafeRunnable action;
				synchronized (this.fActions) {
					action = (ISafeRunnable)this.fActions.removeFirst();
				}
				
				SafeRunner.run(action);
			}
			
			return Status.OK_STATUS;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2004, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.jsp.core.internal.java.search;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jst.jsp.core.internal.JSPCoreMessages;
import org.eclipse.jst.jsp.core.internal.provisional.contenttype.ContentTypeIdForJSP;

/**
 * Re-indexes the entire workspace.
 * Ensures the JSP Index is in a stable state before performing a search.
 * (like after a crash or if previous indexing was canceled)
 * 
 * @author pavery
 */
public class IndexWorkspaceJob extends Job {

	// for debugging
	static final boolean DEBUG;
	static {
		String value= Platform.getDebugOption("org.eclipse.jst.jsp.core/debug/jspindexmanager"); //$NON-NLS-1$
		DEBUG= value != null && value.equalsIgnoreCase("true"); //$NON-NLS-1$
	}
	
	/**
	 * Visitor that retrieves jsp project paths for all jsp files in the workspace,
	 * and adds the files to be indexed as they are encountered
	 */
	private class JSPFileVisitor implements IResourceProxyVisitor {
	    private List files = new ArrayList(); 
		
		// monitor from the Job
		IProgressMonitor fInnerMonitor = null;
		public JSPFileVisitor(IProgressMonitor monitor) {
			this.fInnerMonitor = monitor;
		}
		
		public boolean visit(IResourceProxy proxy) throws CoreException {
			
			// check job canceled
			if (this.fInnerMonitor != null && this.fInnerMonitor.isCanceled()) {
				setCanceledState();
				return false;
			}
			
			// check search support canceled
			if(JSPSearchSupport.getInstance().isCanceled()) {
				setCanceledState();
				return false;
			}
			
			if (proxy.getType() == IResource.FILE) {
				
				// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=3553
				// check this before description
				// check name before actually getting the file (less work)
				if(getJspContentType().isAssociatedWith(proxy.getName())) {
					IFile file = (IFile) proxy.requestResource();
					if(file.exists()) {
						
						if(DEBUG)
							System.out.println("(+) IndexWorkspaceJob adding file: " + file.getName()); //$NON-NLS-1$
						// this call will check the ContentTypeDescription, so don't need to do it here.
						//JSPSearchSupport.getInstance().addJspFile(file);
						this.files.add(file);
						this.fInnerMonitor.subTask(proxy.getName());
						
						// don't search deeper for files
						return false;
					}
				}
			}
			return true;
		}
		
		public final IFile[] getFiles() {
		    return (IFile[])this.files.toArray(new IFile[this.files.size()]);
		}
	}
	
	private IContentType fContentTypeJSP = null;
	
	public IndexWorkspaceJob() {
		// pa_TODO may want to say something like "Rebuilding JSP Index" to be more
		// descriptive instead of "Updating JSP Index" since they are 2 different things
		super(JSPCoreMessages.JSPIndexManager_0);
		setPriority(Job.LONG);
		setSystem(true);
	}

	IContentType getJspContentType() {
		if(this.fContentTypeJSP == null)
			this.fContentTypeJSP = Platform.getContentTypeManager().getContentType(ContentTypeIdForJSP.ContentTypeID_JSP);
		return this.fContentTypeJSP;
	}
	
	/**
	 * @see org eclipse.core.internal.jobs.InternalJob#run(org.eclipse.core.runtime.IProgressMonitor) 
	 * for similar method
	 */
	protected IStatus run(IProgressMonitor monitor) {
		
		IStatus status = Status.OK_STATUS;
		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
		
		if(monitor.isCanceled()) {
			setCanceledState();
			return Status.CANCEL_STATUS;
		}
		
		if(DEBUG)
			System.out.println(" ^ IndexWorkspaceJob started: "); //$NON-NLS-1$
		
		long start = System.currentTimeMillis();
		
		try {
		    JSPFileVisitor visitor = new JSPFileVisitor(monitor);
		    // collect all jsp files
			ResourcesPlugin.getWorkspace().getRoot().accept(visitor, IResource.DEPTH_INFINITE);
			// request indexing
			// this is pretty much like faking an entire workspace resource delta
			JSPIndexManager.getInstance().indexFiles(visitor.getFiles());
		}
		catch (CoreException e) {
			if(DEBUG)
				e.printStackTrace();
		}
		finally {
			monitor.done();
		}
		long finish = System.currentTimeMillis();
		if(DEBUG)
			System.out.println(" ^ IndexWorkspaceJob finished\n   total time running: " + (finish - start)); //$NON-NLS-1$
		
		return status;
	}
	
	void setCanceledState() {
		JSPIndexManager.getInstance().setIndexState(JSPIndexManager.S_CANCELED);
	}
}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 *******************************************************************************/
package org.eclipse.jst.jsp.core.internal.java.search;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.core.JavaModelManager;
import org.eclipse.jdt.internal.core.index.Index;
import org.eclipse.jdt.internal.core.search.indexing.IndexManager;
import org.eclipse.jst.jsp.core.internal.JSPCoreMessages;
import org.eclipse.jst.jsp.core.internal.JSPCorePlugin;
import org.eclipse.jst.jsp.core.internal.Logger;
import org.eclipse.jst.jsp.core.internal.java.JSPTranslatorPersister;
import org.eclipse.jst.jsp.core.internal.provisional.contenttype.ContentTypeIdForJSP;
import org.eclipse.wst.sse.core.indexing.AbstractIndexManager;
import org.osgi.framework.Bundle;

/**
 * <p>Index manger used to update the JDT index with the Java translations
 * of JSPs.</p>
 * 
 * <p>Also keeps JSP persistence up to date</p>
 * 
 * <p>Any action that needs the JDT index to have all of the latest JSP changes processed
 * should wait for this manger to report that it is consistent,
 * {@link #waitForConsistant(org.eclipse.core.runtime.IProgressMonitor)}.  Such actions
 * include but are not limited to searching and refactoring JSPs.</p>
 */
public class JSPIndexManager extends AbstractIndexManager {
	/** the singleton instance of the {@link JSPIndexManager} */
	private static JSPIndexManager INSTANCE;
	
	/** the JSP {@link IContentType} */
	private static final IContentType JSP_CONTENT_TYPE =
		Platform.getContentTypeManager().getContentType(ContentTypeIdForJSP.ContentTypeID_JSP);
	
	/** the location to store state */
	private IPath fWorkingLocation;
	

	private IndexWorkspaceJob indexingJob = new IndexWorkspaceJob();



	// TODO: consider enumeration for these int constants
	// set to S_UPDATING once a resource change comes in
	// set to S_STABLE if:
	// - we know we aren't interested in the resource change
	// - or the ProcessFilesJob completes
	// set to S_CANCELED if an indexing job is canceled
	// set to S_REBUILDING if re-indexing the entire workspace

	// the int '0' is reserved for the default value if a preference is not
	// there
	/** index is reliable to use */
	public static final int S_STABLE = 1;
	/** index is being updated (from a resource delta) */
	public static final int S_UPDATING = 2;
	/** entire index is being rebuilt */
	public static final int S_REBUILDING = 3;
	/**
	 * indexing job was canceled in the middle of it, index needs to be
	 * rebuilt
	 */
	public static final int S_CANCELED = 4;

	/** symbolic name for OSGI framework */
	private final String OSGI_FRAMEWORK_ID = "org.eclipse.osgi"; //$NON-NLS-1$

	/**
	 * Collects JSP files from a resource delta.
	 */
	private class JSPResourceVisitor implements IResourceDeltaVisitor {
		// using hash map ensures only one of each file
		// must be reset before every use
		private HashMap jspFiles = null;

		public JSPResourceVisitor() {
			this.jspFiles = new HashMap();
		}

		public boolean visit(IResourceDelta delta) throws CoreException {

			// in case JSP search was canceled (eg. when closing the editor)
			if (JSPSearchSupport.getInstance().isCanceled() || frameworkIsShuttingDown()) {
				setCanceledState();
				return false;
			}

			try {
				if (!isHiddenResource(delta.getFullPath())) {

					int kind = delta.getKind();
					boolean added = (kind & IResourceDelta.ADDED) == IResourceDelta.ADDED;
					boolean isInterestingChange = false;
					if ((kind & IResourceDelta.CHANGED) == IResourceDelta.CHANGED) {
						int flags = delta.getFlags();
						// ignore things like marker changes
						isInterestingChange = (flags & IResourceDelta.CONTENT) == IResourceDelta.CONTENT || (flags & IResourceDelta.REPLACED) == IResourceDelta.REPLACED;
					}
					boolean removed = (kind & IResourceDelta.REMOVED) == IResourceDelta.REMOVED;
					if (added || isInterestingChange) {

						visitAdded(delta);
					}
					else if (removed) {
						visitRemoved(delta);
					}
				}
			}
			catch (Exception e) {
				// need to set state here somehow, and reindex
				// otherwise index will be unreliable
				if (DEBUG)
					Logger.logException("Delta analysis may not be complete", e); //$NON-NLS-1$
			}
			// if the delta has children, continue to add/remove files
			return true;
		}

		private void visitRemoved(IResourceDelta delta) {
			// handle cleanup
			if (delta.getResource() != null) {
				IResource r = delta.getResource();
				if (r.getType() == IResource.FOLDER && r.exists()) {
					deleteIndex((IFile) r);
				}
			}
		}

		private void visitAdded(IResourceDelta delta) {
			// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=3553
			// quick check if it's even JSP related to improve
			// performance
			// checking name from the delta before getting
			// resource because it's lighter
			String filename = delta.getFullPath().lastSegment();
			if (filename != null && getJspContentType().isAssociatedWith(filename)) {
				IResource r = delta.getResource();
				if (r != null && r.exists() && r.getType() == IResource.FILE) {
					this.jspFiles.put(r.getFullPath(), r);
				}
			}
		}

		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=93463
		private boolean isHiddenResource(IPath p) {
			String[] segments = p.segments();
			for (int i = 0; i < segments.length; i++) {
				if (segments[i].startsWith(".")) //$NON-NLS-1$
					return true;
			}
			return false;
		}

		private void deleteIndex(IFile folder) {
			// cleanup index
			IndexManager im = JavaModelManager.getIndexManager();
			IPath folderPath = folder.getFullPath();
			IPath indexLocation = JSPSearchSupport.getInstance().computeIndexLocation(folderPath);
			im.removeIndex(indexLocation);
			// im.indexLocations.removeKey(folderPath);
			// im.indexLocations.removeValue(indexLocation);
			File f = indexLocation.toFile();
			f.delete();
		}

		public IFile[] getFiles() {
			return (IFile[]) this.jspFiles.values().toArray(new IFile[this.jspFiles.size()]);
		}

		public void reset() {
			this.jspFiles.clear();
		}
	}

	// end class JSPResourceVisitor

	/**
	 * <p>Private singleton constructor</p>
	 */
	private class ProcessFilesJob extends Job {
		List fileList = null;
		// keep track of how many files we've indexed
		int lastFileCursor = 0;

		ProcessFilesJob(String taskName) {
			super(taskName);
			fileList = new ArrayList();
		}

		synchronized void process(IFile[] files) {
			for (int i = 0; i < files.length; i++) {
				fileList.add(files[i]);
			}
			if (DEBUG) {
				System.out.println("JSPIndexManager queuing " + files.length + " files"); //$NON-NLS-2$ //$NON-NLS-1$
			}
		}

		synchronized IFile[] getFiles() {
			return (IFile[]) fileList.toArray(new IFile[fileList.size()]);
		}

		synchronized void clearFiles() {
			fileList.clear();
			lastFileCursor = 0;
			//System.out.println("cleared files");
		}

		protected IStatus run(IProgressMonitor monitor) {
			// System.out.println("indexer monitor" + monitor);
			if (isCanceled(monitor) || frameworkIsShuttingDown()) {
				setCanceledState();
				return Status.CANCEL_STATUS;
			}

			Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
			long start = System.currentTimeMillis();

			try {
				IFile[] filesToBeProcessed = getFiles();

				if (DEBUG) {
					System.out.println("JSPIndexManager indexing " + filesToBeProcessed.length + " files"); //$NON-NLS-2$ //$NON-NLS-1$
				}
				// API indicates that monitor is never null
				monitor.beginTask("", filesToBeProcessed.length); //$NON-NLS-1$
				JSPSearchSupport ss = JSPSearchSupport.getInstance();
				String processingNFiles = ""; //$NON-NLS-1$


				for (;lastFileCursor < filesToBeProcessed.length; lastFileCursor++) {

					if (isCanceled(monitor) || frameworkIsShuttingDown()) {
						setCanceledState();
						return Status.CANCEL_STATUS;
					}
					IFile file = filesToBeProcessed[lastFileCursor];
					try {
						IProject project = file.getProject();
						if (project != null) {
							IJavaProject jproject = JavaCore.create(project);
							if (jproject.exists()) {
								ss.addJspFile(file);
								if (DEBUG) {
									System.out.println("JSPIndexManager Job added file: " + file.getName()); //$NON-NLS-1$
								}
							}
							// JSP Indexer processing n files
							processingNFiles = NLS.bind(JSPCoreMessages.JSPIndexManager_2, new String[]{Integer.toString((filesToBeProcessed.length - lastFileCursor))});
							monitor.subTask(processingNFiles + " - " + file.getName()); //$NON-NLS-1$
							monitor.worked(1);
						}
					}
					catch (Exception e) {
						// RATLC00284776
						// ISSUE: we probably shouldn't be catching EVERY
						// exception, but
						// the framework only allows to return IStatus in
						// order to communicate
						// that something went wrong, which means the loop
						// won't complete, and we would hit the same problem
						// the next time.
						// 
						// a possible solution is to keep track of the
						// exceptions logged
						// and only log a certain amt of the same one,
						// otherwise skip it.
						if (!frameworkIsShuttingDown()) {
							String filename = file != null ? file.getFullPath().toString() : ""; //$NON-NLS-1$
							Logger.logException("JSPIndexer problem indexing:" + filename, e); //$NON-NLS-1$
						}
					}
				} // end for
			}
			finally {
				// just in case something didn't follow API (monitor is null)
				if (monitor != null)
					monitor.done();
			}

			// successfully finished, clear files list
			clearFiles();
			
			long finish = System.currentTimeMillis();
			long diff = finish - start;
			if (DEBUG) {
				fTotalTime += diff;
				System.out.println("============================================================================"); //$NON-NLS-1$
				System.out.println("this time: " + diff + " cumulative time for resource changed: " + fTotalTime); //$NON-NLS-1$ //$NON-NLS-2$
				System.out.println("============================================================================"); //$NON-NLS-1$
			}
			return Status.OK_STATUS;
		}

		private boolean isCanceled(IProgressMonitor runMonitor) {

			boolean canceled = false;
			// check specific monitor passed into run method (the progress
			// group in this case)
			// check main search support canceled
			if (runMonitor != null && runMonitor.isCanceled())
				canceled = true;
			else if (JSPSearchSupport.getInstance().isCanceled()) {
				canceled = true;
				if (runMonitor != null) {
					runMonitor.setCanceled(true);
				}
			}
			return canceled;
		}
		
	}

	// end class ProcessFilesJob

	private static JSPIndexManager fSingleton = null;
	private boolean initialized;
	private boolean initializing = true;

	private IndexJobCoordinator indexJobCoordinator;
	private IResourceChangeListener jspResourceChangeListener;

	private JSPResourceVisitor fVisitor = null;
	private IContentType fContentTypeJSP = null;

	static long fTotalTime = 0;

	// Job for processing resource delta
	private ProcessFilesJob processFilesJob = null;

	private JSPIndexManager() {
		super(JSPCoreMessages.JSPIndexManager);
		// only show in verbose mode
		processFilesJob.setSystem(true);
		processFilesJob.setPriority(Job.LONG);
		processFilesJob.addJobChangeListener(new JobChangeAdapter() {
			public void done(IJobChangeEvent event) {
				super.done(event);
				setStableState();
			}
		});
	}

	public synchronized static JSPIndexManager getInstance() {

		if (fSingleton == null)
			fSingleton = new JSPIndexManager();
		return fSingleton;
	}

	public void initialize() {

		JSPIndexManager singleInstance = getInstance();


		if (!singleInstance.initialized) {
			singleInstance.initialized = true;
			singleInstance.initializing = true;

			singleInstance.indexJobCoordinator = new IndexJobCoordinator();
			singleInstance.jspResourceChangeListener = new JSPResourceChangeListener();

			// added as JobChange listener so JSPIndexManager can be smarter
			// about when it runs
			Platform.getJobManager().addJobChangeListener(singleInstance.indexJobCoordinator);

			// add JSPIndexManager to keep JSP Index up to date
			// listening for IResourceChangeEvent.PRE_DELETE and
			// IResourceChangeEvent.POST_CHANGE
			ResourcesPlugin.getWorkspace().addResourceChangeListener(jspResourceChangeListener, IResourceChangeEvent.POST_CHANGE);

			// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=5091
			// makes sure IndexManager is aware of our indexes
			saveIndexes();
			singleInstance.initializing = false;
		}

	}
	
	synchronized void setIndexState(int state) {
		if (DEBUG) {
			System.out.println("JSPIndexManager setting index state to: " + state2String(state)); //$NON-NLS-1$
		}
		Plugin jspModelPlugin = JSPCorePlugin.getDefault();
		jspModelPlugin.getPluginPreferences().setValue(PKEY_INDEX_STATE, state);
		jspModelPlugin.savePluginPreferences();

	}

	private String state2String(int state) {
		String s = "UNKNOWN"; //$NON-NLS-1$
		switch (state) {
			case (S_STABLE) :
				s = "S_STABLE"; //$NON-NLS-1$
				break;
			case (S_UPDATING) :
				s = "S_UPDATING"; //$NON-NLS-1$
				break;
			case (S_CANCELED) :
				s = "S_CANCELED"; //$NON-NLS-1$
				break;
			case (S_REBUILDING) :
				s = "S_REBUILDING"; //$NON-NLS-1$
				break;
		}
		return s;
	}

	int getIndexState() {
		return JSPCorePlugin.getDefault().getPluginPreferences().getInt(PKEY_INDEX_STATE);
	}

	void setUpdatingState() {
		//if (getIndexState() != S_CANCELED)
		setIndexState(S_UPDATING);
	}

	void setCanceledState() {
		setIndexState(JSPIndexManager.S_CANCELED);
	}

	void setStableState() {
		//if (getIndexState() != S_CANCELED)
		setIndexState(S_STABLE);
	}

	void setRebuildingState() {
		setIndexState(S_REBUILDING);
	}

	synchronized void rebuildIndexIfNeeded() {
		if (getIndexState() != S_STABLE) {
			rebuildIndex();
		}
	}

	void rebuildIndex() {

		if (DEBUG)
			System.out.println("*** JSP Index unstable, requesting re-indexing"); //$NON-NLS-1$

		getIndexingJob().addJobChangeListener(new JobChangeAdapter() {
			public void aboutToRun(IJobChangeEvent event) {
				super.aboutToRun(event);
				setRebuildingState();
			}

			public void done(IJobChangeEvent event) {
				super.done(event);
				setStableState();
				getIndexingJob().removeJobChangeListener(this);
			}
		});
		// we're about to reindex everything anyway
		getProcessFilesJob().clearFiles();
		getIndexingJob().schedule();

	}

	/**
	 * @return the singleton instance of the {@link JSPIndexManager}
	 * indexing should be done through this method or processFiles(IFile file)
	 * 
	 * @param files
	 */
	public static JSPIndexManager getDefault() {
		return INSTANCE != null ? INSTANCE : (INSTANCE = new JSPIndexManager());
		// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=4931
		// processFiles.setRule(new IndexFileRule());
		processFilesJob.process(files);
	}


	/**
	 * @see indexer.internal.indexing.AbstractIndexManager#isResourceToIndex(int, java.lang.String)
	 * 
	 * @return
	 */
	protected boolean isResourceToIndex(int type, String name) {
		return type == IResource.FILE && JSP_CONTENT_TYPE.isAssociatedWith(name);
		if (this.fVisitor == null) {
			this.fVisitor = new JSPResourceVisitor();
		}
		return this.fVisitor;
	}

	// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=5091
	// makes sure IndexManager is aware of our indexes
	void saveIndexes() {
		IndexManager indexManager = JavaModelManager.getIndexManager();
		IPath jspModelWorkingLocation = JSPSearchSupport.getInstance().getModelJspPluginWorkingLocation();

		File folder = new File(jspModelWorkingLocation.toOSString());
		String[] files = folder.list();
		String locay = ""; //$NON-NLS-1$
		Index index = null;
		try {
			for (int i = 0; i < files.length; i++) {
				if (files[i].toLowerCase().endsWith(".index")) { //$NON-NLS-1$
					locay = jspModelWorkingLocation.toString() + "/" + files[i]; //$NON-NLS-1$
					// reuse index file
					index = new Index(locay, "Index for " + locay, true); //$NON-NLS-1$
					indexManager.saveIndex(index);
				}
			}
		}
		catch (Exception e) {
			// we should be shutting down, want to shut down quietly
			if (DEBUG)
				e.printStackTrace();
		}
	}

	IContentType getJspContentType() {
		if (this.fContentTypeJSP == null)
			this.fContentTypeJSP = Platform.getContentTypeManager().getContentType(ContentTypeIdForJSP.ContentTypeID_JSP);
		return this.fContentTypeJSP;
	}

	/**
	 * @see indexer.internal.indexing.AbstractIndexManager#getWorkingLocation()
	 * 
	 * @return true if the System Bundle is stopped (ie. the framework is
	 *         shutting down)
	 */
	protected IPath getWorkingLocation() {
		if(this.fWorkingLocation == null) {
			//create path to working area
    		IPath workignLocation =
    			JSPCorePlugin.getDefault().getStateLocation().append("jspsearch"); //$NON-NLS-1$
		boolean shuttingDown = Platform.getBundle(OSGI_FRAMEWORK_ID).getState() == Bundle.STOPPING;
		if (DEBUG && shuttingDown) {
			System.out.println("JSPIndexManager: system is shutting down!"); //$NON-NLS-1$
		}
		return shuttingDown;
	}


            // ensure that it exists on disk
            File folder = new File(workignLocation.toOSString());
    		if (!folder.isDirectory()) {
    			try {
    				folder.mkdir();
    			}
    			catch (SecurityException e) {
    				Logger.logException(this.fName +
    						": Error while creating state location: " + folder +
    						" This renders the index manager irrevocably broken for this workspace session",
    						e);
    			}
    		}
    		
    		this.fWorkingLocation = workignLocation;
    	}
    	
        return this.fWorkingLocation;
		// done before continuing, since we are shutting down
		waitTillNotRunning(maxwait, processFilesJob);

		if (indexingJob != null) {
			indexingJob.cancel();
		}
		waitTillNotRunning(maxwait, processFilesJob);
	}

	private void waitTillNotRunning(int maxSeconds, Job job) {
		int pauseTime = 10;
		int maxtries = maxSeconds / pauseTime;
		int count = 0;
		while (count++ < maxtries && job.getState() == Job.RUNNING) {
			try {
				Thread.sleep(pauseTime);
				// System.out.println("count: " + count + " max: " +
				// maxtries);
			}
			catch (InterruptedException e) {
				Logger.logException(e);
			}
		}
	}

	/**
	 * @see indexer.internal.indexing.AbstractIndexManager#performAction(byte, byte, org.eclipse.core.resources.IResource, org.eclipse.core.runtime.IPath)
	 */
	protected void performAction(byte source, byte action, IResource resource,
			IPath movePath) {
		
		//inform the persister of the action unless it come from a full workspace scan
		if(JSPTranslatorPersister.ACTIVATED && source != AbstractIndexManager.SOURCE_WORKSPACE_SCAN) {
			switch(action) {
				case AbstractIndexManager.ACTION_ADD: {
					JSPTranslatorPersister.persistTranslation(resource);
					break;
				}
				case AbstractIndexManager.ACTION_REMOVE: {
					JSPTranslatorPersister.removePersistedTranslation(resource);
					break;
				}
				case AbstractIndexManager.ACTION_ADD_MOVE_FROM: {
					JSPTranslatorPersister.movePersistedTranslation(resource, movePath);
					break;
				}
				case AbstractIndexManager.ACTION_REMOVE_MOVE_TO: {
					//do nothing, taken care of by AbstractIndexManager.ACTION_ADD_MOVE_FROM
					break;
				}
					

			}
		}

		private boolean isJobToAvoid(Job jobToCoordinate) {
			boolean result = false;
			if (jobToCoordinate.belongsTo(ResourcesPlugin.FAMILY_AUTO_BUILD) || jobToCoordinate.belongsTo(ResourcesPlugin.FAMILY_MANUAL_BUILD) || jobToCoordinate.belongsTo(ResourcesPlugin.FAMILY_AUTO_REFRESH)) {
				result = true;
			}
			return result;

		}
		
		//add any new JSP files to the JDT index using the JSPSearchSupport
		if(action == AbstractIndexManager.ACTION_ADD ||
				action == AbstractIndexManager.ACTION_ADD_MOVE_FROM) {
		
			IFile file = (IFile)resource; //this assumption can be made because of #isResourceToIndex
			JSPSearchSupport ss = JSPSearchSupport.getInstance();
			try {
				IProject project = file.getProject();
				if (project != null) {
					IJavaProject jproject = JavaCore.create(project);
					if (jproject.exists()) {
						ss.addJspFile(file);

			// ignore resource changes if already rebuilding
			if (getIndexState() == S_REBUILDING)
				return;
			// previously canceled, needs entire index rebuild
			if (getIndexState() == S_CANCELED) {
				// rebuildIndex();
				// just resume indexing
				getProcessFilesJob().schedule(500);
				//System.out.println("schedule: resource changed, previously canceled");
				return;
			}

			IResourceDelta delta = event.getDelta();
			if (delta != null) {
				// only care about adds or changes right now...
				int kind = delta.getKind();
				boolean added = (kind & IResourceDelta.ADDED) == IResourceDelta.ADDED;
				boolean changed = (kind & IResourceDelta.CHANGED) == IResourceDelta.CHANGED;
				if (added || changed) {

					// only analyze the full (starting at root) delta
					// hierarchy
					if (delta.getFullPath().toString().equals("/")) { //$NON-NLS-1$
						try {
							JSPResourceVisitor v = getVisitor();
							// clear from last run
							v.reset();
							// count files, possibly do this in a job too...
							// don't include PHANTOM resources
							delta.accept(v, false);

							// process files from this delta
							IFile[] files = v.getFiles();
							if (files.length > 0) {
								/*
								 * Job change listener should set back to
								 * stable when finished
								 */
								setUpdatingState();
								// processFiles(files);
								indexFiles(files);
							}
						}
						catch (CoreException e) {
							// need to set state here somehow, and reindex
							// otherwise index will be unreliable
							if (DEBUG)
								Logger.logException(e);
						}
						catch (Exception e) {
							// need to set state here somehow, and reindex
							// otherwise index will be unreliable
							if (DEBUG)
								Logger.logException(e);
						}
					}
				}
			}
			catch (Exception e) {
				String filename = file != null ? file.getFullPath().toString() : ""; //$NON-NLS-1$
				Logger.logException("JPSIndexManger: problem indexing:" + filename, e); //$NON-NLS-1$
			}
		}

	}

	IndexWorkspaceJob getIndexingJob() {
		return indexingJob;
	}

	ProcessFilesJob getProcessFilesJob() {
		return processFilesJob;
	}

	boolean isInitializing() {
		return initializing;
	}

}

Lines 315-324 Link Here

(-)src/org/eclipse/jst/jsp/core/internal/java/search/JSPSearchSupport.java (-7 / +68 lines)
315	* @param requestor	315	* @param requestor
316	* passed in to accept search matches (and do "something" with	316	* passed in to accept search matches (and do "something" with
317	* them)	317	* them)
		318	*
		319	* @deprecated use {@link #search(String, IJavaSearchScope, int, int, int, boolean, SearchRequestor, IProgressMonitor)}
318	*/	320	*/
319	public void search(String searchText, IJavaSearchScope scope, int searchFor, int limitTo, int matchMode, boolean isCaseSensitive, SearchRequestor requestor) {	321	public void search(String searchText, IJavaSearchScope scope, int searchFor, int limitTo, int matchMode, boolean isCaseSensitive, SearchRequestor requestor) {
		322	this.search(searchText, scope, searchFor, limitTo, matchMode, isCaseSensitive,
		323	requestor, new NullProgressMonitor());
		324	}
320		325
321	JSPIndexManager.getInstance().rebuildIndexIfNeeded();	326	/**
		327	* Search for an IJavaElement, constrained by the given parameters. Runs in
		328	* a background Job (results may still come in after this method call)
		329	*
		330	* @param element
		331	* @param scope
		332	* @param requestor
		333	*
		334	* @deprecated use {@link #search(IJavaElement, IJavaSearchScope, SearchRequestor, IProgressMonitor)}
		335	*/
		336	public void search(IJavaElement element, IJavaSearchScope scope, SearchRequestor requestor) {
		337	this.search(element, scope, requestor, new NullProgressMonitor());
		338	}
		339
		340	/**
		341	* Search for an IJavaElement, constrained by the given parameters. Runs in
		342	* an IWorkspace runnable (results will be reported by the end of this
		343	* method)
		344	*
		345	* @param element
		346	* @param scope
		347	* @param requestor
		348	*/
		349	public void searchRunnable(IJavaElement element, IJavaSearchScope scope, SearchRequestor requestor) {
		350	this.searchRunnable(element, scope, requestor, new NullProgressMonitor());
		351	}
		352
		353	/**
		354	* Perform a java search w/ the given parameters. Runs in a background Job
		355	* (results may still come in after this method call)
		356	*
		357	* @param searchText
		358	* the string of text to search on
		359	* @param searchFor
		360	* IJavaSearchConstants.TYPE, METHOD, FIELD, PACKAGE, etc...
		361	* @param limitTo
		362	* IJavaSearchConstants.DECLARATIONS,
		363	* IJavaSearchConstants.REFERENCES,
		364	* IJavaSearchConstants.IMPLEMENTORS, or
		365	* IJavaSearchConstants.ALL_OCCURRENCES
		366	* @param matchMode
		367	* allow * wildcards or not
		368	* @param isCaseSensitive
		369	* @param requestor
		370	* passed in to accept search matches (and do "something" with
		371	* them)
		372	*/
		373	public void search(String searchText, IJavaSearchScope scope, int searchFor, int
		374	limitTo, int matchMode, boolean isCaseSensitive, SearchRequestor requestor,
		375	IProgressMonitor monitor) {
		376
		377	//wait for the index
		378	JSPIndexManager.getDefault().waitForConsistant(monitor);
322		379
323	SearchJob job = new SearchJob(searchText, scope, searchFor, limitTo, matchMode, isCaseSensitive, requestor);	380	SearchJob job = new SearchJob(searchText, scope, searchFor, limitTo, matchMode, isCaseSensitive, requestor);
324	setCanceled(false);	381	setCanceled(false);
Lines 338-347 Link Here
338	* @param scope	395	* @param scope
339	* @param requestor	396	* @param requestor
340	*/	397	*/
341	public void search(IJavaElement element, IJavaSearchScope scope, SearchRequestor requestor) {	398	public void search(IJavaElement element, IJavaSearchScope scope, SearchRequestor requestor,
342		399	IProgressMonitor monitor) {
343	JSPIndexManager.getInstance().rebuildIndexIfNeeded();
344		400
		401	//wait for the index
		402	JSPIndexManager.getDefault().waitForConsistant(monitor);
		403
345	SearchJob job = new SearchJob(element, scope, requestor);	404	SearchJob job = new SearchJob(element, scope, requestor);
346	setCanceled(false);	405	setCanceled(false);
347	job.setUser(true);	406	job.setUser(true);
Lines 359-367 Link Here
359	* @param scope	418	* @param scope
360	* @param requestor	419	* @param requestor
361	*/	420	*/
362	public void searchRunnable(IJavaElement element, IJavaSearchScope scope, SearchRequestor requestor) {	421	public void searchRunnable(IJavaElement element, IJavaSearchScope scope,
363		422	SearchRequestor requestor, IProgressMonitor monitor) {
364	JSPIndexManager.getInstance().rebuildIndexIfNeeded();	423
		424	//wait for the index
		425	JSPIndexManager.getDefault().waitForConsistant(monitor);
365		426
366	SearchRunnable searchRunnable = new SearchRunnable(element, scope, requestor);	427	SearchRunnable searchRunnable = new SearchRunnable(element, scope, requestor);
367	try {	428	try {

Lines 59-65 Link Here

(-)src/org/eclipse/jst/jsp/ui/internal/java/search/ui/JSPQueryParticipant.java (-2 / +3 lines)
59	SearchRequestor jspRequestor = new JSPSearchRequestor(requestor);	59	SearchRequestor jspRequestor = new JSPSearchRequestor(requestor);
60		60
61	// pa_TODO need to adapt JavaSearchScope to a JSPSearchScope	61	// pa_TODO need to adapt JavaSearchScope to a JSPSearchScope
62	JSPSearchSupport.getInstance().search(element, new JSPSearchScope(), jspRequestor);	62	JSPSearchSupport.getInstance().search(element, new JSPSearchScope(), jspRequestor, monitor);
63		63
64	}	64	}
65	else if(querySpecification instanceof PatternQuerySpecification) {	65	else if(querySpecification instanceof PatternQuerySpecification) {
Lines 79-85 Link Here
79	patternQuery.getLimitTo(),	79	patternQuery.getLimitTo(),
80	SearchPattern.R_PATTERN_MATCH,	80	SearchPattern.R_PATTERN_MATCH,
81	false,	81	false,
82	jspRequestor);	82	jspRequestor,
		83	monitor);
83	}	84	}
84	}	85	}
85	}	86	}

Lines 7-12 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
7	Bundle-Vendor: %providerName	7	Bundle-Vendor: %providerName
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Export-Package: org.eclipse.wst.sse.core,	9	Export-Package: org.eclipse.wst.sse.core,
		10	org.eclipse.wst.sse.core.indexing,
10	org.eclipse.wst.sse.core.internal;x-friends:="org.eclipse.wst.dtd.core,org.eclipse.wst.dtd.ui,org.eclipse.wst.sse.ui,org.eclipse.wst.xml.core,org.eclipse.wst.xml.ui,org.eclipse.wst.xsd.core,org.eclipse.wst.xsd.ui",	11	org.eclipse.wst.sse.core.internal;x-friends:="org.eclipse.wst.dtd.core,org.eclipse.wst.dtd.ui,org.eclipse.wst.sse.ui,org.eclipse.wst.xml.core,org.eclipse.wst.xml.ui,org.eclipse.wst.xsd.core,org.eclipse.wst.xsd.ui",
11	org.eclipse.wst.sse.core.internal.cleanup;x-friends:="org.eclipse.wst.dtd.core,org.eclipse.wst.dtd.ui,org.eclipse.wst.sse.ui,org.eclipse.wst.xml.core,org.eclipse.wst.xml.ui,org.eclipse.wst.xsd.core,org.eclipse.wst.xsd.ui",	12	org.eclipse.wst.sse.core.internal.cleanup;x-friends:="org.eclipse.wst.dtd.core,org.eclipse.wst.dtd.ui,org.eclipse.wst.sse.ui,org.eclipse.wst.xml.core,org.eclipse.wst.xml.ui,org.eclipse.wst.xsd.core,org.eclipse.wst.xsd.ui",
12	org.eclipse.wst.sse.core.internal.document;x-friends:="org.eclipse.wst.dtd.core,org.eclipse.wst.dtd.ui,org.eclipse.wst.sse.ui,org.eclipse.wst.xml.core,org.eclipse.wst.xml.ui,org.eclipse.wst.xsd.core,org.eclipse.wst.xsd.ui",	13	org.eclipse.wst.sse.core.internal.document;x-friends:="org.eclipse.wst.dtd.core,org.eclipse.wst.dtd.ui,org.eclipse.wst.sse.ui,org.eclipse.wst.xml.core,org.eclipse.wst.xml.ui,org.eclipse.wst.xsd.core,org.eclipse.wst.xsd.ui",




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     
 *******************************************************************************/
package org.eclipse.wst.sse.core.indexing;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IResourceDeltaVisitor;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.ISaveParticipant;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.sse.core.internal.Logger;
import org.eclipse.wst.sse.core.internal.SSECoreMessages;

/**
 * <p>Provides a generic for writing a resource index manager.  It is important
 * to note that this only provides the framework for managing an index, not actually
 * indexing.  The subtle difference is that the manager is in charge of paying attention
 * to all of the resource actions that take place in the workspace and filtering those
 * actions down to simple actions that need to be performed on whatever index this manger
 * is managing.</p>
 * 
 * <p>The manger does its very best to make sure the index is always consistent, even if
 * resource events take place when the manager is not running.  In the event that the
 * manager determines it has missed, loosed, or corrupted any resource change events
 * that have occurred before, during, or after its activation or de-activation then the
 * manager will inspect the entire workspace to insure the index it is managing is
 * Consistent.</p>
 *  
 */
public abstract class AbstractIndexManager {
	
	/** Default time to wait for other tasks to finish */
	private static final int WAIT_TIME = 300;
	
	/**
	 * <p>Used to report progress on jobs where the total work to complete is unknown.
	 * The created effect is a progress bar that moves but that will never complete.</p>
	 */
	private static final int UNKNOWN_WORK = 100;
	
	/** The amount of events to batch up before sending them off to the processing job*/
	private static final int BATCH_UP_AMONT = 100;
	
	/** If this file exists then a full workspace re-processing is needed */ 
	private static final String RE_PROCESS_FILE_NAME = ".re-process"; //$NON-NLS-1$
	
	/** Common error message to log */
	private static final String LOG_ERROR_INDEX_INVALID =
		"Index may become invalid, incomplete, or enter some other inconsistent state."; //$NON-NLS-1$
	
	/** State: manager is stopped */
	private static final byte STATE_DISABLED = 0;
	
	/** State: manager is running */
	private static final byte STATE_ENABLED = 1;
	
	/** Action: add to index */
	protected static final byte ACTION_ADD = 0;
	
	/** Action: remove from index */
	protected static final byte ACTION_REMOVE = 1;
	
	/** Action: add to index caused by move operation */
	protected static final byte ACTION_ADD_MOVE_FROM = 2;
	
	/** Action: remove from index caused by move operation */
	protected static final byte ACTION_REMOVE_MOVE_TO = 3;
	
	/** Source: action originated from resource change event */
	protected static final byte SOURCE_RESROUCE_CHANGE = 0;
	
	/** Source: action originated from workspace scan */
	protected static final byte SOURCE_WORKSPACE_SCAN = 1;
	
	/** Source: action originated from saved state */
	protected static final byte SOURCE_SAVED_STATE = 2;
	
	/** Source: preserved resources to index */
	protected static final byte SOURCE_PRESERVED_RESOURCES_TO_INDEX = 3;
	
	/** the name of this index manager */
	protected String fName;
	
	/** {@link IResourceChangeListener} to listen for file changes */
	private ResourceChangeListener fResourceChangeListener;
	
	/** The {@link Job} that does all of the indexing */
	private ResourceEventProcessingJob fResourceEventProcessingJob;
	
	/** A {@link Job} to search the workspace for all files */
	private Job fWorkspaceVisitorJob;
	
	/**
	 * <p>Current state of the manager</p>
	 * 
	 * @see #STATE_DISABLED
	 * @see #STATE_ENABLED
	 */
	private volatile byte fState;
	
	/** used to prevent manager from starting and stopping at the same time */
	private Object fStartStopLock = new Object();
	
	/** <code>true</code> if the manger is currently starting, <code>false</code> otherwise */
	private boolean fStarting;

	/**
	 * <p>Creates the manager with a given name.</p>
	 * 
	 * @param name This will be pre-pended to progress reporting messages and thus should
	 * be translated
	 */
	protected AbstractIndexManager(String name) {
		this.fName = name;
		this.fState = STATE_DISABLED;
		this.fResourceChangeListener = new ResourceChangeListener();
		this.fResourceEventProcessingJob = new ResourceEventProcessingJob();
		this.fStarting = false;
	}
	
	/**
	 * <p>Starts up the {@link AbstractIndexManager}.  If a {@link IResourceDelta}
	 * is provided then it is assumed that all other files in the workspace
	 * have already been index and thus only those in the provided
	 * {@link IResourceDelta} will be processed.  Else if the provided
	 * {@link IResourceDelta} is <code>null</code> it is assumed no files
	 * have been indexed yet so the entire workspace will be searched for
	 * files to be indexed.</p>
	 * 
	 * <p>If {@link IResourceDelta} is provided this will block until that delta
	 * has finished processing.  If no {@link IResourceDelta} provided then a
	 * separate job will be created to process the entire workspace and this method
	 * will return without waiting for that job to complete</p>
	 * 
	 * <p>Will block until {@link #stop()} has finished running if it is
	 * currently running</p>
	 * 
	 * @param savedStateDelta the delta from a saved state, if <code>null</code>
	 * then the entire workspace will be searched for files to index, else
	 * only files in this {@link IResourceDelta} will be indexed
	 * @param monitor This action can not be canceled but this monitor will be used
	 * to report progress
	 */
	public final void start(IResourceDelta savedStateDelta, IProgressMonitor monitor) {
		SubMonitor progress = SubMonitor.convert(monitor);
		synchronized (this.fStartStopLock) {
			this.fStarting = true;
			
			if(this.fState == STATE_DISABLED) {
				//report status
				progress.beginTask(this.fName + ": " + SSECoreMessages.IndexManager_starting, //$NON-NLS-1$
						2);
				
				//start listening for resource change events
				this.fResourceChangeListener.start();
				
				//check to see if a full re-index is required
				boolean forcedFullReIndexNeeded = this.isForcedFullReIndexNeeded();
				
				/* start the indexing job only loading preserved state if not doing full index
				 * if failed loading preserved state then force full re-index
				 */
				forcedFullReIndexNeeded = !this.fResourceEventProcessingJob.start(!forcedFullReIndexNeeded,
						progress.newChild(1));
				progress.setWorkRemaining(1);
				
				//don't bother processing saved delta if forced full re-index is needed
				boolean stillNeedFullReIndex = forcedFullReIndexNeeded;
				if(!forcedFullReIndexNeeded) {
					//if there is a delta attempt to process it
					if(savedStateDelta != null) {
						stillNeedFullReIndex = false;
						try {
							//deal with reporting progress
							SubMonitor savedStateProgress = progress.newChild(1, SubMonitor.SUPPRESS_NONE);
							savedStateProgress.setTaskName(
									this.fName + ": " + SSECoreMessages.IndexManager_starting + ": " + //$NON-NLS-1$ //$NON-NLS-2$
										SSECoreMessages.IndexManager_processing_deferred_resource_changes);
							
							//process delta
							ResourceDeltaVisitor visitor = new ResourceDeltaVisitor(savedStateProgress,
									AbstractIndexManager.SOURCE_SAVED_STATE);
							savedStateDelta.accept(visitor);
							
							//process any remaining batched up resources to index
							visitor.processBatchedResourceEvents();
						} catch (CoreException e) {
							stillNeedFullReIndex = true;
							Logger.logException(this.fName + ": Could not process saved state. " + //$NON-NLS-1$
									"Forced to do a full workspace re-index.", e); //$NON-NLS-1$
						}
					}
				}
				progress.worked(1);
				
				//if need to process the entire workspace do so in another job
				if(stillNeedFullReIndex){
					this.fWorkspaceVisitorJob = new WorkspaceVisitorJob();
					this.fWorkspaceVisitorJob.schedule();
				}
				
				//update state
				this.fState = STATE_ENABLED;
			}
			this.fStarting = false;
		}
	}
	
	/**
	 * <p>Safely shuts down the manager.</p>
	 * 
	 * <p>This will block until the {@link #start(IResourceDelta, IProgressMonitor)} has
	 * finished (if running).  Also until the current resource event has finished being
	 * processed.  Finally it will block until the events still to be processed by
	 * the processing job have been preserved to be processed on the next call to
	 * {@link #start(IResourceDelta, IProgressMonitor)}.</p>
	 * 
	 * <p>If at any point during this shut down processes something goes wrong the
	 * manager will be sure that on the next call to {@link #start(IResourceDelta, IProgressMonitor)}
	 * the entire workspace will be re-processed.</p>
	 * 
	 * @throws InterruptedException
	 */
	public final void stop() throws InterruptedException {
		synchronized (this.fStartStopLock) {
			if(this.fState != STATE_DISABLED) {
				
				//stop listening for events, and wait for the current event to finish
				this.fResourceChangeListener.stop();
				
				// if currently visiting entire workspace, give up and try again next load
				boolean forceFullReIndexNextStart = false;
				if(this.fWorkspaceVisitorJob != null) {
					if (this.fWorkspaceVisitorJob.getState() != Job.NONE) {
						this.fWorkspaceVisitorJob.cancel();
						
						this.forceFullReIndexNextStart();
						forceFullReIndexNextStart = true;
					}
				}
				
				//stop the indexing job, only preserve if not already forcing a re-index
				forceFullReIndexNextStart = !this.fResourceEventProcessingJob.stop(!forceFullReIndexNextStart);
				
				//if preserving failed, then force re-index
				if(forceFullReIndexNextStart) {
					this.forceFullReIndexNextStart();
				}
				
				//update status
				this.fState = STATE_DISABLED;
			}
		}
	}
	
	/**
	 * <p>Should be called by an client of the index this manger manages before the index
	 * is accessed, assuming the client wants an index consistent with the latest
	 * resource changes.</p>
	 * 
	 * <p>The supplied monitor will be used to supply user readable progress as the manager
	 * insures the index has been given all the latest resource events.  This monitor
	 * maybe canceled, but if it is the state of the index is not guaranteed to be
	 * consistent with the latest resource change events.</p>
	 * 
	 * @param monitor Used to report user readable progress as the manager insures the
	 * index is consistent with the latest resource events.  This monitor can be canceled
	 * to stop waiting for consistency but then no guaranty is made about the consistency
	 * of the index in relation to un-processed resource changes
	 * 
	 * @return <code>true</code> if the wait finished successfully and the manger is consistent,
	 * <code>false</code> otherwise, either an error occurred while waiting for the manager
	 * or the monitor was canceled
	 * 
	 * @throws InterruptedException This can happen when waiting for other jobs
	 */
	public final boolean waitForConsistant(IProgressMonitor monitor) {
		boolean success = true;
		boolean interupted = false;
		SubMonitor progress = SubMonitor.convert(monitor);
		
		//set up the progress of waiting
		int remainingWork = 4;
		progress.beginTask(NLS.bind(SSECoreMessages.IndexManager_Waiting_for_0, this.fName),
				remainingWork);
		
		//wait for start up
		if(this.fStarting && !monitor.isCanceled()) {
			SubMonitor startingProgress = progress.newChild(1);
			startingProgress.subTask(SSECoreMessages.IndexManager_starting);
			while(this.fStarting && !monitor.isCanceled()) {
				//this creates a never ending progress that still moves forward
				startingProgress.setWorkRemaining(UNKNOWN_WORK);
				startingProgress.newChild(1).worked(1);
				try {
					Thread.sleep(WAIT_TIME);
				} catch (InterruptedException e) {
					interupted = true;
				}
			}
		}
		progress.setWorkRemaining(--remainingWork);
		
		//wait for workspace visiting job
		if(this.fWorkspaceVisitorJob != null && this.fWorkspaceVisitorJob.getState() != Job.NONE && !monitor.isCanceled()) {
			SubMonitor workspaceVisitorProgress = progress.newChild(1);
			workspaceVisitorProgress.subTask(SSECoreMessages.IndexManager_Processing_entire_workspace_for_the_first_time);
			while(this.fWorkspaceVisitorJob.getState() != Job.NONE && !monitor.isCanceled()) {
				//this creates a never ending progress that still moves forward
				workspaceVisitorProgress.setWorkRemaining(UNKNOWN_WORK);
				workspaceVisitorProgress.newChild(1).worked(1);
				try {
					Thread.sleep(WAIT_TIME);
				} catch (InterruptedException e) {
					interupted = true;
				}
			}
		}
		progress.setWorkRemaining(--remainingWork);
		
		//wait for the current resource event
		if(this.fResourceChangeListener.isProcessingEvents() && !monitor.isCanceled()) {
			SubMonitor workspaceVisitorProgress = progress.newChild(1);
			workspaceVisitorProgress.subTask(SSECoreMessages.IndexManager_processing_recent_resource_changes);
			while(this.fResourceChangeListener.isProcessingEvents() && !monitor.isCanceled()) {
				workspaceVisitorProgress.setWorkRemaining(UNKNOWN_WORK);
				workspaceVisitorProgress.newChild(1).worked(1);
				try {
					this.fResourceChangeListener.waitForCurrentEvent(WAIT_TIME);
				} catch (InterruptedException e) {
					interupted = true;
				}
			}
		}
		progress.setWorkRemaining(--remainingWork);
		
		//wait for all files to be indexed
		if(this.fResourceEventProcessingJob.getNumResourceEventsToProcess() != 0 && !monitor.isCanceled()) {
			SubMonitor indexingProgress = progress.newChild(1);
			int prevNumResrouces;
			int numResources = this.fResourceEventProcessingJob.getNumResourceEventsToProcess();
			while(numResources != 0 && !monitor.isCanceled()) {
				//update the progress indicator
				indexingProgress.subTask(AbstractIndexManager.this.fName + ": " + //$NON-NLS-1$
						NLS.bind(SSECoreMessages.IndexManager_Indexing_0_Files,
								"" + numResources)); //$NON-NLS-1$
				indexingProgress.setWorkRemaining(numResources);
				prevNumResrouces = numResources;
				numResources = this.fResourceEventProcessingJob.getNumResourceEventsToProcess();
				int numProcessed = prevNumResrouces - numResources;
				indexingProgress.worked(numProcessed > 0 ? numProcessed : 0);
				
				//give the index some time to do some indexing
				try {
					this.fResourceEventProcessingJob.waitForConsistant(WAIT_TIME);
				} catch (InterruptedException e) {
					interupted = true;
				}
			}
		}
		progress.setWorkRemaining(--remainingWork);
		
		if(monitor.isCanceled()) {
			success = false;
		}
		
		//reset the interrupted flag if we were interrupted
		if(interupted) {
			Thread.currentThread().interrupt();
		}
		
		return success;
	}
	
	/**
	 * <p>Used to determine if an {@link IResource} with the given
	 * type and name should be processed by this index manager</p>
	 * 
	 * @param type see {@link IResource#getType()}
	 * @param name the name of the resource
	 * 
	 * @return <code>true</code> if this index manager processes resources
	 * of the given <code>type</code> with the given <code>name</code>,
	 * <code>false</code> otherwise
	 */
	protected abstract boolean isResourceToIndex(int type, String name);
	
	/**
	 * <p>Called for each {@link ResourceEvent} gathered by the various sources and processed
	 * by the {@link ResourceEventProcessingJob}.  The implementation of this method
	 * should use the given information to update the index this manger is managing.</p>
	 * 
	 * @param source The source that reported this resource event
	 * @param action The action to be taken on the given <code>resource</code>
	 * @param resource The index should perform the given <code>action</code> on this
	 * resource
	 * @param movePath If the given <code>action</code> is {@link AbstractIndexManager#ACTION_ADD_MOVE_FROM}
	 * or {@link AbstractIndexManager#ACTION_REMOVE_MOVE_TO} then this field will not be
	 * null and reports the path the given <code>resource</code> was either moved from or
	 * moved to respectively.
	 * 
	 * @see AbstractIndexManager#SOURCE_RESROUCE_CHANGE
	 * @see AbstractIndexManager#SOURCE_SAVED_STATE
	 * @see AbstractIndexManager#SOURCE_WORKSPACE_SCAN
	 * @see AbstractIndexManager#SOURCE_PRESERVED_RESOURCES_TO_INDEX
	 * 
	 * @see AbstractIndexManager#ACTION_ADD
	 * @see AbstractIndexManager#ACTION_REMOVE
	 * @see AbstractIndexManager#ACTION_ADD_MOVE_FROM
	 * @see AbstractIndexManager#ACTION_REMOVE_MOVE_TO
	 */
	protected abstract void performAction(byte source, byte action, IResource resource,
			IPath movePath);
	
	/**
	 * <p>Gets the working location of the manager. This is where any relevant
	 * state can be persisted.</p>
	 * 
	 * @return the working location of the manager
	 */
    protected abstract IPath getWorkingLocation();
	
	/**
	 * <p>Determines if a resource should be visited or not while
	 * looking for files to index.  If a resource should not be
	 * visited it is assumed its children should not be visited either.</p>
	 * 
	 * <p>Implementers may override. Default is to ignore resources
	 * starting with a period.</p>
	 * 
	 * @param resourceName name of the resource to determine if it
	 * should be visited or not
	 * 
	 * @return <code>true</code> if the resource should be visited,
	 * <code>false</code> otherwise
	 */
	protected boolean shouldVisit(String resourceName) {
		return !resourceName.startsWith(".");//$NON-NLS-1$
	}
	
	/**
	 * <p>Next time the manager starts up force a full workspace index</p>
	 */
	private void forceFullReIndexNextStart() {
		IPath reIndexPath =
			AbstractIndexManager.this.getWorkingLocation().append(RE_PROCESS_FILE_NAME);
		File file = new File(reIndexPath.toOSString());
		try {
			file.createNewFile();
		} catch (IOException e) {
			Logger.logException(this.fName + ": Could not create file to tell manager to" + //$NON-NLS-1$
					" do a full re-index on next load. " + //$NON-NLS-1$
					AbstractIndexManager.LOG_ERROR_INDEX_INVALID, e);
		}
	}
	
	/**
	 * @return <code>true</code> if a full workspace index is needed as dictated by
	 * a previous call to {@link #forceFullReIndexNextStart()}, <code>false</code>
	 * otherwise
	 */
	private boolean isForcedFullReIndexNeeded() {
		boolean forcedFullReIndexNeeded = false;
		IPath reIndexPath =
			AbstractIndexManager.this.getWorkingLocation().append(RE_PROCESS_FILE_NAME);
		File file = new File(reIndexPath.toOSString());
		if(file.exists()) {
			file.delete();
			forcedFullReIndexNeeded = true;
		}
		
		return forcedFullReIndexNeeded;
	}
	
	/**
	 * <p>A system {@link Job} used to visit all of the files in the workspace
	 * looking for files to index.</p>
	 * 
	 * <p>This should only have to be done once per workspace on the first load,
	 * but if it fails or a SavedState can not be retrieved on a subsequent
	 * workspace load then this will have to be done again.</p>
	 */
	private class WorkspaceVisitorJob extends Job {
		/**
		 * <p>Default constructor that sets up this job as a system job</p>
		 */
		protected WorkspaceVisitorJob() {
			super(AbstractIndexManager.this.fName + ": " + //$NON-NLS-1$
					SSECoreMessages.IndexManager_Processing_entire_workspace_for_the_first_time);
			
			this.setUser(false);
			this.setSystem(true);
			this.setPriority(Job.LONG);
		}
		
		/**
		 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		 */
		protected IStatus run(IProgressMonitor monitor) {
			try {
				//update status
				monitor.beginTask(AbstractIndexManager.this.fName + ": " + //$NON-NLS-1$
						SSECoreMessages.IndexManager_Processing_entire_workspace_for_the_first_time,
						IProgressMonitor.UNKNOWN);
				
				//visit the workspace
				WorkspaceVisitor visitor = new WorkspaceVisitor(monitor);
				ResourcesPlugin.getWorkspace().getRoot().accept(visitor, IResource.NONE);
				
				//process any remaining batched up resources to index
				visitor.processBatchedResourceEvents();
			} catch(CoreException e) {
				Logger.logException(AbstractIndexManager.this.fName +
						": Failed visiting entire workspace for initial index. " + //$NON-NLS-1$
						AbstractIndexManager.LOG_ERROR_INDEX_INVALID, e);
			}
			
			IStatus status;
			if(monitor.isCanceled()) {
				status = Status.CANCEL_STATUS;
			} else {
				status = Status.OK_STATUS;
			}
			
			return status;
		}
		
		/**
		 * <p>An {@link IResourceProxyVisitor} used to visit all of the files in the
		 * workspace looking for files to add to the index.</p>
		 * 
		 * <p><b>NOTE: </b>After this visitor is used {@link WorkspaceVisitor#processBatchedResourceEvents()
		 * must be called to flush out the last of the {@link ResourceEvent}s produced
		 * by this visitor.</p>
		 */
		private class WorkspaceVisitor implements IResourceProxyVisitor {
			/** {@link IProgressMonitor} used to report status and check for cancellation */
			private SubMonitor fProgress;
			
			/**
			 * {@link Map}&lt{@link IResource}, {@link ResourceEvent}&gt
			 * <p>Map of resources events created and batched up by this visitor.
			 * These events are periodical be sent off to the
			 * {@link ResourceEventProcessingJob} but need to be sent off
			 * one final time after this visitor finishes it work.</p>
			 * 
			 * @see #processBatchedResourceEvents()
			 */
			private Map fBatchedResourceEvents;
			
			/**
			 * <p>Default constructor</p>
			 * @param monitor used to report status and allow this visitor to be canceled
			 */
			protected WorkspaceVisitor(IProgressMonitor monitor) {
				this.fProgress = SubMonitor.convert(monitor);
				this.fBatchedResourceEvents = new LinkedHashMap(BATCH_UP_AMONT);
			}

			/**
			 * <p>As long as the monitor is not canceled visit each file in the workspace
			 * that should be visited.</p>
			 * 
			 * @see org.eclipse.core.resources.IResourceProxyVisitor#visit(org.eclipse.core.resources.IResourceProxy)
			 * @see AbstractIndexManager#shouldVisit(String)
			 */
			public boolean visit(IResourceProxy proxy) throws CoreException {
				this.fProgress.subTask(proxy.getName());
				
				boolean visitChildren = false;
				
				/* if not canceled or a hidden resource then process file
				 * else don't visit children
				 */
				if(!this.fProgress.isCanceled() && shouldVisit(proxy.getName())) {
					if(isResourceToIndex(proxy.getType(), proxy.getName())) {
						
						//add the file to be indexed
						IFile file = (IFile) proxy.requestResource();
						if(file.exists()) {
							this.fBatchedResourceEvents.put(file, new ResourceEvent(
									AbstractIndexManager.SOURCE_WORKSPACE_SCAN,
									AbstractIndexManager.ACTION_ADD,
									null));
						}
					}
					
					visitChildren = true;
				} else {
					visitChildren = false;
				}
				
				//batch up resource changes before sending them out
				if(this.fBatchedResourceEvents.size() >= BATCH_UP_AMONT) {
					this.processBatchedResourceEvents();
				}
				
				return visitChildren;
			}
			
			/**
			 * <p>Sends any batched up resource events created by this visitor to the
			 * {@link ResourceEventProcessingJob}.<p>
			 * 
			 * <p><b>NOTE:</b> This will be called every so often as the visitor is
			 * visiting resources but needs to be called a final time by the user of
			 * this visitor to be sure the final events are sent off</p>
			 */
			protected void processBatchedResourceEvents() {
				AbstractIndexManager.this.fResourceEventProcessingJob.addResourceEvents(
						this.fBatchedResourceEvents);
				this.fBatchedResourceEvents.clear();
			}
		}
	}
	
	/**
	 * <p>Used to listen to resource change events in the workspace.  These events
	 * are batched up and then passed onto the {@link ResourceEventProcessingJob}.</p>
	 */
	private class ResourceChangeListener implements IResourceChangeListener {
		/**
		 * <p>The number of events currently being processed by this listener.</p>
		 * <p>Use the {@link #fEventsBeingProcessedLock} when reading or writing this field</p>
		 * 
		 * @see #fEventsBeingProcessedLock
		 */
		private volatile int fEventsBeingProcessed;
		
		/**
		 * Lock to use when reading or writing {@link #fEventsBeingProcessed}
		 * 
		 * @see #fEventsBeingProcessed
		 */
		private final Object fEventsBeingProcessedLock = new Object();
		
		/**
		 * <p>Current state of this listener</p>
		 * 
		 * @see AbstractIndexManager#STATE_DISABLED
		 * @see AbstractIndexManager#STATE_ENABLED
		 */
		private volatile byte fState;
		
		/**
		 * <p>Default constructor</p>
		 */
		protected ResourceChangeListener() {
			this.fState = STATE_DISABLED;
			this.fEventsBeingProcessed = 0;
		}
		
		/**
		 * <p>Start listening for resource change events</p>
		 */
		protected void start() {
			this.fState = STATE_ENABLED;
			ResourcesPlugin.getWorkspace().addResourceChangeListener(this);
		}
		
		/**
		 * <p>Stop listening for resource change events and if already processing
		 * an event then wait for that processing to finish</p>
		 * 
		 * @throws InterruptedException waiting for a current event to finish processing
		 * could be interrupted
		 */
		protected void stop() throws InterruptedException {
			ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
			
			//wait indefinitely for current event to finish processing
			this.waitForCurrentEvent(0);
			
			this.fState = STATE_DISABLED;
		}
		
		/**
		 * <p>Blocks until either the current resource event has been processed or
		 * until the given timeout has passed.</p>
		 * 
		 * @param timeout block until either this timeout elapses (0 means never to timeout)
		 * or the current resource change event finishes being processed
		 * 
		 * @throws InterruptedException This can happen when waiting for a lock
		 */
		protected void waitForCurrentEvent(int timeout) throws InterruptedException {
			synchronized (this.fEventsBeingProcessedLock) {
				if(this.fEventsBeingProcessed != 0) {
					this.fEventsBeingProcessedLock.wait(timeout);
				}
			}
		}
		
		/**
		 * @return <code>true</code> if this listener is currently processing any
		 * events, <code>false</code> otherwise.
		 */
		protected boolean isProcessingEvents() {
			return this.fEventsBeingProcessed != 0;
		}
		
		/**
		 * <p>Process a resource change event.  If it is a pre-close or pre-delete then
		 * the {@link ResourceEventProcessingJob} is paused so it does not try to
		 * process resources that are about to be deleted.  The {@link ResourceDeltaVisitor}
		 * is used to actually process the event.</p>
		 * 
		 * @see org.eclipse.core.resources.IResourceChangeListener#resourceChanged(org.eclipse.core.resources.IResourceChangeEvent)
		 * @see ResourceDeltaVisitor
		 */
		public void resourceChanged(IResourceChangeEvent event) {
			try {
				//update the number of events being processed
				synchronized (this.fEventsBeingProcessedLock) {
					++this.fEventsBeingProcessed;
				}
				
				if(this.fState == STATE_ENABLED) {
					switch(event.getType()) {
						case IResourceChangeEvent.PRE_CLOSE:
						case IResourceChangeEvent.PRE_DELETE:{
							//pre-close or pre-delete pause the persister job so it does not interfere
							AbstractIndexManager.this.fResourceEventProcessingJob.pause();
							break;
						}
						case IResourceChangeEvent.POST_BUILD:
						case IResourceChangeEvent.POST_CHANGE: {
							//post change start up the indexer job and process the delta
							AbstractIndexManager.this.fResourceEventProcessingJob.unPause();
							
							// only analyze the full (starting at root) delta hierarchy
							IResourceDelta delta = event.getDelta();
							if (delta != null && delta.getFullPath().toString().equals("/")) { //$NON-NLS-1$
								try {
									//use visitor to visit all children
									ResourceDeltaVisitor visitor = new ResourceDeltaVisitor(
											AbstractIndexManager.SOURCE_RESROUCE_CHANGE);
									delta.accept(visitor, false);
									
									//process any remaining batched up resources to index
									visitor.processBatchedResourceEvents();
								} catch (CoreException e) {
									Logger.logException(AbstractIndexManager.this.fName +
											": Failed visiting resrouce change delta. " + //$NON-NLS-1$
											AbstractIndexManager.LOG_ERROR_INDEX_INVALID, e);
								}
							}
							break;
						}
					}
				} else {
					Logger.log(Logger.ERROR, "A resource change event came in after " +
							AbstractIndexManager.this.fName + " shut down. This should never " +
							"ever happen, but if it does the index may now be inconsistant.");
				}
			} finally {
				//no matter how we exit be sure to update the number of events being processed
				synchronized (this.fEventsBeingProcessedLock) {
					--this.fEventsBeingProcessed;
					
					//if currently not events being processed, then notify
					if(this.fEventsBeingProcessed == 0) {
						this.fEventsBeingProcessedLock.notifyAll();
					}
				}
			}
		}
	}
	
	/**
	 * <p>Used to visit {@link IResourceDelta}s from both the {@link IResourceChangeListener}
	 * and from a {@link ISaveParticipant} given to {@link AbstractIndexManager#start(IResourceDelta, IProgressMonitor)}.
	 * The resource events are batched into groups of {@link AbstractIndexManager#BATCH_UP_AMONT}
	 * before being passed onto the {@link ResourceEventProcessingJob}.</p>
	 * 
	 * <p><b>NOTE 1: </b> This class is intended for one time use, thus a new instance should
	 * be instantiated each time this visitor is needed to process a new {@link IResourceDelta}.</p>
	 * 
	 * <p><b>NOTE 2: </b> Be sure to call {@link ResourceDeltaVisitor#processBatchedResourceEvents()}
	 * after using this visitor to be sure any remaining events get passed onto the
	 * {@link ResourceEventProcessingJob}.</p>
	 * 
	 * @see ResourceDeltaVisitor#processBatchedResourceEvents()
	 */
	private class ResourceDeltaVisitor implements IResourceDeltaVisitor {
		/** {@link IProgressMonitor} used to report status */
		private SubMonitor fProgress;
		
		/**
		 * <p>The source that should be used when sending resource events to the
		 * {@link ResourceEventProcessingJob}.</p>
		 * 
		 * @see AbstractIndexManager#SOURCE_SAVED_STATE
		 * @see AbstractIndexManager#SOURCE_RESROUCE_CHANGE
		 */
		private byte fSource;
		
		/**
		 * <p>Due to the nature of a visitor it has no way of knowing the total amount
		 * of work it has to do but it can start to predict it based on the number of
		 * children of each event it processes and whether it plans on visiting those
		 * children</p>
		 */
		private int fPredictedWorkRemaining;
		
		/**
		 * {@link Map}&lt{@link IResource}, {@link ResourceEvent}&gt
		 * <p>Map of resources events created and batched up by this visitor.
		 * These events are periodical be sent off to the
		 * {@link ResourceEventProcessingJob} but need to be sent off
		 * one final time after this visitor finishes it work.</p>
		 * 
		 * @see #processBatchedResourceEvents()
		 */
		private Map fBatchedResourceEvents;
		
		/**
		 * <p>Creates a visitor that will create resource events based on the resources
		 * it visits and using the given source as the source of the events.</p>
		 * 
		 * @param source The source of the events that should be used when creating
		 * resource events from visited resources
		 * 
		 * @see AbstractIndexManager#SOURCE_RESROUCE_CHANGE
		 * @see AbstractIndexManager#SOURCE_SAVED_STATE
		 */
		protected ResourceDeltaVisitor(byte source) {
			this(SubMonitor.convert(null), source);
		}
		
		/**
		 * <p>Creates a visitor that will create resource events based on the resources
		 * it visits and using the given source as the source of the events and
		 * report its status to the given progress as best it can as it visits
		 * resources.</p>
		 * 
		 * <p><b>NOTE:</b> While the {@link SubMonitor} is provided to report status the
		 * visitor will not honor any cancellation requests.</p>
		 * 
		 * @param progress Used to report status. This visitor can <b>not</b> be
		 * canceled
		 * @param source The source of the events that should be used when creating
		 * resource events from visited resources
		 * 
		 * @see AbstractIndexManager#SOURCE_RESROUCE_CHANGE
		 * @see AbstractIndexManager#SOURCE_SAVED_STATE
		 */
		protected ResourceDeltaVisitor(SubMonitor progress, byte source) {
			this.fProgress = progress;
			this.fSource = source;
			this.fBatchedResourceEvents = new LinkedHashMap(BATCH_UP_AMONT);
			this.fPredictedWorkRemaining = 1;
		}
		
		/**
		 * <p>Transforms each {@link IResourceDelta} into a {@link ResourceEvent}.
		 * Batches up these {@link ResourceEvent}s and then passes them onto the
		 * {@link ResourceEventProcessingJob}.</p>
		 * 
		 * <p><b>NOTE 2: </b> Be sure to call {@link ResourceDeltaVisitor#processBatchedResourceEvents()}
		 * after using this visitor to be sure any remaining events get passed onto the
		 * {@link ResourceEventProcessingJob}.</p>
		 * 
		 * @see org.eclipse.core.resources.IResourceDeltaVisitor#visit(org.eclipse.core.resources.IResourceDelta)
		 * @see #processBatchedResourceEvents()
		 */
		public boolean visit(IResourceDelta delta) throws CoreException {
			//report status
			this.fProgress.subTask(
					NLS.bind(SSECoreMessages.IndexManager_0_resources_to_go, "" + fPredictedWorkRemaining) + //$NON-NLS-1$
					": " + delta.getFullPath().toString()); //$NON-NLS-1$
			
			//process delta if resource not hidden
			boolean visitChildren = false;
			IResource resource = delta.getResource();
			if(shouldVisit(resource.getName())) {
				//check if should index resource
				if(isResourceToIndex(resource.getType(), resource.getName())) {
				
					switch (delta.getKind()) {
						case IResourceDelta.CHANGED : {
							/* ignore any change that is not a CONTENT, REPLACED, TYPE,
							 * or MOVE_FROM change
							 */
							if( !((delta.getFlags() & IResourceDelta.CONTENT) != 0) &&
									!((delta.getFlags() & IResourceDelta.REPLACED) != 0) &&
									!((delta.getFlags() & IResourceDelta.TYPE) != 0) &&
									!(((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0))) {
								
								break;
							}
						}
						//$FALL-THROUGH$ it is intended that sometimes a change will fall through to add
						case IResourceDelta.ADDED : {
							if((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0) {
								//create add move from action
								this.fBatchedResourceEvents.put(resource, new ResourceEvent(
										this.fSource,
										AbstractIndexManager.ACTION_ADD_MOVE_FROM,
										delta.getMovedFromPath()));

							} else {
								//create add action
								this.fBatchedResourceEvents.put(resource, new ResourceEvent(
										this.fSource,
										AbstractIndexManager.ACTION_ADD,
										null));
							}
							
							break;
						}
						case IResourceDelta.REMOVED : {
							if((delta.getFlags() & IResourceDelta.MOVED_TO) != 0) {
								//create remove move to action
								this.fBatchedResourceEvents.put(resource, new ResourceEvent(
										this.fSource,
										AbstractIndexManager.ACTION_REMOVE_MOVE_TO,
										delta.getMovedToPath()));
							} else {
								//create remove action
								this.fBatchedResourceEvents.put(resource, new ResourceEvent(
										this.fSource,
										AbstractIndexManager.ACTION_REMOVE,
										null));
							}
							break;
						}
					}
				}
					
				visitChildren = true;
			} else {
				visitChildren = false;
			}
			
			//deal with trying to report progress
			if(visitChildren) {
				this.fPredictedWorkRemaining += delta.getAffectedChildren().length;
			}
			this.fProgress.setWorkRemaining(this.fPredictedWorkRemaining);
			this.fProgress.worked(1);
			--this.fPredictedWorkRemaining;
			
			//batch up resource changes before sending them out
			if(this.fBatchedResourceEvents.size() >= BATCH_UP_AMONT) {
				this.processBatchedResourceEvents();
			}
			
			return visitChildren;
		}
		
		/**
		 * <p>Sends any batched up resource events created by this visitor to the
		 * {@link ResourceEventProcessingJob}.<p>
		 * 
		 * <p><b>NOTE:</b> This will be called every so often as the visitor is
		 * visiting resources but needs to be called a final time by the user of
		 * this visitor to be sure the final events are sent off</p>
		 */
		protected void processBatchedResourceEvents() {
			AbstractIndexManager.this.fResourceEventProcessingJob.addResourceEvents(
					this.fBatchedResourceEvents);
			this.fBatchedResourceEvents.clear();
		}
	}
	
	/**
	 * <p>Collects {@link ResourceEvent}s from the different sources and then processes
	 * each one by calling {@link AbstractIndexManager#performAction(byte, byte, IResource, IPath)}
	 * for each {@link ResourceEvent}.</p>
	 * 
	 * @see AbstractIndexManager#performAction(byte, byte, IResource, IPath)
	 */
	private class ResourceEventProcessingJob extends Job {
		/** Length to delay when scheduling job */
		private static final int DELAY = 500;
		
		/**
		 * <p>Name of the file where resource events still to index
		 * will be preserved for the next start up.</p>
		 */
		private static final String PRESERVED_RESOURCE_EVENTS_TO_PROCESS_FILE_NAME = ".preservedResourceEvents";  //$NON-NLS-1$
		
		/**
		 * <p>This needs to be updated if {@link #preserveRecievedResourceEvents()} ever
		 * changes how it persists resource events so that {@link #loadPreservedRecievedResourceEvents(SubMonitor)}
		 * knows when opening a file that the format is of the current version and if not
		 * knows it does not know how to read the older version.</p>
		 * 
		 * @see #preserveRecievedResourceEvents()
		 * @see #loadPreservedRecievedResourceEvents(SubMonitor)
		 */
		private static final long serialVersionUID = 1L;
		
		/** Whether this job has been paused or not */
		private volatile boolean fIsPaused;
		
		/**
		 * {@link Map}&lt{@link IResource}, {@link ResourceEvent}&gt
		 * <p>The list of resources events to be processed</p>
		 */
		private Map fResourceEvents;
		
		/** Lock used when accessing {@link #fBatchedResourceEvents} */
		private final Object fResourceEventsLock = new Object();
		
		/**
		 * Locked used for allowing other jobs to wait on this job.  This job
		 * will notify those waiting on this lock whenever it is done processing
		 * all resource events it currently knows about.
		 * 
		 * @see #waitForConsistant(int)
		 */
		private final Object fToNotifyLock = new Object();
		
		/**
		 * <p>Sets up this job as a long running system job</p>
		 */
		protected ResourceEventProcessingJob() {
			super(AbstractIndexManager.this.fName + ": " + //$NON-NLS-1$
					SSECoreMessages.IndexManager_Processing_resource_events);
			
			//set this up as a long running system job
			this.setUser(false);
			this.setSystem(true);
			this.setPriority(Job.LONG);
			
			this.fIsPaused = false;
			this.fResourceEvents = new LinkedHashMap();
		}
		
		/**
		 * <p>Loads any preserved {@link ResourceEvent}s from the last time {@link #stop(boolean)}
		 * was invoked and schedules the job to be run</p>
		 * 
		 * <p><b>NOTE: </b>Should be used instead of of calling {@link Job#schedule()}
		 * because this method also takes care of loading preserved state.</p>
		 * 
		 * @param loadPreservedResourceEvents <code>true</code> if should load any
		 * preserved {@link ResourceEvent}s from the last time {@link #stop(boolean)}
		 * was invoked
		 * 
		 * @return <code>true</code> if either <code>loadPreservedResourceEvents</code>
		 * was false or there was success in loading the preserved {@link ResourceEvent}s.
		 * If <code>false</code> then some {@link ResourceEvent}s may have been loosed
		 * and to insure index consistency with the workspace a full workspace  re-index
		 * is needed.
		 * 
		 * @see #stop(boolean)
		 */
		protected synchronized boolean start(boolean loadPreservedResourceEvents, 
				SubMonitor progress) {
			
			boolean successLoadingPreserved = true;
			
			//attempt to load preserved resource events if requested
			if(!loadPreservedResourceEvents) {
				File preservedResourceEventsFile = this.getPreservedResourceEventsFile();
				preservedResourceEventsFile.delete();
			} else {
				successLoadingPreserved = this.loadPreservedRecievedResourceEvents(progress);
			}
			
			//start up the job
			this.schedule();
			
			return successLoadingPreserved;
		}
		
		/**
		 * <p>Immediately stops the job and preserves any {@link ResourceEvent}s in the queue
		 * to be processed by not yet processed if requested</p>
		 * 
		 * @param preserveResourceEvents <code>true</code> to preserve any {@link ResourceEvent}s
		 * in the queue yet to be processed, <code>false</code> otherwise
		 * 
		 * @return <code>true</code> if either <code>preserveResourceEvents</code> is 
		 * <code>false</code> or if there was success in preserving the {@link ResourceEvent}s
		 * yet to be processed.  If <code>false</code> then the preserving failed and a
		 * full workspace re-processing is needed the next time the manger is started
		 * 
		 * @throws InterruptedException This could happen when trying to cancel or join 
		 * the job in progress, but it really shouldn't
		 * 
		 * @see #start(boolean, SubMonitor)
		 */
		protected synchronized boolean stop(boolean preserveResourceEvents) throws InterruptedException {
			//this will not block indefinitely because it is known this job can be canceled
			this.cancel();
			this.join();
			
			//preserve if requested, else be sure no preserve file is left over for next start
			boolean success = true;
			if(preserveResourceEvents && this.hasResourceEventsToProcess()) {
				success = this.preserveRecievedResourceEvents();
			} else {
				this.getPreservedResourceEventsFile().delete();
			}
			
			return success;
		}
		
		/**
		 * @return <code>true</code> if job is currently running or paused
		 * 
		 * @see #pause()
		 * @see #unPause()
		 */
		protected synchronized boolean isProcessing() {
			return this.getState() != Job.NONE || this.fIsPaused;
		}
		
		/**
		 * <p>Un-pauses this job.  This has no effect if the job is already running.</p>
		 * <p>This should be used in place of {@link Job#schedule()} to reset state
		 * caused by calling {@link #pause()}</p>
		 * 
		 * @see #pause()
		 */
		protected synchronized void unPause() {
			this.fIsPaused = false;
			
			//get the job running again depending on its current state
			if(this.getState() == Job.SLEEPING) {
				this.wakeUp(DELAY);
			} else {
				this.schedule(DELAY);
			}
		}
		
		/**
		 * <p>Pauses this job, even if it is running</p>
		 * <p>This should be used in place of {@link Job#sleep()} because {@link Job#sleep()}
		 * will not pause a job that is already running but calling this will pause this job
		 * even if it is running. {@link #unPause()} must be used to start this job again</p>
		 * 
		 * @see #unPause()
		 */
		protected synchronized void pause() {
			//if job is already running this will force it to pause
			this.fIsPaused = true;
			
			//this only works if the job is not running
			this.sleep();
		}
		
		/**
		 * <p>Adds a batch of {@link ResourceEvent}s to the queue of events to be processed.
		 * Will also un-pause the job if it is not already running</p>
		 * 
		 * @param resourceEvents {@link Map}&lt{@link IResource}, {@link ResourceEvent}&gt
		 * A batch of {@link ResourceEvent}s to be processed
		 * 
		 * @see #addResourceEvent(ResourceEvent)
		 * @see #unPause()
		 */
		protected void addResourceEvents(Map resourceEvents) {
			Iterator iter = resourceEvents.keySet().iterator();
			while(iter.hasNext()) {
				IResource resource = (IResource)iter.next();
				ResourceEvent resourceEvent = (ResourceEvent)resourceEvents.get(resource);
				addResourceEvent(resource, resourceEvent);
			}
			
			//un-pause the processor if it is not already running
			if(!isProcessing()) {
				this.unPause();
			}
		}
		
		/**
		 * <p>Gets the number of {@link ResourceEvent}s left to process by this job. This
		 * count is only valid for the exact moment it is returned because events are
		 * constantly being added and removed from the queue of events to process</p>
		 * 
		 * @return the number of {@link ResourceEvent}s left to process
		 */
		protected int getNumResourceEventsToProcess() {
			return this.fResourceEvents.size();
		}
		
		/**
		 * <p>Blocks until either the given timeout elapses (0 means never to timeout), or
		 * there are currently no {@link ResourceEvent}s to process or being processed
		 * by this job</p>
		 * 
		 * @param timeout block until either this timeout elapses (0 means never to timeout)
		 * or there are currently no {@link ResourceEvent}s to process or being processed
		 * by this job
		 * 
		 * @throws InterruptedException This can happen when waiting for a lock
		 */
		protected void waitForConsistant(int timeout) throws InterruptedException {
			if(hasResourceEventsToProcess() || isProcessing()) {
				synchronized (this.fToNotifyLock) {
					this.fToNotifyLock.wait(timeout);
				}
			}
		}
		
		/**
		 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
		 */
		protected IStatus run(IProgressMonitor monitor) {
			try {
				//report status
				SubMonitor progress = SubMonitor.convert(monitor);
				
				while(!this.fIsPaused && !monitor.isCanceled() && this.hasResourceEventsToProcess()) {
					//report status
					progress.setTaskName(AbstractIndexManager.this.fName + ": " + //$NON-NLS-1$
							NLS.bind(SSECoreMessages.IndexManager_Indexing_0_Files,
									"" + getNumResourceEventsToProcess())); //$NON-NLS-1$
					progress.setWorkRemaining(getNumResourceEventsToProcess());
					
					//get the next event to process
					ResourceEvent resourceEvent = null;
					IResource resource = null;
					synchronized (this.fResourceEventsLock) {
						resource = (IResource) this.fResourceEvents.keySet().iterator().next();
						resourceEvent = (ResourceEvent)this.fResourceEvents.remove(resource);
					}
					
					//report status
					monitor.subTask(resource.getName());
					
					//perform action safely
					final byte source = resourceEvent.fSource;
					final byte action = resourceEvent.fAction;
					final IResource finResource = resource;
					final IPath movePath = resourceEvent.fMovePath;
					SafeRunner.run(new ISafeRunnable() {
						public void run() throws Exception {
							AbstractIndexManager.this.performAction(source, action,
									finResource, movePath);
						}
	
						public void handleException(Throwable e) {
							Logger.logException("Error while performing an update to the index. " + //$NON-NLS-1$
									AbstractIndexManager.LOG_ERROR_INDEX_INVALID, e);
						}
					});
					
					//report progress
					progress.worked(1);
					
					//avoid dead locks
					Job.getJobManager().currentJob().yieldRule(monitor);
				}
				
				//done work
				monitor.done();
			} finally {
				//want to be sure we notify no matter how we exit
				this.notifyIfConsistant();
			}
			
			/* if canceled then return CANCEL,
			 * else if done or paused return OK
			 */
			IStatus exitStatus;
			if(monitor.isCanceled()) {
				exitStatus = Status.CANCEL_STATUS;
			} else {
				exitStatus = Status.OK_STATUS;
			}
			
			return exitStatus;
		}
		
		/**
		 * <p>If resource not already scheduled to be processed, schedule it
		 * else if resource already scheduled to be processed, update the action only if
		 * the new action comes from a resource change event.</p>
		 * 
		 * <p>Ignore other sources for updating existing resource events because all other
		 * sources are "start-up" type sources and thus only {@link ResourceEvent} with a
		 * source of a resource change event trump existing events.</p>
		 * 
		 * @param resourceEvent {@link ResourceEvent} to be processed by this job
		 */
		private void addResourceEvent(IResource resource, ResourceEvent resourceEvent) {
			
			synchronized (this.fResourceEventsLock) {
				/* if resource not already scheduled to be processed, schedule it
				 * else if resource already scheduled to be processed, update the action only if
				 * 		the new action comes from a resource change event
				 */
				if(!this.fResourceEvents.containsKey(resource)) {
					this.fResourceEvents.put(resource, resourceEvent);
				} else if(resourceEvent.fSource == AbstractIndexManager.SOURCE_RESROUCE_CHANGE) {
					((ResourceEvent)this.fResourceEvents.get(resource)).fAction = resourceEvent.fAction;
				} else {
					//Purposely ignoring all other resource events
				}
			}
		}
		
		/**
		 * @return <code>true</code> if there are any resources to process,
		 * <code>false</code> otherwise
		 */
		private boolean hasResourceEventsToProcess() {
			return !this.fResourceEvents.isEmpty();
		}
		
		/**
		 * <p>Preserves all of the resource events that have been received by this
		 * manager but not yet processed</p>
		 * 
		 * <p>If this operation was successful then the next time the manager starts
		 * it can load these events and process them.  If it was not successful then a
		 * full re-processing of the entire workspace will need to take place to be
		 * sure the index is consistent.</p>
		 * 
		 * <p><b>NOTE:</b> If this method changes how it preserves these events then
		 * {@link #serialVersionUID} will need to be incremented so that the manger
		 * does not attempt to load an old version of the file that may exist in a users
		 * workspace.  Also {@link #loadPreservedRecievedResourceEvents(SubMonitor)} will
		 * have to be updated to load the new file structure</p>
		 * 
		 * @return <code>true</code> if successfully preserved the resources the resource
		 * events that have been received by not yet processed, <code>false</code> otherwise
		 * 
		 * @see #serialVersionUID
		 * @see #loadPreservedRecievedResourceEvents(SubMonitor)
		 */
		private boolean preserveRecievedResourceEvents() {
			File preservedResourceEventsFile = this.getPreservedResourceEventsFile();
			boolean success = true;
			
			synchronized (this.fResourceEventsLock) {
				DataOutputStream dos = null;
				try {
					//if file already exists delete it
					if(preservedResourceEventsFile.exists()) {
						preservedResourceEventsFile.delete();
						preservedResourceEventsFile.createNewFile();
					}
					
					//create output objects
					FileOutputStream fos = new FileOutputStream(preservedResourceEventsFile);
					BufferedOutputStream bos = new BufferedOutputStream(fos);
					dos = new DataOutputStream(bos);
					
					//write serial version
					dos.writeLong(serialVersionUID);
					
					//write size
					dos.writeInt(this.getNumResourceEventsToProcess());
					
					//write out all the information needed to restore the resource events to process
					Iterator iter = this.fResourceEvents.keySet().iterator();
					while(iter.hasNext()) {
						IResource resource = (IResource)iter.next();
						ResourceEvent resourceEvent = (ResourceEvent)this.fResourceEvents.get(resource);
						
						if(resourceEvent.fSource != AbstractIndexManager.SOURCE_WORKSPACE_SCAN) {
							//write out information
							dos.writeByte(resourceEvent.fAction);
							dos.writeByte(resource.getType());
							dos.writeBytes(resource.getLocation().toPortableString());
							dos.writeByte('\0');
							if(resourceEvent.fMovePath != null) {
								dos.writeBytes(resourceEvent.fMovePath.toPortableString());
							}
							dos.writeByte('\0');
						}
					}
					
					this.fResourceEvents.clear();
					
					dos.flush();
				} catch (FileNotFoundException e) {
					Logger.logException(AbstractIndexManager.this.fName +
							": Exception while opening file to preserve resrouces to index.", //$NON-NLS-1$
							e);
					success = false;
				} catch (IOException e) {
					Logger.logException(AbstractIndexManager.this.fName +
							": Exception while writing to file to preserve resrouces to index.", //$NON-NLS-1$
							e);
					success = false;
				} finally {
					//be sure to close output
					if(dos != null) {
						try {
							dos.close();
						} catch (IOException e) {
							Logger.logException(AbstractIndexManager.this.fName +
									": Exception while closing file with preserved resources to index.", //$NON-NLS-1$
									e);
							success = false;
						}
					}
				}
				
				//if failed, for consistency must do a full re-process next workspace load
				if(!success) {
					preservedResourceEventsFile.delete();
				}
			}
			
			return success;
		}
		
		/**
		 * <p>Loads the received resource events that were preserved during the manger's
		 * last shut down so they can be processed now</p>
		 * 
		 * <p>If this operation is not successful then a full re-processing of the
		 * entire workspace is needed to be sure the index is consistent.</p>
		 * 
		 * @param progress used to report status of loading the preserved received resource events
		 * @return <code>true</code> if the loading of the preserved received resource events
		 * was successful, <code>false</code> otherwise.
		 * 
		 * @see #serialVersionUID
		 * @see #preserveRecievedResourceEvents()
		 */
		private boolean loadPreservedRecievedResourceEvents(SubMonitor progress) {
			progress.subTask(SSECoreMessages.IndexManager_processing_deferred_resource_changes);
			
			boolean success = true;
			File preservedResourceEventsFile = this.getPreservedResourceEventsFile();
			
			if(preservedResourceEventsFile.exists()) {
				Map preservedResrouceEvents = null;
				
				DataInputStream dis = null;
				try {
					FileInputStream fis = new FileInputStream(preservedResourceEventsFile);
					BufferedInputStream bis = new BufferedInputStream(fis);
					dis = new DataInputStream(bis);
					
					//check serial version first
					long preservedSerialVersionUID = dis.readLong();
					if(preservedSerialVersionUID == serialVersionUID) {
						
						//read each record
						int numberOfRecords = dis.readInt();
						preservedResrouceEvents = new LinkedHashMap(numberOfRecords);
						progress.setWorkRemaining(numberOfRecords);
						for(int i = 0; i < numberOfRecords; ++i) {
							//action is first byte
							byte action = dis.readByte();
							
							//file type is the next byte 
							byte fileType = dis.readByte();
							
							//resource location are the next bytes
							StringBuffer resourceLocationBuffer = new StringBuffer();
							byte b = dis.readByte();
							while(b != '\0') {
								resourceLocationBuffer.append(b);
							}
							
							//move path are the next bytes
							StringBuffer movePathBuffer = new StringBuffer();
							b = dis.readByte();
							while(b != '\0') {
								movePathBuffer.append(b);
							}
							
							//get the resource
							IResource resource = null;
							IPath resourcePath = new Path(resourceLocationBuffer.toString());
							if(fileType == IResource.FILE) {
								resource =
									ResourcesPlugin.getWorkspace().getRoot().getFile(resourcePath);
							} else {
								resource =
									ResourcesPlugin.getWorkspace().getRoot().getFolder(resourcePath);
							}
							
							//get the move path
							IPath movePath = null;
							if(movePathBuffer.length() != 0) {
								movePath = new Path(movePathBuffer.toString());
							}
							
							//add the object to the list of of preserved resources
							preservedResrouceEvents.put(resource, new ResourceEvent(
									AbstractIndexManager.SOURCE_PRESERVED_RESOURCES_TO_INDEX,
									action, movePath));
							
							progress.worked(1);
						}	
					} else {
						success = false;
					}
				} catch (FileNotFoundException e) {
					Logger.logException(AbstractIndexManager.this.fName +
							": Exception while opening file to read preserved resrouces to index.", //$NON-NLS-1$
							e);
					success = false;
				} catch (IOException e) {
					Logger.logException(AbstractIndexManager.this.fName +
							": Exception while reading from file of preserved resrouces to index.", //$NON-NLS-1$
							e);
					success = false;
				} finally {
					if(dis != null) {
						try {
							dis.close();
						} catch (IOException e) {
							Logger.logException(AbstractIndexManager.this.fName +
									": Exception while closing file of preserved resources" + //$NON-NLS-1$
									" to index that was just read.  This should have no" + //$NON-NLS-1$
									" effect on the consistency of the index.", //$NON-NLS-1$
									e);
						}
					}
				}
				
				//if success loading preserved then add to master list
				if(success) {
					synchronized (this.fResourceEventsLock) {
						Iterator iter = preservedResrouceEvents.keySet().iterator();
						while(iter.hasNext()) {
							IResource resource = (IResource)iter.next();
							ResourceEvent event = (ResourceEvent)preservedResrouceEvents.get(resource);
							this.fResourceEvents.put(resource, event);
						}
					}
				} else {
					//failed reading file, so delete it
					preservedResourceEventsFile.delete();
				}
			}
			
			return success;
		}
		
		/**
		 * @return {@link File} that contains any resource events received but not processed
		 * by this manager the last time it shutdown. This file may or may not actually
		 * exist.
		 * 
		 * @see #preserveRecievedResourceEvents()
		 * @see #loadPreservedRecievedResourceEvents(SubMonitor)
		 */
		private File getPreservedResourceEventsFile() {
			IPath preservedResroucesToIndexPath =
				AbstractIndexManager.this.getWorkingLocation().append(
						PRESERVED_RESOURCE_EVENTS_TO_PROCESS_FILE_NAME);
			return new File(preservedResroucesToIndexPath.toOSString());
		}
		
		/**
		 * <p>If all resource events have been processed 
		 */
		private void notifyIfConsistant() {
			if(!this.hasResourceEventsToProcess()) {
				synchronized (this.fToNotifyLock) {
					this.fToNotifyLock.notifyAll();
				}
			}
		}
	}
	
	/**
	 * <p>Represents a resource that was discovered by this manager.  Contains
	 * all the information this manager and the index needs to know about this
	 * resource.  Such has how the manager was notified about this resource and
	 * the type of action occurring on the resource.</p>
	 */
	private static class ResourceEvent {
		/**
		 * <p>The source of this resource event</p>
		 * 
		 * @see AbstractIndexManager#SOURCE_RESROUCE_CHANGE
		 * @see AbstractIndexManager#SOURCE_SAVED_STATE
		 * @see AbstractIndexManager#SOURCE_WORKSPACE_SCAN
		 * @see AbstractIndexManager#SOURCE_PRESERVED_RESOURCES_TO_INDEX
		 */
		protected byte fSource;
		
		/**
		 * <p>The action that the index should take with this resource</p>
		 *
		 * @see AbstractIndexManager#ACTION_ADD
		 * @see AbstractIndexManager#ACTION_REMOVE
		 * @see AbstractIndexManager#ACTION_ADD_MOVE_FROM
		 * @see AbstractIndexManager#ACTION_REMOVE_MOVE_TO
		 */
		protected byte fAction;
		
		/**
		 * 
		 * <p>If the {@link #fAction} is {@link AbstractIndexManager#ACTION_ADD_MOVE_FROM} or
		 * {@link AbstractIndexManager#ACTION_REMOVE_MOVE_TO} then this field will have the
		 * path the resource was moved from or moved to. Else this field will be <code>null</code></p>
		 * 
		 * <p><b>NOTE: </b>Maybe <code>null</code>.</p>
		 * 
		 * @see AbstractIndexManager#ACTION_ADD_MOVE_FROM
		 * @see AbstractIndexManager#ACTION_REMOVE_MOVE_TO
		 */
		protected IPath fMovePath;
		
		/**
		 * <p>Creates a resource event that the index needs to react to in some way</p>
		 * 
		 * @param source source that the manger used to learn of this resource
		 * @param action action the index should take on this resource
		 * @param resource resource that the index should know about
		 * @param movePath if action is {@link AbstractIndexManager#ACTION_ADD_MOVE_FROM} or
		 * {@link AbstractIndexManager#ACTION_REMOVE_MOVE_TO} then this should be the path the
		 * resource was moved from or moved to respectively, else should be <code>null</code>
		 * 
		 * @see AbstractIndexManager#SOURCE_RESROUCE_CHANGE
		 * @see AbstractIndexManager#SOURCE_SAVED_STATE
		 * @see AbstractIndexManager#SOURCE_WORKSPACE_SCAN
		 * @see AbstractIndexManager#SOURCE_PRESERVED_RESOURCES_TO_INDEX
		 * 
		 * @see AbstractIndexManager#ACTION_ADD
		 * @see AbstractIndexManager#ACTION_REMOVE
		 * @see AbstractIndexManager#ACTION_ADD_MOVE_FROM
		 * @see AbstractIndexManager#ACTION_REMOVE_MOVE_TO
		 */
		protected ResourceEvent(byte source, byte action, IPath movePath) {
			this.fSource = source;
			this.fAction = action;
			this.fMovePath = movePath;
		}
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/sse/core/internal/SSECoreMessages.java (-1 / +10 lines)
1	/**********************************************************************	1	/**********************************************************************
2	* Copyright (c) 2005 IBM Corporation and others. All rights reserved. This	2	* Copyright (c) 2005, 2010 IBM Corporation and others. All rights reserved. This
3	* program and the accompanying materials are made available under the terms of	3	* program and the accompanying materials are made available under the terms of
4	* the Eclipse Public License v1.0 which accompanies this distribution, and is	4	* the Eclipse Public License v1.0 which accompanies this distribution, and is
5	* available at http://www.eclipse.org/legal/epl-v10.html	5	* available at http://www.eclipse.org/legal/epl-v10.html
Lines 36-39 Link Here
36	public static String TaskScanningJob_0;	36	public static String TaskScanningJob_0;
37	public static String TaskScanningJob_1;	37	public static String TaskScanningJob_1;
38	public static String Migrate_Charset;	38	public static String Migrate_Charset;
		39
		40	public static String IndexManager_starting;
		41	public static String IndexManager_Indexing_0_Files;
		42	public static String IndexManager_processing_deferred_resource_changes;
		43	public static String IndexManager_Processing_entire_workspace_for_the_first_time;
		44	public static String IndexManager_processing_recent_resource_changes;
		45	public static String IndexManager_0_resources_to_go;
		46	public static String IndexManager_Waiting_for_0;
		47	public static String IndexManager_Processing_resource_events;
39	}	48	}




###############################################################################
# Copyright (c) 2001, 2010 IBM Corporation and others.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at

TaskScanningJob_1=Errors while detecting Tasks
###############################################################################
Migrate_Charset=Migrate Charset

IndexManager_starting=Starting
IndexManager_Indexing_0_Files=Indexing {0} Files
IndexManager_processing_deferred_resource_changes=Processing deferred resource changes
IndexManager_Processing_entire_workspace_for_the_first_time=Processing entire workspace for the first time
IndexManager_processing_recent_resource_changes=Processing recent resource changes
IndexManager_0_resources_to_go={0} resources to go
IndexManager_Waiting_for_0=Waiting for {0}
IndexManager_Processing_resource_events=Processing Resource Events

Return to bug 323392

Lines 16-22 Link Here

(-)src/org/eclipse/jst/jsp/core/internal/java/JSPTranslation.java (-5 / +18 lines)
16	import java.util.Iterator;	16	import java.util.Iterator;
17	import java.util.List;	17	import java.util.List;
18		18
19	import org.eclipse.core.resources.IFile;
20	import org.eclipse.core.resources.WorkspaceJob;	19	import org.eclipse.core.resources.WorkspaceJob;
21	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IProgressMonitor;	21	import org.eclipse.core.runtime.IProgressMonitor;
Lines 29-35 Link Here
29	import org.eclipse.jdt.core.ICompilationUnit;	28	import org.eclipse.jdt.core.ICompilationUnit;
30	import org.eclipse.jdt.core.IJavaElement;	29	import org.eclipse.jdt.core.IJavaElement;
31	import org.eclipse.jdt.core.IJavaProject;	30	import org.eclipse.jdt.core.IJavaProject;
32	import org.eclipse.jdt.core.JavaCore;	31	import org.eclipse.jdt.core.IPackageFragment;
		32	import org.eclipse.jdt.core.IPackageFragmentRoot;
33	import org.eclipse.jdt.core.JavaModelException;	33	import org.eclipse.jdt.core.JavaModelException;
34	import org.eclipse.jdt.core.WorkingCopyOwner;	34	import org.eclipse.jdt.core.WorkingCopyOwner;
35	import org.eclipse.jface.text.Position;	35	import org.eclipse.jface.text.Position;
Lines 436-444 Link Here
436	return null;	436	return null;
437		437
438	final String name = getClassname() + ".java";	438	final String name = getClassname() + ".java";
439	IFile fakeFile = je.getProject().getFile(name);	439	IPackageFragmentRoot packageFragmentRoot = null;
440	ICompilationUnit fakeUnit = JavaCore.createCompilationUnitFrom(fakeFile);	440	IPackageFragmentRoot[] packageFragmentRoots = je.getPackageFragmentRoots();
441	ICompilationUnit cu = fakeUnit.getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor());	441	for (int i = 0; i < packageFragmentRoots.length; i++) {
		442	if (!packageFragmentRoots[i].isArchive() && !packageFragmentRoots[i].isExternal()) {
		443	packageFragmentRoot = packageFragmentRoots[i];
		444	break;
		445	}
		446	}
		447	if (packageFragmentRoot == null) {
		448	if(DEBUG) {
		449	System.out.println("** Abort create working copy: cannot create working copy: JSP is not in a Java project with source package fragment root"); //$NON-NLS-1$
		450	}
		451	return null;
		452	}
		453	final IPackageFragment fragment = packageFragmentRoot.getPackageFragment(IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH);
		454	ICompilationUnit cu = fragment.getCompilationUnit(name).getWorkingCopy(getWorkingCopyOwner(), getProgressMonitor());
442	setContents(cu);	455	setContents(cu);
443		456
444	if(DEBUG) {	457	if(DEBUG) {

Removed Link Here

(-)src/org/eclipse/jst/jsp/core/internal/java/search/IndexWorkspaceJob.java (-163 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2005 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jst.jsp.core.internal.java.search;
12
13	import java.util.ArrayList;
14	import java.util.List;
15
16	import org.eclipse.core.resources.IFile;
17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.resources.IResourceProxy;
19	import org.eclipse.core.resources.IResourceProxyVisitor;
20	import org.eclipse.core.resources.ResourcesPlugin;
21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.IStatus;
24	import org.eclipse.core.runtime.Platform;
25	import org.eclipse.core.runtime.Status;
26	import org.eclipse.core.runtime.content.IContentType;
27	import org.eclipse.core.runtime.jobs.Job;
28	import org.eclipse.jst.jsp.core.internal.JSPCoreMessages;
29	import org.eclipse.jst.jsp.core.internal.provisional.contenttype.ContentTypeIdForJSP;
30
31	/**
32	* Re-indexes the entire workspace.
33	* Ensures the JSP Index is in a stable state before performing a search.
34	* (like after a crash or if previous indexing was canceled)
35	*
36	* @author pavery
37	*/
38	public class IndexWorkspaceJob extends Job {
39
40	// for debugging
41	static final boolean DEBUG;
42	static {
43	String value= Platform.getDebugOption("org.eclipse.jst.jsp.core/debug/jspindexmanager"); //$NON-NLS-1$
44	DEBUG= value != null && value.equalsIgnoreCase("true"); //$NON-NLS-1$
45	}
46
47	/**
48	* Visitor that retrieves jsp project paths for all jsp files in the workspace,
49	* and adds the files to be indexed as they are encountered
50	*/
51	private class JSPFileVisitor implements IResourceProxyVisitor {
52	private List files = new ArrayList();
53
54	// monitor from the Job
55	IProgressMonitor fInnerMonitor = null;
56	public JSPFileVisitor(IProgressMonitor monitor) {
57	this.fInnerMonitor = monitor;
58	}
59
60	public boolean visit(IResourceProxy proxy) throws CoreException {
61
62	// check job canceled
63	if (this.fInnerMonitor != null && this.fInnerMonitor.isCanceled()) {
64	setCanceledState();
65	return false;
66	}
67
68	// check search support canceled
69	if(JSPSearchSupport.getInstance().isCanceled()) {
70	setCanceledState();
71	return false;
72	}
73
74	if (proxy.getType() == IResource.FILE) {
75
76	// https://w3.opensource.ibm.com/bugzilla/show_bug.cgi?id=3553
77	// check this before description
78	// check name before actually getting the file (less work)
79	if(getJspContentType().isAssociatedWith(proxy.getName())) {
80	IFile file = (IFile) proxy.requestResource();
81	if(file.exists()) {
82
83	if(DEBUG)
84	System.out.println("(+) IndexWorkspaceJob adding file: " + file.getName()); //$NON-NLS-1$
85	// this call will check the ContentTypeDescription, so don't need to do it here.
86	//JSPSearchSupport.getInstance().addJspFile(file);
87	this.files.add(file);
88	this.fInnerMonitor.subTask(proxy.getName());
89
90	// don't search deeper for files
91	return false;
92	}
93	}
94	}
95	return true;
96	}
97
98	public final IFile[] getFiles() {
99	return (IFile[])this.files.toArray(new IFile[this.files.size()]);
100	}
101	}
102
103	private IContentType fContentTypeJSP = null;
104
105	public IndexWorkspaceJob() {
106	// pa_TODO may want to say something like "Rebuilding JSP Index" to be more
107	// descriptive instead of "Updating JSP Index" since they are 2 different things
108	super(JSPCoreMessages.JSPIndexManager_0);
109	setPriority(Job.LONG);
110	setSystem(true);
111	}
112
113	IContentType getJspContentType() {
114	if(this.fContentTypeJSP == null)
115	this.fContentTypeJSP = Platform.getContentTypeManager().getContentType(ContentTypeIdForJSP.ContentTypeID_JSP);
116	return this.fContentTypeJSP;
117	}
118
119	/**
120	* @see org eclipse.core.internal.jobs.InternalJob#run(org.eclipse.core.runtime.IProgressMonitor)
121	* for similar method
122	*/
123	protected IStatus run(IProgressMonitor monitor) {
124
125	IStatus status = Status.OK_STATUS;
126	Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
127
128	if(monitor.isCanceled()) {
129	setCanceledState();
130	return Status.CANCEL_STATUS;
131	}
132
133	if(DEBUG)
134	System.out.println(" ^ IndexWorkspaceJob started: "); //$NON-NLS-1$
135
136	long start = System.currentTimeMillis();
137
138	try {
139	JSPFileVisitor visitor = new JSPFileVisitor(monitor);
140	// collect all jsp files
141	ResourcesPlugin.getWorkspace().getRoot().accept(visitor, IResource.DEPTH_INFINITE);
142	// request indexing
143	// this is pretty much like faking an entire workspace resource delta
144	JSPIndexManager.getInstance().indexFiles(visitor.getFiles());
145	}
146	catch (CoreException e) {
147	if(DEBUG)
148	e.printStackTrace();
149	}
150	finally {
151	monitor.done();
152	}
153	long finish = System.currentTimeMillis();
154	if(DEBUG)
155	System.out.println(" ^ IndexWorkspaceJob finished\n total time running: " + (finish - start)); //$NON-NLS-1$
156
157	return status;
158	}
159
160	void setCanceledState() {
161	JSPIndexManager.getInstance().setIndexState(JSPIndexManager.S_CANCELED);
162	}
163	}

Lines 1-5 Link Here

(-)src/org/eclipse/wst/sse/core/internal/SSECorePluginResources.properties (-1 / +10 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2001, 2005 IBM Corporation and others.	2	# Copyright (c) 2001, 2010 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials	3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0	4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at	5	# which accompanies this distribution, and is available at
Lines 19-21 Link Here
19	TaskScanningJob_1=Errors while detecting Tasks	19	TaskScanningJob_1=Errors while detecting Tasks
20	###############################################################################	20	###############################################################################
21	Migrate_Charset=Migrate Charset	21	Migrate_Charset=Migrate Charset
		22
		23	IndexManager_starting=Starting
		24	IndexManager_Indexing_0_Files=Indexing {0} Files
		25	IndexManager_processing_deferred_resource_changes=Processing deferred resource changes
		26	IndexManager_Processing_entire_workspace_for_the_first_time=Processing entire workspace for the first time
		27	IndexManager_processing_recent_resource_changes=Processing recent resource changes
		28	IndexManager_0_resources_to_go={0} resources to go
		29	IndexManager_Waiting_for_0=Waiting for {0}
		30	IndexManager_Processing_resource_events=Processing Resource Events