513ad3d150e7e6fa9f51d9141f9c45beca44c5cb
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / SetClasspathOperation.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 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.io.File;
14 import java.util.ArrayList;
15 import java.util.HashMap;
16 import java.util.HashSet;
17 import java.util.Iterator;
18 import java.util.Map;
19
20 import net.sourceforge.phpdt.core.IClasspathEntry;
21 import net.sourceforge.phpdt.core.IJavaElement;
22 import net.sourceforge.phpdt.core.IJavaElementDelta;
23 import net.sourceforge.phpdt.core.IJavaModel;
24 import net.sourceforge.phpdt.core.IJavaModelStatus;
25 import net.sourceforge.phpdt.core.IJavaProject;
26 import net.sourceforge.phpdt.core.IPackageFragment;
27 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
28 import net.sourceforge.phpdt.core.JavaModelException;
29 import net.sourceforge.phpdt.internal.compiler.util.ObjectVector;
30
31 import org.eclipse.core.resources.IFolder;
32 import org.eclipse.core.resources.IProject;
33 import org.eclipse.core.resources.IProjectDescription;
34 import org.eclipse.core.resources.IResource;
35 import org.eclipse.core.resources.IWorkspace;
36 import org.eclipse.core.resources.IWorkspaceRoot;
37 import org.eclipse.core.resources.ResourcesPlugin;
38 import org.eclipse.core.runtime.CoreException;
39 import org.eclipse.core.runtime.IPath;
40 import org.eclipse.core.runtime.Path;
41
42 /**
43  * This operation sets an <code>IJavaProject</code>'s classpath.
44  *
45  * @see IJavaProject
46  */
47 public class SetClasspathOperation extends JavaModelOperation {
48
49         IClasspathEntry[] oldResolvedPath, newResolvedPath;
50         IClasspathEntry[] newRawPath;
51         boolean canChangeResource;
52         boolean needCycleCheck;
53         boolean needValidation;
54         boolean needSave;
55         IPath newOutputLocation;
56         
57         public static final IClasspathEntry[] ReuseClasspath = new IClasspathEntry[0];
58         public static final IClasspathEntry[] UpdateClasspath = new IClasspathEntry[0];
59         // if reusing output location, then also reuse clean flag
60         public static final IPath ReuseOutputLocation = new Path("Reuse Existing Output Location");  //$NON-NLS-1$
61         
62         /**
63          * When executed, this operation sets the classpath of the given project.
64          */
65         public SetClasspathOperation(
66                 IJavaProject project,
67                 IClasspathEntry[] oldResolvedPath,
68                 IClasspathEntry[] newRawPath,
69                 IPath newOutputLocation,
70                 boolean canChangeResource,
71                 boolean needValidation,
72                 boolean needSave) {
73
74                 super(new IJavaElement[] { project });
75                 this.oldResolvedPath = oldResolvedPath;
76                 this.newRawPath = newRawPath;
77                 this.newOutputLocation = newOutputLocation;
78                 this.canChangeResource = canChangeResource;
79                 this.needValidation = needValidation;
80                 this.needSave = needSave;
81         }
82
83         /**
84          * Adds deltas for the given roots, with the specified change flag,
85          * and closes the root. Helper method for #setClasspath
86          */
87         protected void addClasspathDeltas(
88                 IPackageFragmentRoot[] roots,
89                 int flag,
90                 JavaElementDelta delta) {
91
92                 for (int i = 0; i < roots.length; i++) {
93                         IPackageFragmentRoot root = roots[i];
94                         delta.changed(root, flag);
95                         if ((flag & IJavaElementDelta.F_REMOVED_FROM_CLASSPATH) != 0 
96                                         || (flag & IJavaElementDelta.F_SOURCEATTACHED) != 0
97                                         || (flag & IJavaElementDelta.F_SOURCEDETACHED) != 0){
98                                 try {
99                                         root.close();
100                                 } catch (JavaModelException e) {
101                                 }
102                                 // force detach source on jar package fragment roots (source will be lazily computed when needed)
103                                 ((PackageFragmentRoot) root).setSourceAttachmentProperty(null);// loose info - will be recomputed
104                         }
105                 }
106         }
107
108
109
110         /**
111          * Returns the index of the item in the list if the given list contains the specified entry. If the list does
112          * not contain the entry, -1 is returned.
113          * A helper method for #setClasspath
114          */
115         protected int classpathContains(
116                 IClasspathEntry[] list,
117                 IClasspathEntry entry) {
118
119                 IPath[] exclusionPatterns = entry.getExclusionPatterns();
120                 nextEntry: for (int i = 0; i < list.length; i++) {
121                         IClasspathEntry other = list[i];
122                         if (other.getContentKind() == entry.getContentKind()
123                                 && other.getEntryKind() == entry.getEntryKind()
124                                 && other.isExported() == entry.isExported()
125                                 && other.getPath().equals(entry.getPath())) {
126                                         // check custom outputs
127                                         IPath entryOutput = entry.getOutputLocation();
128                                         IPath otherOutput = other.getOutputLocation();
129                                         if (entryOutput == null) {
130                                                 if (otherOutput != null)
131                                                         continue;
132                                         } else {
133                                                 if (!entryOutput.equals(otherOutput))
134                                                         continue;
135                                         }
136                                         
137                                         // check exclusion patterns
138                                         IPath[] otherExcludes = other.getExclusionPatterns();
139                                         if (exclusionPatterns != otherExcludes) {
140                                                 int excludeLength = exclusionPatterns.length;
141                                                 if (otherExcludes.length != excludeLength)
142                                                         continue;
143                                                 for (int j = 0; j < excludeLength; j++) {
144                                                         // compare toStrings instead of IPaths 
145                                                         // since IPath.equals is specified to ignore trailing separators
146                                                         if (!exclusionPatterns[j].toString().equals(otherExcludes[j].toString()))
147                                                                 continue nextEntry;
148                                                 }
149                                         }
150                                         return i;
151                         }
152                 }
153                 return -1;
154         }
155
156         /**
157          * Recursively adds all subfolders of <code>folder</code> to the given collection.
158          */
159         protected void collectAllSubfolders(IFolder folder, ArrayList collection) throws JavaModelException {
160                 try {
161                         IResource[] members= folder.members();
162                         for (int i = 0, max = members.length; i < max; i++) {
163                                 IResource r= members[i];
164                                 if (r.getType() == IResource.FOLDER) {
165                                         collection.add(r);
166                                         collectAllSubfolders((IFolder)r, collection);
167                                 }
168                         }       
169                 } catch (CoreException e) {
170                         throw new JavaModelException(e);
171                 }
172         }
173
174         /**
175          * Returns a collection of package fragments that have been added/removed
176          * as the result of changing the output location to/from the given
177          * location. The collection is empty if no package fragments are
178          * affected.
179          */
180 //      protected ArrayList determineAffectedPackageFragments(IPath location) throws JavaModelException {
181 //              ArrayList fragments = new ArrayList();
182 //              JavaProject project =getProject();
183 //      
184 //              // see if this will cause any package fragments to be affected
185 //              IWorkspace workspace = ResourcesPlugin.getWorkspace();
186 //              IResource resource = null;
187 //              if (location != null) {
188 //                      resource = workspace.getRoot().findMember(location);
189 //              }
190 //              if (resource != null && resource.getType() == IResource.FOLDER) {
191 //                      IFolder folder = (IFolder) resource;
192 //                      // only changes if it actually existed
193 //                      IClasspathEntry[] classpath = project.getExpandedClasspath(true);
194 //                      for (int i = 0; i < classpath.length; i++) {
195 //                              IClasspathEntry entry = classpath[i];
196 //                              IPath path = classpath[i].getPath();
197 //                              if (entry.getEntryKind() != IClasspathEntry.CPE_PROJECT && path.isPrefixOf(location) && !path.equals(location)) {
198 //                                      IPackageFragmentRoot[] roots = project.computePackageFragmentRoots(classpath[i]);
199 //                                      IPackageFragmentRoot root = roots[0];
200 //                                      // now the output location becomes a package fragment - along with any subfolders
201 //                                      ArrayList folders = new ArrayList();
202 //                                      folders.add(folder);
203 //                                      collectAllSubfolders(folder, folders);
204 //                                      Iterator elements = folders.iterator();
205 //                                      int segments = path.segmentCount();
206 //                                      while (elements.hasNext()) {
207 //                                              IFolder f = (IFolder) elements.next();
208 //                                              IPath relativePath = f.getFullPath().removeFirstSegments(segments);
209 //                                              String name = relativePath.toOSString();
210 //                                              name = name.replace(File.pathSeparatorChar, '.');
211 //                                              if (name.endsWith(".")) { //$NON-NLS-1$
212 //                                                      name = name.substring(0, name.length() - 1);
213 //                                              }
214 //                                              IPackageFragment pkg = root.getPackageFragment(name);
215 //                                              fragments.add(pkg);
216 //                                      }
217 //                              }
218 //                      }
219 //              }
220 //              return fragments;
221 //      }
222
223         /**
224          * Sets the classpath of the pre-specified project.
225          */
226         protected void executeOperation() throws JavaModelException {
227                 // project reference updated - may throw an exception if unable to write .project file
228                 updateProjectReferencesIfNecessary();
229
230                 // classpath file updated - may throw an exception if unable to write .classpath file
231                 saveClasspathIfNecessary();
232                 
233                 // perform classpath and output location updates, if exception occurs in classpath update,
234                 // make sure the output location is updated before surfacing the exception (in case the output
235                 // location update also throws an exception, give priority to the classpath update one).
236                 JavaModelException originalException = null;
237
238                 try {
239                         JavaProject project = getProject();
240                         if (this.newRawPath == UpdateClasspath) this.newRawPath = project.getRawClasspath();
241                         if (this.newRawPath != ReuseClasspath){
242                                 updateClasspath();
243 //                              project.updatePackageFragmentRoots();
244                                 JavaModelManager.getJavaModelManager().deltaProcessor.addForRefresh(project);
245                         }
246
247                 } catch(JavaModelException e){
248                         originalException = e;
249                         throw e;
250
251                 } finally { // if traversed by an exception we still need to update the output location when necessary
252
253                         try {
254                                 if (this.newOutputLocation != ReuseOutputLocation) updateOutputLocation();
255
256                         } catch(JavaModelException e){
257                                 if (originalException != null) throw originalException; 
258                                 throw e;
259                         }
260                 }
261                 done();
262         }
263
264         /**
265          * Generates the delta of removed/added/reordered roots.
266          * Use three deltas in case the same root is removed/added/reordered (for
267          * instance, if it is changed from K_SOURCE to K_BINARY or vice versa)
268          */
269 //      protected void generateClasspathChangeDeltas(
270 //              IClasspathEntry[] oldResolvedPath,
271 //              IClasspathEntry[] newResolvedPath,
272 //              final JavaProject project) {
273 //      
274 //              JavaModelManager manager = JavaModelManager.getJavaModelManager();
275 //              boolean needToUpdateDependents = false;
276 //              JavaElementDelta delta = new JavaElementDelta(getJavaModel());
277 //              boolean hasDelta = false;
278 //              int oldLength = oldResolvedPath.length;
279 //              int newLength = newResolvedPath.length;
280 //                      
281 //              final IndexManager indexManager = manager.getIndexManager();
282 //              Map oldRoots = null;
283 //              IPackageFragmentRoot[] roots = null;
284 //              if (project.isOpen()) {
285 //                      try {
286 //                              roots = project.getPackageFragmentRoots();
287 //                      } catch (JavaModelException e) {
288 //                      }
289 //              } else {
290 //                      Map allRemovedRoots ;
291 //                      if ((allRemovedRoots = manager.deltaProcessor.removedRoots) != null) {
292 //                              roots = (IPackageFragmentRoot[]) allRemovedRoots.get(project);
293 //                      }
294 //              }
295 //              if (roots != null) {
296 //                      oldRoots = new HashMap();
297 //                      for (int i = 0; i < roots.length; i++) {
298 //                              IPackageFragmentRoot root = roots[i];
299 //                              oldRoots.put(root.getPath(), root);
300 //                      }
301 //              }
302 //              for (int i = 0; i < oldLength; i++) {
303 //                      
304 //                      int index = classpathContains(newResolvedPath, oldResolvedPath[i]);
305 //                      if (index == -1) {
306 //                              // do not notify remote project changes
307 //                              if (oldResolvedPath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
308 //                                      needToUpdateDependents = true;
309 //                                      this.needCycleCheck = true;
310 //                                      continue; 
311 //                              }
312 //      
313 //                              IPackageFragmentRoot[] pkgFragmentRoots = null;
314 //                              if (oldRoots != null) {
315 //                                      IPackageFragmentRoot oldRoot = (IPackageFragmentRoot)  oldRoots.get(oldResolvedPath[i].getPath());
316 //                                      if (oldRoot != null) { // use old root if any (could be none if entry wasn't bound)
317 //                                              pkgFragmentRoots = new IPackageFragmentRoot[] { oldRoot };
318 //                                      }
319 //                              }
320 //                              if (pkgFragmentRoots == null) {
321 //                                      try {
322 //                                              ObjectVector accumulatedRoots = new ObjectVector();
323 //                                              HashSet rootIDs = new HashSet(5);
324 //                                              rootIDs.add(project.rootID());
325 //                                              project.computePackageFragmentRoots(
326 //                                                      oldResolvedPath[i], 
327 //                                                      accumulatedRoots, 
328 //                                                      rootIDs,
329 //                                                      true, // inside original project
330 //                                                      false, // don't check existency
331 //                                                      false); // don't retrieve exported roots
332 //                                              pkgFragmentRoots = new IPackageFragmentRoot[accumulatedRoots.size()];
333 //                                              accumulatedRoots.copyInto(pkgFragmentRoots);
334 //                                      } catch (JavaModelException e) {
335 //                                              pkgFragmentRoots =  new IPackageFragmentRoot[] {};
336 //                                      }
337 //                              }
338 //                              addClasspathDeltas(pkgFragmentRoots, IJavaElementDelta.F_REMOVED_FROM_CLASSPATH, delta);
339 //                              
340 //                              int changeKind = oldResolvedPath[i].getEntryKind();
341 //                              needToUpdateDependents |= (changeKind == IClasspathEntry.CPE_SOURCE) || oldResolvedPath[i].isExported();
342 //      
343 //                              // Remove the .java files from the index for a source folder
344 //                              // For a lib folder or a .jar file, remove the corresponding index if not shared.
345 //                              if (indexManager != null) {
346 //                                      IClasspathEntry oldEntry = oldResolvedPath[i];
347 //                                      final IPath path = oldEntry.getPath();
348 //                                      switch (changeKind) {
349 //                                              case IClasspathEntry.CPE_SOURCE:
350 //                                                      final char[][] exclusionPatterns = ((ClasspathEntry)oldEntry).fullExclusionPatternChars();
351 //                                                      postAction(new IPostAction() {
352 //                                                              public String getID() {
353 //                                                                      return path.toString();
354 //                                                              }
355 //                                                              public void run() throws JavaModelException {
356 //                                                                      indexManager.removeSourceFolderFromIndex(project, path, exclusionPatterns);
357 //                                                              }
358 //                                                      }, 
359 //                                                      REMOVEALL_APPEND);
360 //                                                      break;
361 //                                              case IClasspathEntry.CPE_LIBRARY:
362 //                                                      final DeltaProcessor deltaProcessor = manager.deltaProcessor;
363 //                                                      postAction(new IPostAction() {
364 //                                                              public String getID() {
365 //                                                                      return path.toString();
366 //                                                              }
367 //                                                              public void run() throws JavaModelException {
368 //                                                                      if (deltaProcessor.otherRoots.get(path) == null) { // if root was not shared
369 //                                                                              indexManager.discardJobs(path.toString());
370 //                                                                              indexManager.removeIndex(path);
371 //                                                                              // TODO: we could just remove the in-memory index and have the indexing check for timestamps
372 //                                                                      }
373 //                                                              }
374 //                                                      }, 
375 //                                                      REMOVEALL_APPEND);
376 //                                                      break;
377 //                                      }               
378 //                              }
379 //                              hasDelta = true;
380 //      
381 //                      } else {
382 //                              // do not notify remote project changes
383 //                              if (oldResolvedPath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
384 //                                      this.needCycleCheck |= (oldResolvedPath[i].isExported() != newResolvedPath[index].isExported());
385 //                                      continue; 
386 //                              }                               
387 //                              needToUpdateDependents |= (oldResolvedPath[i].isExported() != newResolvedPath[index].isExported());
388 //                              if (index != i) { //reordering of the classpath
389 //                                              addClasspathDeltas(
390 //                                                      project.computePackageFragmentRoots(oldResolvedPath[i]),
391 //                                                      IJavaElementDelta.F_REORDER,
392 //                                                      delta);
393 //                                              int changeKind = oldResolvedPath[i].getEntryKind();
394 //                                              needToUpdateDependents |= (changeKind == IClasspathEntry.CPE_SOURCE);
395 //              
396 //                                              hasDelta = true;
397 //                              }
398 //                              
399 //                              // check source attachment
400 //                              IPath newSourcePath = newResolvedPath[index].getSourceAttachmentPath();
401 //                              int sourceAttachmentFlags = 
402 //                                      this.getSourceAttachmentDeltaFlag(
403 //                                              oldResolvedPath[i].getSourceAttachmentPath(),
404 //                                              newSourcePath,
405 //                                              null/*not a source root path*/);
406 //                              int sourceAttachmentRootFlags = 
407 //                                      this.getSourceAttachmentDeltaFlag(
408 //                                              oldResolvedPath[i].getSourceAttachmentRootPath(),
409 //                                              newResolvedPath[index].getSourceAttachmentRootPath(),
410 //                                              newSourcePath/*in case both root paths are null*/);
411 //                              int flags = sourceAttachmentFlags | sourceAttachmentRootFlags;
412 //                              if (flags != 0) {
413 //                                      addClasspathDeltas(
414 //                                              project.computePackageFragmentRoots(oldResolvedPath[i]),
415 //                                              flags,
416 //                                              delta);
417 //                                      hasDelta = true;
418 //                              }
419 //                      }
420 //              }
421 //      
422 //              for (int i = 0; i < newLength; i++) {
423 //      
424 //                      int index = classpathContains(oldResolvedPath, newResolvedPath[i]);
425 //                      if (index == -1) {
426 //                              // do not notify remote project changes
427 //                              if (newResolvedPath[i].getEntryKind() == IClasspathEntry.CPE_PROJECT){
428 //                                      needToUpdateDependents = true;
429 //                                      this.needCycleCheck = true;
430 //                                      continue; 
431 //                              }
432 //                              addClasspathDeltas(
433 //                                      project.computePackageFragmentRoots(newResolvedPath[i]),
434 //                                      IJavaElementDelta.F_ADDED_TO_CLASSPATH,
435 //                                      delta);
436 //                              int changeKind = newResolvedPath[i].getEntryKind();
437 //                              
438 //                              // Request indexing
439 //                              if (indexManager != null) {
440 //                                      switch (changeKind) {
441 //                                              case IClasspathEntry.CPE_LIBRARY:
442 //                                                      boolean pathHasChanged = true;
443 //                                                      final IPath newPath = newResolvedPath[i].getPath();
444 //                                                      for (int j = 0; j < oldLength; j++) {
445 //                                                              IClasspathEntry oldEntry = oldResolvedPath[j];
446 //                                                              if (oldEntry.getPath().equals(newPath)) {
447 //                                                                      pathHasChanged = false;
448 //                                                                      break;
449 //                                                              }
450 //                                                      }
451 //                                                      if (pathHasChanged) {
452 //                                                              postAction(new IPostAction() {
453 //                                                                      public String getID() {
454 //                                                                              return newPath.toString();
455 //                                                                      }
456 //                                                                      public void run() throws JavaModelException {
457 //                                                                              indexManager.indexLibrary(newPath, project.getProject());
458 //                                                                      }
459 //                                                              }, 
460 //                                                              REMOVEALL_APPEND);
461 //                                                      }
462 //                                                      break;
463 //                                              case IClasspathEntry.CPE_SOURCE:
464 //                                                      IClasspathEntry entry = newResolvedPath[i];
465 //                                                      final IPath path = entry.getPath();
466 //                                                      final char[][] exclusionPatterns = ((ClasspathEntry)entry).fullExclusionPatternChars();
467 //                                                      postAction(new IPostAction() {
468 //                                                              public String getID() {
469 //                                                                      return path.toString();
470 //                                                              }
471 //                                                              public void run() throws JavaModelException {
472 //                                                                      indexManager.indexSourceFolder(project, path, exclusionPatterns);
473 //                                                              }
474 //                                                      }, 
475 //                                                      APPEND); // append so that a removeSourceFolder action is not removed
476 //                                                      break;
477 //                                      }
478 //                              }
479 //                              
480 //                              needToUpdateDependents |= (changeKind == IClasspathEntry.CPE_SOURCE) || newResolvedPath[i].isExported();
481 //                              hasDelta = true;
482 //      
483 //                      } // classpath reordering has already been generated in previous loop
484 //              }
485 //      
486 //              if (hasDelta) {
487 //                      this.addDelta(delta);
488 //              }
489 //              if (needToUpdateDependents){
490 //                      updateAffectedProjects(project.getProject().getFullPath());
491 //              }
492 //      }
493
494         protected JavaProject getProject() {
495                 return ((JavaProject) getElementsToProcess()[0]);
496         }
497
498         /*
499          * Returns the source attachment flag for the delta between the 2 give source paths.
500          * Returns either F_SOURCEATTACHED, F_SOURCEDETACHED, F_SOURCEATTACHED | F_SOURCEDETACHED
501          * or 0 if there is no difference.
502          */
503         private int getSourceAttachmentDeltaFlag(IPath oldPath, IPath newPath, IPath sourcePath) {
504                 if (oldPath == null) {
505                         if (newPath != null) {
506                                 return IJavaElementDelta.F_SOURCEATTACHED;
507                         } else {
508                                 if (sourcePath != null) {
509                                         // if source path is specified and no root path, it needs to be recomputed dynamically
510                                         return IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED;
511                                 } else {
512                                         return 0;
513                                 }
514                         }
515                 } else if (newPath == null) {
516                         return IJavaElementDelta.F_SOURCEDETACHED;
517                 } else if (!oldPath.equals(newPath)) {
518                         return IJavaElementDelta.F_SOURCEATTACHED | IJavaElementDelta.F_SOURCEDETACHED;
519                 } else {
520                         return 0;
521                 }
522         }
523
524         /**
525          * Returns <code>true</code> if this operation performs no resource modifications,
526          * otherwise <code>false</code>. Subclasses must override.
527          */
528         public boolean isReadOnly() {
529                 return !this.canChangeResource;
530         }
531
532         protected void saveClasspathIfNecessary() throws JavaModelException {
533                 
534                 if (!this.canChangeResource || !this.needSave) return;
535                                 
536                 IClasspathEntry[] classpathForSave;
537                 JavaProject project = getProject();
538                 if (this.newRawPath == ReuseClasspath || this.newRawPath == UpdateClasspath){
539                         classpathForSave = project.getRawClasspath();
540                 } else {
541                         classpathForSave = this.newRawPath;
542                 }
543                 IPath outputLocationForSave;
544                 if (this.newOutputLocation == ReuseOutputLocation){
545                         outputLocationForSave = project.getOutputLocation();
546                 } else {
547                         outputLocationForSave = this.newOutputLocation;
548                 }
549                 // if read-only .classpath, then the classpath setting will never been performed completely
550                 if (project.saveClasspath(classpathForSave, outputLocationForSave)) {
551                         this.setAttribute(HAS_MODIFIED_RESOURCE_ATTR, TRUE); 
552                 }
553         }
554         
555         public String toString(){
556                 StringBuffer buffer = new StringBuffer(20);
557                 buffer.append("SetClasspathOperation\n"); //$NON-NLS-1$
558                 buffer.append(" - classpath : "); //$NON-NLS-1$
559                 if (this.newRawPath == ReuseClasspath){
560                         buffer.append("<Reuse Existing Classpath>"); //$NON-NLS-1$
561                 } else {
562                         buffer.append("{"); //$NON-NLS-1$
563                         for (int i = 0; i < this.newRawPath.length; i++) {
564                                 if (i > 0) buffer.append(","); //$NON-NLS-1$
565                                 IClasspathEntry element = this.newRawPath[i];
566                                 buffer.append(" ").append(element.toString()); //$NON-NLS-1$
567                         }
568                 }
569                 buffer.append("\n - output location : ");  //$NON-NLS-1$
570                 if (this.newOutputLocation == ReuseOutputLocation){
571                         buffer.append("<Reuse Existing Output Location>"); //$NON-NLS-1$
572                 } else {
573                         buffer.append(this.newOutputLocation.toString()); //$NON-NLS-1$
574                 }
575                 return buffer.toString();
576         }
577
578         private void updateClasspath() throws JavaModelException {
579
580                 JavaProject project = ((JavaProject) getElementsToProcess()[0]);
581
582                 beginTask(Util.bind("classpath.settingProgress", project.getElementName()), 2); //$NON-NLS-1$
583
584                 // SIDE-EFFECT: from thereon, the classpath got modified
585                 project.setRawClasspath0(this.newRawPath);
586
587                 // resolve new path (asking for marker creation if problems)
588                 if (this.newResolvedPath == null) {
589                         this.newResolvedPath = project.getResolvedClasspath(true, this.canChangeResource);
590                 }
591                 
592 //              if (this.oldResolvedPath != null) {
593 //                      generateClasspathChangeDeltas(
594 //                              this.oldResolvedPath,
595 //                              this.newResolvedPath,
596 //                              project);
597 //              } else {
598                         this.needCycleCheck = true;
599                         updateAffectedProjects(project.getProject().getFullPath());
600 //              }
601                 
602                 updateCycleMarkersIfNecessary(newResolvedPath);
603         }
604
605         /**
606          * Update projects which are affected by this classpath change:
607          * those which refers to the current project as source
608          */
609         protected void updateAffectedProjects(IPath prerequisiteProjectPath) {
610
611                 try {
612                         IJavaModel model = JavaModelManager.getJavaModelManager().getJavaModel();
613                         IJavaProject originatingProject = getProject();
614                         IJavaProject[] projects = model.getJavaProjects();
615                         for (int i = 0, projectCount = projects.length; i < projectCount; i++) {
616                                 try {
617                                         JavaProject project = (JavaProject) projects[i];
618                                         if (project.equals(originatingProject)) continue; // skip itself
619                                         
620                                         // consider ALL dependents (even indirect ones), since they may need to
621                                         // flush their respective namelookup caches (all pkg fragment roots).
622
623                                         IClasspathEntry[] classpath = project.getExpandedClasspath(true);
624                                         for (int j = 0, entryCount = classpath.length; j < entryCount; j++) {
625                                                 IClasspathEntry entry = classpath[j];
626                                                 if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT
627                                                         && entry.getPath().equals(prerequisiteProjectPath)) {
628                                                         project.setRawClasspath(
629                                                                 UpdateClasspath, 
630                                                                 SetClasspathOperation.ReuseOutputLocation, 
631                                                                 this.fMonitor, 
632                                                                 this.canChangeResource,  
633                                                                 project.getResolvedClasspath(true), 
634                                                                 false, // updating only - no validation
635                                                                 false); // updating only - no need to save
636                                                         break;
637                                                 }
638                                         }
639                                 } catch (JavaModelException e) {
640                                 }
641                         }
642                 } catch (JavaModelException e) {
643                 }
644                 
645         }
646
647         /**
648          * Update cycle markers
649          */
650         protected void updateCycleMarkersIfNecessary(IClasspathEntry[] newResolvedPath) {
651
652                 if (!this.needCycleCheck) return;
653                 if (!this.canChangeResource) return;
654                  
655                 try {
656                         JavaProject project = getProject();
657                         if (!project.hasCycleMarker() && !project.hasClasspathCycle(project.getResolvedClasspath(true))){
658                                 return;
659                         }
660                 
661                         postAction(
662                                 new IPostAction() {
663                                         public String getID() {
664                                                 return "updateCycleMarkers";  //$NON-NLS-1$
665                                         }
666                                         public void run() throws JavaModelException {
667                                                 JavaProject.updateAllCycleMarkers();
668                                         }
669                                 },
670                                 REMOVEALL_APPEND);
671                 } catch(JavaModelException e){
672                 }
673         }
674
675         /**
676          * Sets the output location of the pre-specified project.
677          *
678          * <p>This can cause changes in package fragments, in case either  the
679          * old or new output location folder are considered as a package fragment.
680          */
681         protected void updateOutputLocation() throws JavaModelException {
682                 
683                 JavaProject project= ((JavaProject) getElementsToProcess()[0]);
684
685                 beginTask(Util.bind("classpath.settingOutputLocationProgress", project.getElementName()), 2); //$NON-NLS-1$
686                 
687                 IPath oldLocation= project.getOutputLocation();
688         
689                 // see if this will cause any package fragments to be added
690                 boolean deltaToFire= false;
691                 JavaElementDelta delta = newJavaElementDelta();
692 //              ArrayList added= determineAffectedPackageFragments(oldLocation);
693 //              Iterator iter = added.iterator();
694 //              while (iter.hasNext()){
695 //                      IPackageFragment frag= (IPackageFragment)iter.next();
696 //                      ((IPackageFragmentRoot)frag.getParent()).close();
697 //                      if (!Util.isExcluded(frag)) {
698 //                              delta.added(frag);
699 //                              deltaToFire = true;
700 //                      }
701 //              }
702         
703                 // see if this will cause any package fragments to be removed
704 //              ArrayList removed= determineAffectedPackageFragments(this.newOutputLocation);
705 //              iter = removed.iterator();
706 //              while (iter.hasNext()){
707 //                      IPackageFragment frag= (IPackageFragment)iter.next();
708 //                      ((IPackageFragmentRoot)frag.getParent()).close(); 
709 //                      if (!Util.isExcluded(frag)) {
710 //                              delta.removed(frag);
711 //                              deltaToFire = true;
712 //                      }
713 //              }
714
715                 JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project.getProject());
716                 synchronized (perProjectInfo) {
717                         perProjectInfo.outputLocation = this.newOutputLocation;
718                 }
719                                 
720                 if (deltaToFire) {
721                         addDelta(delta);        
722                 }
723                 worked(1);
724         }
725         
726         /**
727          * Update projects references so that the build order is consistent with the classpath
728          */
729         protected void updateProjectReferencesIfNecessary() throws JavaModelException {
730                 
731                 if (!this.canChangeResource) return;
732                 if (this.newRawPath == ReuseClasspath || this.newRawPath == UpdateClasspath) return;
733         
734                 JavaProject jproject = getProject();
735                 String[] oldRequired = jproject.projectPrerequisites(this.oldResolvedPath);
736
737                 if (this.newResolvedPath == null) {
738                         this.newResolvedPath = jproject.getResolvedClasspath(this.newRawPath, null, true, this.needValidation, null /*no reverse map*/);
739                 }
740                 String[] newRequired = jproject.projectPrerequisites(this.newResolvedPath);
741         
742                 try {           
743                         IProject project = jproject.getProject();
744                         IProjectDescription description = project.getDescription();
745                          
746                         IProject[] projectReferences = description.getReferencedProjects();
747                         
748                         HashSet oldReferences = new HashSet(projectReferences.length);
749                         for (int i = 0; i < projectReferences.length; i++){
750                                 String projectName = projectReferences[i].getName();
751                                 oldReferences.add(projectName);
752                         }
753                         HashSet newReferences = (HashSet)oldReferences.clone();
754         
755                         for (int i = 0; i < oldRequired.length; i++){
756                                 String projectName = oldRequired[i];
757                                 newReferences.remove(projectName);
758                         }
759                         for (int i = 0; i < newRequired.length; i++){
760                                 String projectName = newRequired[i];
761                                 newReferences.add(projectName);
762                         }
763         
764                         Iterator iter;
765                         int newSize = newReferences.size();
766                         
767                         checkIdentity: {
768                                 if (oldReferences.size() == newSize){
769                                         iter = newReferences.iterator();
770                                         while (iter.hasNext()){
771                                                 if (!oldReferences.contains(iter.next())){
772                                                         break checkIdentity;
773                                                 }
774                                         }
775                                         return;
776                                 }
777                         }
778                         String[] requiredProjectNames = new String[newSize];
779                         int index = 0;
780                         iter = newReferences.iterator();
781                         while (iter.hasNext()){
782                                 requiredProjectNames[index++] = (String)iter.next();
783                         }
784                         Util.sort(requiredProjectNames); // ensure that if changed, the order is consistent
785                         
786                         IProject[] requiredProjectArray = new IProject[newSize];
787                         IWorkspaceRoot wksRoot = project.getWorkspace().getRoot();
788                         for (int i = 0; i < newSize; i++){
789                                 requiredProjectArray[i] = wksRoot.getProject(requiredProjectNames[i]);
790                         }
791         
792                         description.setReferencedProjects(requiredProjectArray);
793                         project.setDescription(description, this.fMonitor);
794         
795                 } catch(CoreException e){
796                         throw new JavaModelException(e);
797                 }
798         }
799
800         public IJavaModelStatus verify() {
801
802                 IJavaModelStatus status = super.verify();
803                 if (!status.isOK()) {
804                         return status;
805                 }
806
807                 if (needValidation) {
808                         IJavaProject project = (IJavaProject) getElementToProcess();
809                         // retrieve classpath 
810                         IClasspathEntry[] entries = this.newRawPath;
811                         if (entries == ReuseClasspath){
812                                 try {
813                                         entries = project.getRawClasspath();                    
814                                 } catch (JavaModelException e) {
815                                         return e.getJavaModelStatus();
816                                 }
817                         }               
818                         // retrieve output location
819                         IPath outputLocation = this.newOutputLocation;
820                         if (outputLocation == ReuseOutputLocation){
821                                 try {
822                                         outputLocation = project.getOutputLocation();
823                                 } catch (JavaModelException e) {
824                                         return e.getJavaModelStatus();
825                                 }
826                         }
827                                         
828                         // perform validation
829 //                      return JavaConventions.validateClasspath(
830 //                              project,
831 //                              entries,
832 //                              outputLocation);
833                 }
834                 
835                 return JavaModelStatus.VERIFIED_OK;
836         }
837 }