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