869b40b79c6b8e47a3bcb19900d31258806f6323
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / DeltaProcessingState.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.core;
12
13 import java.util.Collections;
14 import java.util.HashMap;
15 import java.util.HashSet;
16 import java.util.Hashtable;
17 import java.util.Iterator;
18 import java.util.Set;
19
20 import net.sourceforge.phpdt.core.IClasspathEntry;
21 import net.sourceforge.phpdt.core.IElementChangedListener;
22 import net.sourceforge.phpdt.core.IJavaModel;
23 import net.sourceforge.phpdt.core.IJavaProject;
24 import net.sourceforge.phpdt.core.JavaModelException;
25 import net.sourceforge.phpdt.internal.core.util.Util;
26
27 import org.eclipse.core.resources.IProject;
28 import org.eclipse.core.resources.IProjectDescription;
29 import org.eclipse.core.resources.IResourceChangeEvent;
30 import org.eclipse.core.resources.IResourceChangeListener;
31 import org.eclipse.core.resources.IWorkspaceRoot;
32 import org.eclipse.core.runtime.CoreException;
33 import org.eclipse.core.runtime.ISafeRunnable;
34 //import org.eclipse.core.runtime.Platform;
35 import org.eclipse.core.runtime.SafeRunner;
36
37 /**
38  * Keep the global states used during Java element delta processing.
39  */
40 public class DeltaProcessingState implements IResourceChangeListener {
41
42         /*
43          * Collection of listeners for Java element deltas
44          */
45         public IElementChangedListener[] elementChangedListeners = new IElementChangedListener[5];
46
47         public int[] elementChangedListenerMasks = new int[5];
48
49         public int elementChangedListenerCount = 0;
50
51         /*
52          * Collection of pre Java resource change listeners
53          */
54         public IResourceChangeListener[] preResourceChangeListeners = new IResourceChangeListener[1];
55
56         public int preResourceChangeListenerCount = 0;
57
58         /*
59          * The delta processor for the current thread.
60          */
61         private ThreadLocal deltaProcessors = new ThreadLocal();
62
63         /* A table from IPath (from a classpath entry) to RootInfo */
64         public HashMap roots = new HashMap();
65
66         /*
67          * A table from IPath (from a classpath entry) to ArrayList of RootInfo Used
68          * when an IPath corresponds to more than one root
69          */
70         public HashMap otherRoots = new HashMap();
71
72         /*
73          * A table from IPath (from a classpath entry) to RootInfo from the last
74          * time the delta processor was invoked.
75          */
76         public HashMap oldRoots = new HashMap();
77
78         /*
79          * A table from IPath (from a classpath entry) to ArrayList of RootInfo from
80          * the last time the delta processor was invoked. Used when an IPath
81          * corresponds to more than one root
82          */
83         public HashMap oldOtherRoots = new HashMap();
84
85         /*
86          * A table from IPath (a source attachment path from a classpath entry) to
87          * IPath (a root path)
88          */
89         public HashMap sourceAttachments = new HashMap();
90
91         /* Whether the roots tables should be recomputed */
92         public boolean rootsAreStale = true;
93
94         /* Threads that are currently running initializeRoots() */
95         private Set initializingThreads = Collections
96                         .synchronizedSet(new HashSet());
97
98         public Hashtable externalTimeStamps = new Hashtable();
99
100         public HashMap projectUpdates = new HashMap();
101
102         public static class ProjectUpdateInfo {
103                 JavaProject project;
104
105                 IClasspathEntry[] oldResolvedPath;
106
107                 IClasspathEntry[] newResolvedPath;
108
109                 IClasspathEntry[] newRawPath;
110
111                 /**
112                  * Update projects references so that the build order is consistent with
113                  * the classpath
114                  */
115                 public void updateProjectReferencesIfNecessary()
116                                 throws JavaModelException {
117
118                         String[] oldRequired = this.project
119                                         .projectPrerequisites(this.oldResolvedPath);
120
121                         if (this.newResolvedPath == null) {
122                                 this.newResolvedPath = this.project
123                                                 .getResolvedClasspath(this.newRawPath, null, true,
124                                                                 true, null/* no reverse map */);
125                         }
126                         String[] newRequired = this.project
127                                         .projectPrerequisites(this.newResolvedPath);
128                         try {
129                                 IProject projectResource = this.project.getProject();
130                                 IProjectDescription description = projectResource
131                                                 .getDescription();
132
133                                 IProject[] projectReferences = description
134                                                 .getDynamicReferences();
135
136                                 HashSet oldReferences = new HashSet(projectReferences.length);
137                                 for (int i = 0; i < projectReferences.length; i++) {
138                                         String projectName = projectReferences[i].getName();
139                                         oldReferences.add(projectName);
140                                 }
141                                 HashSet newReferences = (HashSet) oldReferences.clone();
142
143                                 for (int i = 0; i < oldRequired.length; i++) {
144                                         String projectName = oldRequired[i];
145                                         newReferences.remove(projectName);
146                                 }
147                                 for (int i = 0; i < newRequired.length; i++) {
148                                         String projectName = newRequired[i];
149                                         newReferences.add(projectName);
150                                 }
151
152                                 Iterator iter;
153                                 int newSize = newReferences.size();
154
155                                 checkIdentity: {
156                                         if (oldReferences.size() == newSize) {
157                                                 iter = newReferences.iterator();
158                                                 while (iter.hasNext()) {
159                                                         if (!oldReferences.contains(iter.next())) {
160                                                                 break checkIdentity;
161                                                         }
162                                                 }
163                                                 return;
164                                         }
165                                 }
166                                 String[] requiredProjectNames = new String[newSize];
167                                 int index = 0;
168                                 iter = newReferences.iterator();
169                                 while (iter.hasNext()) {
170                                         requiredProjectNames[index++] = (String) iter.next();
171                                 }
172                                 Util.sort(requiredProjectNames); // ensure that if changed,
173                                                                                                         // the order is consistent
174
175                                 IProject[] requiredProjectArray = new IProject[newSize];
176                                 IWorkspaceRoot wksRoot = projectResource.getWorkspace()
177                                                 .getRoot();
178                                 for (int i = 0; i < newSize; i++) {
179                                         requiredProjectArray[i] = wksRoot
180                                                         .getProject(requiredProjectNames[i]);
181                                 }
182                                 description.setDynamicReferences(requiredProjectArray);
183                                 projectResource.setDescription(description, null);
184
185                         } catch (CoreException e) {
186                                 throw new JavaModelException(e);
187                         }
188                 }
189         }
190
191         /**
192          * Workaround for bug 15168 circular errors not reported This is a cache of
193          * the projects before any project addition/deletion has started.
194          */
195         public IJavaProject[] modelProjectsCache;
196
197         /*
198          * Need to clone defensively the listener information, in case some listener
199          * is reacting to some notification iteration by adding/changing/removing
200          * any of the other (for example, if it deregisters itself).
201          */
202         public void addElementChangedListener(IElementChangedListener listener,
203                         int eventMask) {
204                 for (int i = 0; i < this.elementChangedListenerCount; i++) {
205                         if (this.elementChangedListeners[i].equals(listener)) {
206
207                                 // only clone the masks, since we could be in the middle of
208                                 // notifications and one listener decide to change
209                                 // any event mask of another listeners (yet not notified).
210                                 int cloneLength = this.elementChangedListenerMasks.length;
211                                 System
212                                                 .arraycopy(
213                                                                 this.elementChangedListenerMasks,
214                                                                 0,
215                                                                 this.elementChangedListenerMasks = new int[cloneLength],
216                                                                 0, cloneLength);
217                                 this.elementChangedListenerMasks[i] = eventMask; // could be
218                                                                                                                                         // different
219                                 return;
220                         }
221                 }
222                 // may need to grow, no need to clone, since iterators will have cached
223                 // original arrays and max boundary and we only add to the end.
224                 int length;
225                 if ((length = this.elementChangedListeners.length) == this.elementChangedListenerCount) {
226                         System
227                                         .arraycopy(
228                                                         this.elementChangedListeners,
229                                                         0,
230                                                         this.elementChangedListeners = new IElementChangedListener[length * 2],
231                                                         0, length);
232                         System.arraycopy(this.elementChangedListenerMasks, 0,
233                                         this.elementChangedListenerMasks = new int[length * 2], 0,
234                                         length);
235                 }
236                 this.elementChangedListeners[this.elementChangedListenerCount] = listener;
237                 this.elementChangedListenerMasks[this.elementChangedListenerCount] = eventMask;
238                 this.elementChangedListenerCount++;
239         }
240
241         public void addPreResourceChangedListener(IResourceChangeListener listener) {
242                 for (int i = 0; i < this.preResourceChangeListenerCount; i++) {
243                         if (this.preResourceChangeListeners[i].equals(listener)) {
244                                 return;
245                         }
246                 }
247                 // may need to grow, no need to clone, since iterators will have cached
248                 // original arrays and max boundary and we only add to the end.
249                 int length;
250                 if ((length = this.preResourceChangeListeners.length) == this.preResourceChangeListenerCount) {
251                         System
252                                         .arraycopy(
253                                                         this.preResourceChangeListeners,
254                                                         0,
255                                                         this.preResourceChangeListeners = new IResourceChangeListener[length * 2],
256                                                         0, length);
257                 }
258                 this.preResourceChangeListeners[this.preResourceChangeListenerCount] = listener;
259                 this.preResourceChangeListenerCount++;
260         }
261
262         public DeltaProcessor getDeltaProcessor() {
263                 DeltaProcessor deltaProcessor = (DeltaProcessor) this.deltaProcessors
264                                 .get();
265                 if (deltaProcessor != null)
266                         return deltaProcessor;
267                 deltaProcessor = new DeltaProcessor(this, JavaModelManager
268                                 .getJavaModelManager());
269                 this.deltaProcessors.set(deltaProcessor);
270                 return deltaProcessor;
271         }
272
273         public void performClasspathResourceChange(JavaProject project,
274                         IClasspathEntry[] oldResolvedPath,
275                         IClasspathEntry[] newResolvedPath, IClasspathEntry[] newRawPath,
276                         boolean canChangeResources) throws JavaModelException {
277                 ProjectUpdateInfo info = new ProjectUpdateInfo();
278                 info.project = project;
279                 info.oldResolvedPath = oldResolvedPath;
280                 info.newResolvedPath = newResolvedPath;
281                 info.newRawPath = newRawPath;
282                 if (canChangeResources) {
283                         this.projectUpdates.remove(project); // remove possibly awaiting
284                                                                                                         // one
285                         info.updateProjectReferencesIfNecessary();
286                         return;
287                 }
288                 this.recordProjectUpdate(info);
289         }
290
291         public void initializeRoots() {
292
293                 // recompute root infos only if necessary
294                 HashMap newRoots = null;
295                 HashMap newOtherRoots = null;
296                 HashMap newSourceAttachments = null;
297                 if (this.rootsAreStale) {
298                         Thread currentThread = Thread.currentThread();
299                         boolean addedCurrentThread = false;
300                         try {
301                                 // if reentering initialization (through a container initializer
302                                 // for example) no need to compute roots again
303                                 // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=47213
304                                 if (!this.initializingThreads.add(currentThread))
305                                         return;
306                                 addedCurrentThread = true;
307
308                                 newRoots = new HashMap();
309                                 newOtherRoots = new HashMap();
310                                 newSourceAttachments = new HashMap();
311
312                                 IJavaModel model = JavaModelManager.getJavaModelManager()
313                                                 .getJavaModel();
314                                 IJavaProject[] projects;
315                                 try {
316                                         projects = model.getJavaProjects();
317                                 } catch (JavaModelException e) {
318                                         // nothing can be done
319                                         return;
320                                 }
321                                 for (int i = 0, length = projects.length; i < length; i++) {
322                                         JavaProject project = (JavaProject) projects[i];
323                                         // IClasspathEntry[] classpath;
324                                         // try {
325                                         // classpath =
326                                         // project.getResolvedClasspath(true/*ignoreUnresolvedEntry*/,
327                                         // false/*don't generateMarkerOnError*/, false/*don't
328                                         // returnResolutionInProgress*/);
329                                         // } catch (JavaModelException e) {
330                                         // // continue with next project
331                                         // continue;
332                                         // }
333                                         // for (int j= 0, classpathLength = classpath.length; j <
334                                         // classpathLength; j++) {
335                                         // IClasspathEntry entry = classpath[j];
336                                         // if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT)
337                                         // continue;
338                                         //                                              
339                                         // // root path
340                                         // IPath path = entry.getPath();
341                                         // if (newRoots.get(path) == null) {
342                                         // newRoots.put(path, new DeltaProcessor.RootInfo(project,
343                                         // path,
344                                         // ((ClasspathEntry)entry).fullInclusionPatternChars(),
345                                         // ((ClasspathEntry)entry).fullExclusionPatternChars(),
346                                         // entry.getEntryKind()));
347                                         // } else {
348                                         // ArrayList rootList = (ArrayList)newOtherRoots.get(path);
349                                         // if (rootList == null) {
350                                         // rootList = new ArrayList();
351                                         // newOtherRoots.put(path, rootList);
352                                         // }
353                                         // rootList.add(new DeltaProcessor.RootInfo(project, path,
354                                         // ((ClasspathEntry)entry).fullInclusionPatternChars(),
355                                         // ((ClasspathEntry)entry).fullExclusionPatternChars(),
356                                         // entry.getEntryKind()));
357                                         // }
358                                         //                                              
359                                         // // source attachment path
360                                         // if (entry.getEntryKind() != IClasspathEntry.CPE_LIBRARY)
361                                         // continue;
362                                         // QualifiedName qName = new
363                                         // QualifiedName(JavaCore.PLUGIN_ID, "sourceattachment: " +
364                                         // path.toOSString()); //$NON-NLS-1$;
365                                         // String propertyString = null;
366                                         // try {
367                                         // propertyString =
368                                         // ResourcesPlugin.getWorkspace().getRoot().getPersistentProperty(qName);
369                                         // } catch (CoreException e) {
370                                         // continue;
371                                         // }
372                                         // IPath sourceAttachmentPath;
373                                         // if (propertyString != null) {
374                                         // int index=
375                                         // propertyString.lastIndexOf(PackageFragmentRoot.ATTACHMENT_PROPERTY_DELIMITER);
376                                         // sourceAttachmentPath = (index < 0) ? new
377                                         // Path(propertyString) : new
378                                         // Path(propertyString.substring(0, index));
379                                         // } else {
380                                         // sourceAttachmentPath = entry.getSourceAttachmentPath();
381                                         // }
382                                         // if (sourceAttachmentPath != null) {
383                                         // newSourceAttachments.put(sourceAttachmentPath, path);
384                                         // }
385                                         // }
386                                 }
387                         } finally {
388                                 if (addedCurrentThread) {
389                                         this.initializingThreads.remove(currentThread);
390                                 }
391                         }
392                 }
393                 synchronized (this) {
394                         this.oldRoots = this.roots;
395                         this.oldOtherRoots = this.otherRoots;
396                         if (this.rootsAreStale && newRoots != null) { // double check
397                                                                                                                         // again
398                                 this.roots = newRoots;
399                                 this.otherRoots = newOtherRoots;
400                                 this.sourceAttachments = newSourceAttachments;
401                                 this.rootsAreStale = false;
402                         }
403                 }
404         }
405
406         public synchronized void recordProjectUpdate(ProjectUpdateInfo newInfo) {
407
408                 JavaProject project = newInfo.project;
409                 ProjectUpdateInfo oldInfo = (ProjectUpdateInfo) this.projectUpdates
410                                 .get(project);
411                 if (oldInfo != null) { // refresh new classpath information
412                         oldInfo.newRawPath = newInfo.newRawPath;
413                         oldInfo.newResolvedPath = newInfo.newResolvedPath;
414                 } else {
415                         this.projectUpdates.put(project, newInfo);
416                 }
417         }
418
419         public synchronized ProjectUpdateInfo[] removeAllProjectUpdates() {
420                 int length = this.projectUpdates.size();
421                 if (length == 0)
422                         return null;
423                 ProjectUpdateInfo[] updates = new ProjectUpdateInfo[length];
424                 this.projectUpdates.values().toArray(updates);
425                 this.projectUpdates.clear();
426                 return updates;
427         }
428
429         public void removeElementChangedListener(IElementChangedListener listener) {
430
431                 for (int i = 0; i < this.elementChangedListenerCount; i++) {
432
433                         if (this.elementChangedListeners[i].equals(listener)) {
434
435                                 // need to clone defensively since we might be in the middle of
436                                 // listener notifications (#fire)
437                                 int length = this.elementChangedListeners.length;
438                                 IElementChangedListener[] newListeners = new IElementChangedListener[length];
439                                 System.arraycopy(this.elementChangedListeners, 0, newListeners,
440                                                 0, i);
441                                 int[] newMasks = new int[length];
442                                 System.arraycopy(this.elementChangedListenerMasks, 0, newMasks,
443                                                 0, i);
444
445                                 // copy trailing listeners
446                                 int trailingLength = this.elementChangedListenerCount - i - 1;
447                                 if (trailingLength > 0) {
448                                         System.arraycopy(this.elementChangedListeners, i + 1,
449                                                         newListeners, i, trailingLength);
450                                         System.arraycopy(this.elementChangedListenerMasks, i + 1,
451                                                         newMasks, i, trailingLength);
452                                 }
453
454                                 // update manager listener state (#fire need to iterate over
455                                 // original listeners through a local variable to hold onto
456                                 // the original ones)
457                                 this.elementChangedListeners = newListeners;
458                                 this.elementChangedListenerMasks = newMasks;
459                                 this.elementChangedListenerCount--;
460                                 return;
461                         }
462                 }
463         }
464
465         public void removePreResourceChangedListener(
466                         IResourceChangeListener listener) {
467
468                 for (int i = 0; i < this.preResourceChangeListenerCount; i++) {
469
470                         if (this.preResourceChangeListeners[i].equals(listener)) {
471
472                                 // need to clone defensively since we might be in the middle of
473                                 // listener notifications (#fire)
474                                 int length = this.preResourceChangeListeners.length;
475                                 IResourceChangeListener[] newListeners = new IResourceChangeListener[length];
476                                 System.arraycopy(this.preResourceChangeListeners, 0,
477                                                 newListeners, 0, i);
478
479                                 // copy trailing listeners
480                                 int trailingLength = this.preResourceChangeListenerCount - i
481                                                 - 1;
482                                 if (trailingLength > 0) {
483                                         System.arraycopy(this.preResourceChangeListeners, i + 1,
484                                                         newListeners, i, trailingLength);
485                                 }
486
487                                 // update manager listener state (#fire need to iterate over
488                                 // original listeners through a local variable to hold onto
489                                 // the original ones)
490                                 this.preResourceChangeListeners = newListeners;
491                                 this.preResourceChangeListenerCount--;
492                                 return;
493                         }
494                 }
495         }
496
497         public void resourceChanged(final IResourceChangeEvent event) {
498                 boolean isPostChange = event.getType() == IResourceChangeEvent.POST_CHANGE;
499                 if (isPostChange) {
500                         for (int i = 0; i < this.preResourceChangeListenerCount; i++) {
501                                 // wrap callbacks with Safe runnable for subsequent listeners to
502                                 // be called when some are causing grief
503                                 final IResourceChangeListener listener = this.preResourceChangeListeners[i];
504                                 SafeRunner.run(new ISafeRunnable() {
505                                         public void handleException(Throwable exception) {
506                                                 Util
507                                                                 .log(exception,
508                                                                                 "Exception occurred in listener of pre Java resource change notification"); //$NON-NLS-1$
509                                         }
510
511                                         public void run() throws Exception {
512                                                 listener.resourceChanged(event);
513                                         }
514                                 });
515                         }
516                 }
517                 try {
518                         getDeltaProcessor().resourceChanged(event);
519                 } finally {
520                         // TODO (jerome) see 47631, may want to get rid of following so as
521                         // to reuse delta processor ?
522                         if (isPostChange) {
523                                 this.deltaProcessors.set(null);
524                         }
525                 }
526
527         }
528
529         /*
530          * Update the roots that are affected by the addition or the removal of the
531          * given container resource.
532          */
533         // public synchronized void updateRoots(IPath containerPath, IResourceDelta
534         // containerDelta, DeltaProcessor deltaProcessor) {
535         // Map updatedRoots;
536         // Map otherUpdatedRoots;
537         // if (containerDelta.getKind() == IResourceDelta.REMOVED) {
538         // updatedRoots = this.oldRoots;
539         // otherUpdatedRoots = this.oldOtherRoots;
540         // } else {
541         // updatedRoots = this.roots;
542         // otherUpdatedRoots = this.otherRoots;
543         // }
544         // Iterator iterator = updatedRoots.keySet().iterator();
545         // while (iterator.hasNext()) {
546         // IPath path = (IPath)iterator.next();
547         // if (containerPath.isPrefixOf(path) && !containerPath.equals(path)) {
548         // IResourceDelta rootDelta =
549         // containerDelta.findMember(path.removeFirstSegments(1));
550         // if (rootDelta == null) continue;
551         // DeltaProcessor.RootInfo rootInfo =
552         // (DeltaProcessor.RootInfo)updatedRoots.get(path);
553         //      
554         // if (!rootInfo.project.getPath().isPrefixOf(path)) { // only consider
555         // roots that are not included in the container
556         // deltaProcessor.updateCurrentDeltaAndIndex(rootDelta,
557         // IJavaElement.PACKAGE_FRAGMENT_ROOT, rootInfo);
558         // }
559         //                              
560         // ArrayList rootList = (ArrayList)otherUpdatedRoots.get(path);
561         // if (rootList != null) {
562         // Iterator otherProjects = rootList.iterator();
563         // while (otherProjects.hasNext()) {
564         // rootInfo = (DeltaProcessor.RootInfo)otherProjects.next();
565         // if (!rootInfo.project.getPath().isPrefixOf(path)) { // only consider
566         // roots that are not included in the container
567         // deltaProcessor.updateCurrentDeltaAndIndex(rootDelta,
568         // IJavaElement.PACKAGE_FRAGMENT_ROOT, rootInfo);
569         // }
570         // }
571         // }
572         // }
573         // }
574         // }
575 }