net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/JavaModelManager.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.BufferedInputStream;
  14 import java.io.BufferedOutputStream;
  15 import java.io.DataInputStream;
  16 import java.io.DataOutputStream;
  17 import java.io.File;
  18 import java.io.FileInputStream;
  19 import java.io.FileOutputStream;
  20 import java.io.IOException;
  21 import java.text.NumberFormat;
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.HashMap;
  25 import java.util.HashSet;
  26 import java.util.Iterator;
  27 import java.util.Map;
  28 import java.util.WeakHashMap;
  29 import java.util.zip.ZipFile;
  30
  31 import net.sourceforge.phpdt.core.ElementChangedEvent;
  32 import net.sourceforge.phpdt.core.IClasspathEntry;
  33 import net.sourceforge.phpdt.core.ICompilationUnit;
  34 import net.sourceforge.phpdt.core.IElementChangedListener;
  35 import net.sourceforge.phpdt.core.IJavaElement;
  36 import net.sourceforge.phpdt.core.IJavaElementDelta;
  37 import net.sourceforge.phpdt.core.IJavaModel;
  38 import net.sourceforge.phpdt.core.IJavaProject;
  39 import net.sourceforge.phpdt.core.IPackageFragment;
  40 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
  41 import net.sourceforge.phpdt.core.IWorkingCopy;
  42 import net.sourceforge.phpdt.core.JavaModelException;
  43 import net.sourceforge.phpdt.core.JavaCore;
  44 import net.sourceforge.phpdt.internal.ui.util.PHPFileUtil;
  45 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  46 import net.sourceforge.phpdt.internal.core.builder.PHPBuilder;
  47 import net.sourceforge.phpdt.internal.core.util.Util;
  48
  49 import org.eclipse.core.resources.IFile;
  50 import org.eclipse.core.resources.IFolder;
  51 import org.eclipse.core.resources.IProject;
  52 import org.eclipse.core.resources.IResource;
  53 import org.eclipse.core.resources.IResourceDelta;
  54 import org.eclipse.core.resources.ISaveContext;
  55 import org.eclipse.core.resources.ISaveParticipant;
  56 import org.eclipse.core.resources.IWorkspace;
  57 import org.eclipse.core.resources.IWorkspaceDescription;
  58 import org.eclipse.core.resources.IWorkspaceRoot;
  59 import org.eclipse.core.resources.ResourcesPlugin;
  60 import org.eclipse.core.runtime.CoreException;
  61 import org.eclipse.core.runtime.IPath;
  62 import org.eclipse.core.runtime.IPluginDescriptor;
  63 import org.eclipse.core.runtime.IProgressMonitor;
  64 import org.eclipse.core.runtime.ISafeRunnable;
  65 import org.eclipse.core.runtime.IStatus;
  66 import org.eclipse.core.runtime.MultiStatus;
  67 import org.eclipse.core.runtime.Path;
  68 import org.eclipse.core.runtime.Platform;
  69 import org.eclipse.core.runtime.Plugin;
  70 import org.eclipse.core.runtime.Preferences;
  71 import org.eclipse.core.runtime.Status;
  72 import net.sourceforge.phpdt.internal.core.BufferManager;
  73
  74 import net.sourceforge.phpdt.internal.core.DefaultWorkingCopyOwner;
  75
  76 import net.sourceforge.phpdt.internal.core.DeltaProcessingState;
  77
  78 import net.sourceforge.phpdt.internal.core.DeltaProcessor;
  79
  80 import net.sourceforge.phpdt.core.IParent;
  81 import net.sourceforge.phpdt.internal.core.JavaElementInfo;
  82
  83 import net.sourceforge.phpdt.core.IProblemRequestor;
  84 import net.sourceforge.phpdt.core.WorkingCopyOwner;
  85 import net.sourceforge.phpdt.core.compiler.IProblem;
  86 import net.sourceforge.phpdt.internal.core.CompilationUnit;
  87 import net.sourceforge.phpdt.internal.core.JavaElement;
  88 import net.sourceforge.phpdt.internal.core.JavaElementDeltaBuilder;
  89 import net.sourceforge.phpdt.internal.core.JavaModelManager.PerWorkingCopyInfo;
  90
  91 /**
  92  * The <code>JavaModelManager</code> manages instances of <code>IJavaModel</code>.
  93  * <code>IElementChangedListener</code>s register with the <code>JavaModelManager</code>,
  94  * and receive <code>ElementChangedEvent</code>s for all <code>IJavaModel</code>s.
  95  * <p>
  96  * The single instance of <code>JavaModelManager</code> is available from
  97  * the static method <code>JavaModelManager.getJavaModelManager()</code>.
  98  */
  99 public class JavaModelManager implements ISaveParticipant {
 100
 101         /**
 102          * Unique handle onto the JavaModel
 103          */
 104         final JavaModel javaModel = new JavaModel();
 105
 106         /**
 107          * Classpath variables pool
 108          */
 109         public static HashMap Variables = new HashMap(5);
 110         public static HashMap PreviousSessionVariables = new HashMap(5);
 111         public static HashSet OptionNames = new HashSet(20);
 112         public final static String CP_VARIABLE_PREFERENCES_PREFIX = PHPeclipsePlugin.PLUGIN_ID+".classpathVariable."; //$NON-NLS-1$
 113 //      public final static String CP_CONTAINER_PREFERENCES_PREFIX = PHPCore.PLUGIN_ID+".classpathContainer."; //$NON-NLS-1$
 114         public final static String CP_ENTRY_IGNORE = "##<cp entry ignore>##"; //$NON-NLS-1$
 115
 116         /**
 117          * Classpath containers pool
 118          */
 119         public static HashMap Containers = new HashMap(5);
 120         public static HashMap PreviousSessionContainers = new HashMap(5);
 121
 122         /**
 123          * Name of the extension point for contributing classpath variable initializers
 124          */
 125 //      public static final String CPVARIABLE_INITIALIZER_EXTPOINT_ID = "classpathVariableInitializer" ; //$NON-NLS-1$
 126
 127         /**
 128          * Name of the extension point for contributing classpath container initializers
 129          */
 130 //      public static final String CPCONTAINER_INITIALIZER_EXTPOINT_ID = "classpathContainerInitializer" ; //$NON-NLS-1$
 131
 132         /**
 133          * Name of the extension point for contributing a source code formatter
 134          */
 135         public static final String FORMATTER_EXTPOINT_ID = "codeFormatter" ; //$NON-NLS-1$
 136
 137         /**
 138          * Special value used for recognizing ongoing initialization and breaking initialization cycles
 139          */
 140         public final static IPath VariableInitializationInProgress = new Path("Variable Initialization In Progress"); //$NON-NLS-1$
 141 //      public final static IClasspathContainer ContainerInitializationInProgress = new IClasspathContainer() {
 142 //              public IClasspathEntry[] getClasspathEntries() { return null; }
 143 //              public String getDescription() { return "Container Initialization In Progress"; } //$NON-NLS-1$
 144 //              public int getKind() { return 0; }
 145 //              public IPath getPath() { return null; }
 146 //              public String toString() { return getDescription(); }
 147 //      };
 148
 149         private static final String INDEX_MANAGER_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/indexmanager" ; //$NON-NLS-1$
 150         private static final String COMPILER_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/compiler" ; //$NON-NLS-1$
 151         private static final String JAVAMODEL_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/javamodel" ; //$NON-NLS-1$
 152         private static final String CP_RESOLVE_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/cpresolution" ; //$NON-NLS-1$
 153         private static final String ZIP_ACCESS_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/zipaccess" ; //$NON-NLS-1$
 154         private static final String DELTA_DEBUG =PHPeclipsePlugin.PLUGIN_ID + "/debug/javadelta" ; //$NON-NLS-1$
 155         private static final String HIERARCHY_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/hierarchy" ; //$NON-NLS-1$
 156         private static final String POST_ACTION_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/postaction" ; //$NON-NLS-1$
 157         private static final String BUILDER_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/builder" ; //$NON-NLS-1$
 158         private static final String COMPLETION_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/completion" ; //$NON-NLS-1$
 159         private static final String SELECTION_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/selection" ; //$NON-NLS-1$
 160         private static final String SHARED_WC_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/sharedworkingcopy" ; //$NON-NLS-1$
 161         private static final String SEARCH_DEBUG = PHPeclipsePlugin.PLUGIN_ID + "/debug/search" ; //$NON-NLS-1$
 162
 163         public final static IWorkingCopy[] NoWorkingCopy = new IWorkingCopy[0];
 164
 165         /**
 166          * Table from WorkingCopyOwner to a table of ICompilationUnit (working copy handle) to PerWorkingCopyInfo.
 167          * NOTE: this object itself is used as a lock to synchronize creation/removal of per working copy infos
 168          */
 169         protected Map perWorkingCopyInfos = new HashMap(5);
 170         /**
 171          * Returns whether the given full path (for a package) conflicts with the output location
 172          * of the given project.
 173          */
 174         public static boolean conflictsWithOutputLocation(IPath folderPath, JavaProject project) {
 175                 try {
 176                         IPath outputLocation = project.getOutputLocation();
 177                         if (outputLocation == null) {
 178                                 // in doubt, there is a conflict
 179                                 return true;
 180                         }
 181                         if (outputLocation.isPrefixOf(folderPath)) {
 182                                 // only allow nesting in project's output if there is a corresponding source folder
 183                                 // or if the project's output is not used (in other words, if all source folders have their custom output)
 184                                 IClasspathEntry[] classpath = project.getResolvedClasspath(true);
 185                                 boolean isOutputUsed = false;
 186                                 for (int i = 0, length = classpath.length; i < length; i++) {
 187                                         IClasspathEntry entry = classpath[i];
 188                                         if (entry.getEntryKind() == IClasspathEntry.CPE_SOURCE) {
 189                                                 if (entry.getPath().equals(outputLocation)) {
 190                                                         return false;
 191                                                 }
 192                                                 if (entry.getOutputLocation() == null) {
 193                                                         isOutputUsed = true;
 194                                                 }
 195                                         }
 196                                 }
 197                                 return isOutputUsed;
 198                         }
 199                         return false;
 200                 } catch (JavaModelException e) {
 201                         // in doubt, there is a conflict
 202                         return true;
 203                 }
 204         }
 205
 206 //      public static IClasspathContainer containerGet(IJavaProject project, IPath containerPath) {
 207 //              Map projectContainers = (Map)Containers.get(project);
 208 //              if (projectContainers == null){
 209 //                      return null;
 210 //              }
 211 //              IClasspathContainer container = (IClasspathContainer)projectContainers.get(containerPath);
 212 //              return container;
 213 //      }
 214
 215 //      public static void containerPut(IJavaProject project, IPath containerPath, IClasspathContainer container){
 216 //
 217 //              Map projectContainers = (Map)Containers.get(project);
 218 //              if (projectContainers == null){
 219 //                      projectContainers = new HashMap(1);
 220 //                      Containers.put(project, projectContainers);
 221 //              }
 222 //
 223 //              if (container == null) {
 224 //                      projectContainers.remove(containerPath);
 225 //                      Map previousContainers = (Map)PreviousSessionContainers.get(project);
 226 //                      if (previousContainers != null){
 227 //                              previousContainers.remove(containerPath);
 228 //                      }
 229 //              } else {
 230 //                      projectContainers.put(containerPath, container);
 231 //              }
 232 //
 233 //              // do not write out intermediate initialization value
 234 //              if (container == JavaModelManager.ContainerInitializationInProgress) {
 235 //                      return;
 236 //              }
 237 //              Preferences preferences = PHPeclipsePlugin.getPlugin().getPluginPreferences();
 238 //              String containerKey = CP_CONTAINER_PREFERENCES_PREFIX+project.getElementName() +"|"+containerPath;//$NON-NLS-1$
 239 //              String containerString = CP_ENTRY_IGNORE;
 240 //              try {
 241 //                      if (container != null) {
 242 //                              containerString = ((JavaProject)project).encodeClasspath(container.getClasspathEntries(), null, false);
 243 //                      }
 244 //              } catch(JavaModelException e){
 245 //              }
 246 //              preferences.setDefault(containerKey, CP_ENTRY_IGNORE); // use this default to get rid of removed ones
 247 //              preferences.setValue(containerKey, containerString);
 248 //              PHPeclipsePlugin.getPlugin().savePluginPreferences();
 249 //      }
 250
 251         /**
 252          * Returns the Java element corresponding to the given resource, or
 253          * <code>null</code> if unable to associate the given resource
 254          * with a Java element.
 255          * <p>
 256          * The resource must be one of:<ul>
 257          *      <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
 258          *      <li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>
 259          *      <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
 260          *      <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
 261          *  <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
 262          *                      or <code>IPackageFragment</code></li>
 263          *  <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
 264          *      </ul>
 265          * <p>
 266          * Creating a Java element has the side effect of creating and opening all of the
 267          * element's parents if they are not yet open.
 268          */
 269         public static IJavaElement create(IResource resource, IJavaProject project) {
 270                 if (resource == null) {
 271                         return null;
 272                 }
 273                 int type = resource.getType();
 274                 switch (type) {
 275                         case IResource.PROJECT :
 276                                 return JavaCore.create((IProject) resource);
 277                         case IResource.FILE :
 278                                 return create((IFile) resource, project);
 279                         case IResource.FOLDER :
 280                                 return create((IFolder) resource, project);
 281                         case IResource.ROOT :
 282                                 return JavaCore.create((IWorkspaceRoot) resource);
 283                         default :
 284                                 return null;
 285                 }
 286         }
 287
 288         /**
 289          * Returns the Java element corresponding to the given file, its project being the given
 290          * project.
 291          * Returns <code>null</code> if unable to associate the given file
 292          * with a Java element.
 293          *
 294          * <p>The file must be one of:<ul>
 295          *      <li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>
 296          *      <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
 297          *      <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
 298          *      </ul>
 299          * <p>
 300          * Creating a Java element has the side effect of creating and opening all of the
 301          * element's parents if they are not yet open.
 302          */
 303         public static IJavaElement create(IFile file, IJavaProject project) {
 304                 if (file == null) {
 305                         return null;
 306                 }
 307                 if (project == null) {
 308                         project = JavaCore.create(file.getProject());
 309                 }
 310
 311                 if (file.getFileExtension() != null) {
 312                         String name = file.getName();
 313 //                      if (Util.isValidCompilationUnitName(name))
 314                         if (PHPFileUtil.isPHPFile(file))
 315                                 return createCompilationUnitFrom(file, project);
 316 //                      if (Util.isValidClassFileName(name))
 317 //                              return createClassFileFrom(file, project);
 318 //                      if (Util.isArchiveFileName(name))
 319 //                              return createJarPackageFragmentRootFrom(file, project);
 320                 }
 321                 return null;
 322         }
 323
 324         /**
 325          * Returns the package fragment or package fragment root corresponding to the given folder,
 326          * its parent or great parent being the given project.
 327          * or <code>null</code> if unable to associate the given folder with a Java element.
 328          * <p>
 329          * Note that a package fragment root is returned rather than a default package.
 330          * <p>
 331          * Creating a Java element has the side effect of creating and opening all of the
 332          * element's parents if they are not yet open.
 333          */
 334         public static IJavaElement create(IFolder folder, IJavaProject project) {
 335                 if (folder == null) {
 336                         return null;
 337                 }
 338                 if (project == null) {
 339                         project = JavaCore.create(folder.getProject());
 340                 }
 341                 IJavaElement element = determineIfOnClasspath(folder, project);
 342                 if (conflictsWithOutputLocation(folder.getFullPath(), (JavaProject)project)
 343                         || (folder.getName().indexOf('.') >= 0
 344                                 && !(element instanceof IPackageFragmentRoot))) {
 345                         return null; // only package fragment roots are allowed with dot names
 346                 } else {
 347                         return element;
 348                 }
 349         }
 350
 351         /**
 352          * Creates and returns a class file element for the given <code>.class</code> file,
 353          * its project being the given project. Returns <code>null</code> if unable
 354          * to recognize the class file.
 355          */
 356 //      public static IClassFile createClassFileFrom(IFile file, IJavaProject project ) {
 357 //              if (file == null) {
 358 //                      return null;
 359 //              }
 360 //              if (project == null) {
 361 //                      project = PHPCore.create(file.getProject());
 362 //              }
 363 //              IPackageFragment pkg = (IPackageFragment) determineIfOnClasspath(file, project);
 364 //              if (pkg == null) {
 365 //                      // fix for 1FVS7WE
 366 //                      // not on classpath - make the root its folder, and a default package
 367 //                      IPackageFragmentRoot root = project.getPackageFragmentRoot(file.getParent());
 368 //                      pkg = root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
 369 //              }
 370 //              return pkg.getClassFile(file.getName());
 371 //      }
 372
 373         /**
 374          * Creates and returns a compilation unit element for the given <code>.java</code>
 375          * file, its project being the given project. Returns <code>null</code> if unable
 376          * to recognize the compilation unit.
 377          */
 378         public static ICompilationUnit createCompilationUnitFrom(IFile file, IJavaProject project) {
 379
 380                 if (file == null) return null;
 381
 382                 if (project == null) {
 383                         project = JavaCore.create(file.getProject());
 384                 }
 385                 IPackageFragment pkg = (IPackageFragment) determineIfOnClasspath(file, project);
 386                 if (pkg == null) {
 387                         // not on classpath - make the root its folder, and a default package
 388                         IPackageFragmentRoot root = project.getPackageFragmentRoot(file.getParent());
 389                         pkg = root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
 390
 391                         if (VERBOSE){
 392                                 System.out.println("WARNING : creating unit element outside classpath ("+ Thread.currentThread()+"): " + file.getFullPath()); //$NON-NLS-1$//$NON-NLS-2$
 393                         }
 394                 }
 395                 return pkg.getCompilationUnit(file.getName());
 396         }
 397         /**
 398          * Creates and returns a handle for the given JAR file, its project being the given project.
 399          * The Java model associated with the JAR's project may be
 400          * created as a side effect.
 401          * Returns <code>null</code> if unable to create a JAR package fragment root.
 402          * (for example, if the JAR file represents a non-Java resource)
 403          */
 404 //      public static IPackageFragmentRoot createJarPackageFragmentRootFrom(IFile file, IJavaProject project) {
 405 //              if (file == null) {
 406 //                      return null;
 407 //              }
 408 //              if (project == null) {
 409 //                      project = PHPCore.create(file.getProject());
 410 //              }
 411 //
 412 //              // Create a jar package fragment root only if on the classpath
 413 //              IPath resourcePath = file.getFullPath();
 414 //              try {
 415 //                      IClasspathEntry[] entries = ((JavaProject)project).getResolvedClasspath(true);
 416 //                      for (int i = 0, length = entries.length; i < length; i++) {
 417 //                              IClasspathEntry entry = entries[i];
 418 //                              IPath rootPath = entry.getPath();
 419 //                              if (rootPath.equals(resourcePath)) {
 420 //                                      return project.getPackageFragmentRoot(file);
 421 //                              }
 422 //                      }
 423 //              } catch (JavaModelException e) {
 424 //              }
 425 //              return null;
 426 //      }
 427
 428         /**
 429          * Returns the package fragment root represented by the resource, or
 430          * the package fragment the given resource is located in, or <code>null</code>
 431          * if the given resource is not on the classpath of the given project.
 432          */
 433         public static IJavaElement determineIfOnClasspath(
 434                 IResource resource,
 435                 IJavaProject project) {
 436
 437                 IPath resourcePath = resource.getFullPath();
 438                 try {
 439                         IClasspathEntry[] entries =
 440                                 net.sourceforge.phpdt.internal.compiler.util.Util.isJavaFileName(resourcePath.lastSegment())
 441                                         ? project.getRawClasspath() // JAVA file can only live inside SRC folder (on the raw path)
 442                                         : ((JavaProject)project).getResolvedClasspath(true);
 443
 444                         for (int i = 0; i < entries.length; i++) {
 445                                 IClasspathEntry entry = entries[i];
 446                                 if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) continue;
 447                                 IPath rootPath = entry.getPath();
 448                                 if (rootPath.equals(resourcePath)) {
 449                                         return project.getPackageFragmentRoot(resource);
 450                                 } else if (rootPath.isPrefixOf(resourcePath) && !Util.isExcluded(resource, ((ClasspathEntry)entry).fullExclusionPatternChars())) {
 451                                         // given we have a resource child of the root, it cannot be a JAR pkg root
 452                                         IPackageFragmentRoot root = ((JavaProject) project).getFolderPackageFragmentRoot(rootPath);
 453                                         if (root == null) return null;
 454                                         IPath pkgPath = resourcePath.removeFirstSegments(rootPath.segmentCount());
 455                                         if (resource.getType() == IResource.FILE) {
 456                                                 // if the resource is a file, then remove the last segment which
 457                                                 // is the file name in the package
 458                                                 pkgPath = pkgPath.removeLastSegments(1);
 459
 460                                                 // don't check validity of package name (see http://bugs.eclipse.org/bugs/show_bug.cgi?id=26706)
 461                                                 String pkgName = pkgPath.toString().replace('/', '.');
 462                                                 return root.getPackageFragment(pkgName);
 463                                         } else {
 464                                                 String pkgName = Util.packageName(pkgPath);
 465                                                 if (pkgName == null){// || JavaConventions.validatePackageName(pkgName).getSeverity() == IStatus.ERROR) {
 466                                                         return null;
 467                                                 }
 468                                                 return root.getPackageFragment(pkgName);
 469                                         }
 470                                 }
 471                         }
 472                 } catch (JavaModelException npe) {
 473                         return null;
 474                 }
 475                 return null;
 476         }
 477
 478         /**
 479          * The singleton manager
 480          */
 481         private final static JavaModelManager Manager= new JavaModelManager();
 482
 483         /**
 484          * Infos cache.
 485          */
 486         protected JavaModelCache cache = new JavaModelCache();
 487
 488         /*
 489          * Temporary cache of newly opened elements
 490          */
 491         private ThreadLocal temporaryCache = new ThreadLocal();
 492         /**
 493          * Set of elements which are out of sync with their buffers.
 494          */
 495         protected Map elementsOutOfSynchWithBuffers = new HashMap(11);
 496         /**
 497          * Holds the state used for delta processing.
 498          */
 499         public DeltaProcessingState deltaState = new DeltaProcessingState();
 500         /**
 501          * Turns delta firing on/off. By default it is on.
 502          */
 503         private boolean isFiring= true;
 504
 505         /**
 506          * Queue of deltas created explicily by the Java Model that
 507          * have yet to be fired.
 508          */
 509         ArrayList javaModelDeltas= new ArrayList();
 510         /**
 511          * Queue of reconcile deltas on working copies that have yet to be fired.
 512          * This is a table form IWorkingCopy to IJavaElementDelta
 513          */
 514         HashMap reconcileDeltas = new HashMap();
 515
 516
 517         /**
 518          * Collection of listeners for Java element deltas
 519          */
 520         private IElementChangedListener[] elementChangedListeners = new IElementChangedListener[5];
 521         private int[] elementChangedListenerMasks = new int[5];
 522         private int elementChangedListenerCount = 0;
 523         public int currentChangeEventType = ElementChangedEvent.PRE_AUTO_BUILD;
 524         public static final int DEFAULT_CHANGE_EVENT = 0; // must not collide with ElementChangedEvent event masks
 525
 526
 527
 528         /**
 529          * Used to convert <code>IResourceDelta</code>s into <code>IJavaElementDelta</code>s.
 530          */
 531 //      public final DeltaProcessor deltaProcessor = new DeltaProcessor(this);
 532         /**
 533          * Used to update the JavaModel for <code>IJavaElementDelta</code>s.
 534          */
 535 //      private final ModelUpdater modelUpdater =new ModelUpdater();
 536         /**
 537          * Workaround for bug 15168 circular errors not reported
 538          * This is a cache of the projects before any project addition/deletion has started.
 539          */
 540         public IJavaProject[] javaProjectsCache;
 541
 542         /**
 543          * Table from IProject to PerProjectInfo.
 544          * NOTE: this object itself is used as a lock to synchronize creation/removal of per project infos
 545          */
 546         protected Map perProjectInfo = new HashMap(5);
 547
 548         /**
 549          * A map from ICompilationUnit to IWorkingCopy
 550          * of the shared working copies.
 551          */
 552         public Map sharedWorkingCopies = new HashMap();
 553
 554         /**
 555          * A weak set of the known scopes.
 556          */
 557         protected WeakHashMap scopes = new WeakHashMap();
 558
 559         public static class PerProjectInfo {
 560                 public IProject project;
 561                 public Object savedState;
 562                 public boolean triedRead;
 563                 public IClasspathEntry[] classpath;
 564                 public IClasspathEntry[] lastResolvedClasspath;
 565                 public Map resolvedPathToRawEntries; // reverse map from resolved path to raw entries
 566                 public IPath outputLocation;
 567                 public Preferences preferences;
 568                 public PerProjectInfo(IProject project) {
 569
 570                         this.triedRead = false;
 571                         this.savedState = null;
 572                         this.project = project;
 573                 }
 574         }
 575         public static class PerWorkingCopyInfo implements IProblemRequestor {
 576                 int useCount = 0;
 577                 IProblemRequestor problemRequestor;
 578                 ICompilationUnit workingCopy;
 579                 public PerWorkingCopyInfo(ICompilationUnit workingCopy, IProblemRequestor problemRequestor) {
 580                         this.workingCopy = workingCopy;
 581                         this.problemRequestor = problemRequestor;
 582                 }
 583                 public void acceptProblem(IProblem problem) {
 584                         if (this.problemRequestor == null) return;
 585                         this.problemRequestor.acceptProblem(problem);
 586                 }
 587                 public void beginReporting() {
 588                         if (this.problemRequestor == null) return;
 589                         this.problemRequestor.beginReporting();
 590                 }
 591                 public void endReporting() {
 592                         if (this.problemRequestor == null) return;
 593                         this.problemRequestor.endReporting();
 594                 }
 595                 public ICompilationUnit getWorkingCopy() {
 596                         return this.workingCopy;
 597                 }
 598                 public boolean isActive() {
 599                         return this.problemRequestor != null && this.problemRequestor.isActive();
 600                 }
 601                 public String toString() {
 602                         StringBuffer buffer = new StringBuffer();
 603                         buffer.append("Info for "); //$NON-NLS-1$
 604                         buffer.append(((JavaElement)workingCopy).toStringWithAncestors());
 605                         buffer.append("\nUse count = "); //$NON-NLS-1$
 606                         buffer.append(this.useCount);
 607                         buffer.append("\nProblem requestor:\n  "); //$NON-NLS-1$
 608                         buffer.append(this.problemRequestor);
 609                         return buffer.toString();
 610                 }
 611         }
 612         public static boolean VERBOSE = true;
 613         public static boolean CP_RESOLVE_VERBOSE = false;
 614         public static boolean ZIP_ACCESS_VERBOSE = false;
 615
 616         /**
 617          * A cache of opened zip files per thread.
 618          * (map from Thread to map of IPath to java.io.ZipFile)
 619          * NOTE: this object itself is used as a lock to synchronize creation/removal of entries
 620          */
 621         private HashMap zipFiles = new HashMap();
 622
 623
 624         /**
 625          * Update the classpath variable cache
 626          */
 627         public static class PluginPreferencesListener implements Preferences.IPropertyChangeListener {
 628                 /**
 629                  * @see org.eclipse.core.runtime.Preferences.IPropertyChangeListener#propertyChange(PropertyChangeEvent)
 630                  */
 631                 public void propertyChange(Preferences.PropertyChangeEvent event) {
 632
 633                         String propertyName = event.getProperty();
 634                         if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {
 635                                 String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());
 636                                 String newValue = (String)event.getNewValue();
 637                                 if (newValue != null && !(newValue = newValue.trim()).equals(CP_ENTRY_IGNORE)) {
 638                                         Variables.put(varName, new Path(newValue));
 639                                 } else {
 640                                         Variables.remove(varName);
 641                                 }
 642                         }
 643 //              TODO jsurfer temp-del
 644 //                      if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)) {
 645 //                              recreatePersistedContainer(propertyName, (String)event.getNewValue(), false);
 646 //                      }
 647                 }
 648         }
 649
 650         /**
 651          * Line separator to use throughout the JavaModel for any source edit operation
 652          */
 653   public static String LINE_SEPARATOR = System.getProperty("line.separator"); //$NON-NLS-1$
 654         /**
 655          * Constructs a new JavaModelManager
 656          */
 657         private JavaModelManager() {
 658         }
 659
 660         /**
 661          * @deprecated - discard once debug has converted to not using it
 662          */
 663         public void addElementChangedListener(IElementChangedListener listener) {
 664                 this.addElementChangedListener(listener, ElementChangedEvent.POST_CHANGE | ElementChangedEvent.POST_RECONCILE);
 665         }
 666         /**
 667          * addElementChangedListener method comment.
 668          * Need to clone defensively the listener information, in case some listener is reacting to some notification iteration by adding/changing/removing
 669          * any of the other (for example, if it deregisters itself).
 670          */
 671         public void addElementChangedListener(IElementChangedListener listener, int eventMask) {
 672                 for (int i = 0; i < this.elementChangedListenerCount; i++){
 673                         if (this.elementChangedListeners[i].equals(listener)){
 674
 675                                 // only clone the masks, since we could be in the middle of notifications and one listener decide to change
 676                                 // any event mask of another listeners (yet not notified).
 677                                 int cloneLength = this.elementChangedListenerMasks.length;
 678                                 System.arraycopy(this.elementChangedListenerMasks, 0, this.elementChangedListenerMasks = new int[cloneLength], 0, cloneLength);
 679                                 this.elementChangedListenerMasks[i] = eventMask; // could be different
 680                                 return;
 681                         }
 682                 }
 683                 // may need to grow, no need to clone, since iterators will have cached original arrays and max boundary and we only add to the end.
 684                 int length;
 685                 if ((length = this.elementChangedListeners.length) == this.elementChangedListenerCount){
 686                         System.arraycopy(this.elementChangedListeners, 0, this.elementChangedListeners = new IElementChangedListener[length*2], 0, length);
 687                         System.arraycopy(this.elementChangedListenerMasks, 0, this.elementChangedListenerMasks = new int[length*2], 0, length);
 688                 }
 689                 this.elementChangedListeners[this.elementChangedListenerCount] = listener;
 690                 this.elementChangedListenerMasks[this.elementChangedListenerCount] = eventMask;
 691                 this.elementChangedListenerCount++;
 692         }
 693
 694         /**
 695          * Starts caching ZipFiles.
 696          * Ignores if there are already clients.
 697          */
 698         public void cacheZipFiles() {
 699                 synchronized(this.zipFiles) {
 700                         Thread currentThread = Thread.currentThread();
 701                         if (this.zipFiles.get(currentThread) != null) return;
 702                         this.zipFiles.put(currentThread, new HashMap());
 703                 }
 704         }
 705         public void closeZipFile(ZipFile zipFile) {
 706                 if (zipFile == null) return;
 707                 synchronized(this.zipFiles) {
 708                         if (this.zipFiles.get(Thread.currentThread()) != null) {
 709                                 return; // zip file will be closed by call to flushZipFiles
 710                         }
 711                         try {
 712                                 if (JavaModelManager.ZIP_ACCESS_VERBOSE) {
 713                                         System.out.println("(" + Thread.currentThread() + ") [JavaModelManager.closeZipFile(ZipFile)] Closing ZipFile on " +zipFile.getName()); //$NON-NLS-1$   //$NON-NLS-2$
 714                                 }
 715                                 zipFile.close();
 716                         } catch (IOException e) {
 717                         }
 718                 }
 719         }
 720
 721
 722
 723         /**
 724          * Configure the plugin with respect to option settings defined in ".options" file
 725          */
 726         public void configurePluginDebugOptions(){
 727                 if(JavaCore.getPlugin().isDebugging()){
 728 //              TODO jsurfer temp-del
 729
 730                         String option = Platform.getDebugOption(BUILDER_DEBUG);
 731 //                      if(option != null) JavaBuilder.DEBUG = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 732 //
 733 //                      option = Platform.getDebugOption(COMPILER_DEBUG);
 734 //                      if(option != null) Compiler.DEBUG = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 735 //
 736 //                      option = Platform.getDebugOption(COMPLETION_DEBUG);
 737 //                      if(option != null) CompletionEngine.DEBUG = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 738 //
 739                         option = Platform.getDebugOption(CP_RESOLVE_DEBUG);
 740                         if(option != null) JavaModelManager.CP_RESOLVE_VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 741
 742                         option = Platform.getDebugOption(DELTA_DEBUG);
 743                         if(option != null) DeltaProcessor.VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 744
 745 //                      option = Platform.getDebugOption(HIERARCHY_DEBUG);
 746 //                      if(option != null) TypeHierarchy.DEBUG = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 747 //
 748 //                      option = Platform.getDebugOption(INDEX_MANAGER_DEBUG);
 749 //                      if(option != null) IndexManager.VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 750
 751                         option = Platform.getDebugOption(JAVAMODEL_DEBUG);
 752                         if(option != null) JavaModelManager.VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 753
 754                         option = Platform.getDebugOption(POST_ACTION_DEBUG);
 755                         if(option != null) JavaModelOperation.POST_ACTION_VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 756
 757 //                      option = Platform.getDebugOption(SEARCH_DEBUG);
 758 //                      if(option != null) SearchEngine.VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 759 //
 760 //                      option = Platform.getDebugOption(SELECTION_DEBUG);
 761 //                      if(option != null) SelectionEngine.DEBUG = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 762
 763                         option = Platform.getDebugOption(ZIP_ACCESS_DEBUG);
 764                         if(option != null) JavaModelManager.ZIP_ACCESS_VERBOSE = option.equalsIgnoreCase("true") ; //$NON-NLS-1$
 765                 }
 766         }
 767
 768
 769         /*
 770          * Discards the per working copy info for the given working copy (making it a compilation unit)
 771          * if its use count was 1. Otherwise, just decrement the use count.
 772          * If the working copy is primary, computes the delta between its state and the original compilation unit
 773          * and register it.
 774          * Close the working copy, its buffer and remove it from the shared working copy table.
 775          * Ignore if no per-working copy info existed.
 776          * NOTE: it must be synchronized as it may interact with the element info cache (if useCount is decremented to 0), see bug 50667.
 777          * Returns the new use count (or -1 if it didn't exist).
 778          */
 779         public synchronized int discardPerWorkingCopyInfo(CompilationUnit workingCopy) throws JavaModelException {
 780                 synchronized(perWorkingCopyInfos) {
 781                         WorkingCopyOwner owner = workingCopy.owner;
 782                         Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
 783                         if (workingCopyToInfos == null) return -1;
 784
 785                         PerWorkingCopyInfo info = (PerWorkingCopyInfo)workingCopyToInfos.get(workingCopy);
 786                         if (info == null) return -1;
 787
 788                         if (--info.useCount == 0) {
 789                                 // create the delta builder (this remembers the current content of the working copy)
 790                                 JavaElementDeltaBuilder deltaBuilder = null;
 791                                 if (workingCopy.isPrimary()) {
 792                                         deltaBuilder = new JavaElementDeltaBuilder(workingCopy);
 793                                 }
 794
 795                                 // remove per working copy info
 796                                 workingCopyToInfos.remove(workingCopy);
 797                                 if (workingCopyToInfos.isEmpty()) {
 798                                         this.perWorkingCopyInfos.remove(owner);
 799                                 }
 800
 801                                 // remove infos + close buffer (since no longer working copy)
 802                                 removeInfoAndChildren(workingCopy);
 803                                 workingCopy.closeBuffer();
 804
 805                                 // compute the delta if needed and register it if there are changes
 806                                 if (deltaBuilder != null) {
 807                                         deltaBuilder.buildDeltas();
 808                                         if ((deltaBuilder.delta != null) && (deltaBuilder.delta.getAffectedChildren().length > 0)) {
 809                                                 getDeltaProcessor().registerJavaModelDelta(deltaBuilder.delta);
 810                                         }
 811                                 }
 812
 813                         }
 814                         return info.useCount;
 815                 }
 816         }
 817
 818         /**
 819          * @see ISaveParticipant
 820          */
 821         public void doneSaving(ISaveContext context){
 822         }
 823
 824         /**
 825          * Fire Java Model delta, flushing them after the fact after post_change notification.
 826          * If the firing mode has been turned off, this has no effect.
 827          */
 828         public void fire(IJavaElementDelta customDelta, int eventType) {
 829
 830                 if (!this.isFiring) return;
 831
 832                 if (DeltaProcessor.VERBOSE && (eventType == DEFAULT_CHANGE_EVENT || eventType == ElementChangedEvent.PRE_AUTO_BUILD)) {
 833                         System.out.println("-----------------------------------------------------------------------------------------------------------------------");//$NON-NLS-1$
 834                 }
 835
 836                 IJavaElementDelta deltaToNotify;
 837                 if (customDelta == null){
 838                         deltaToNotify = this.mergeDeltas(this.javaModelDeltas);
 839                 } else {
 840                         deltaToNotify = customDelta;
 841                 }
 842
 843                 // Refresh internal scopes
 844                 if (deltaToNotify != null) {
 845 //              TODO khartlage temp-del
 846 //                      Iterator scopes = this.scopes.keySet().iterator();
 847 //                      while (scopes.hasNext()) {
 848 //                              AbstractSearchScope scope = (AbstractSearchScope)scopes.next();
 849 //                              scope.processDelta(deltaToNotify);
 850 //                      }
 851                 }
 852
 853                 // Notification
 854
 855                 // Important: if any listener reacts to notification by updating the listeners list or mask, these lists will
 856                 // be duplicated, so it is necessary to remember original lists in a variable (since field values may change under us)
 857                 IElementChangedListener[] listeners = this.elementChangedListeners;
 858                 int[] listenerMask = this.elementChangedListenerMasks;
 859                 int listenerCount = this.elementChangedListenerCount;
 860
 861                 switch (eventType) {
 862                         case DEFAULT_CHANGE_EVENT:
 863                                 firePreAutoBuildDelta(deltaToNotify, listeners, listenerMask, listenerCount);
 864                                 firePostChangeDelta(deltaToNotify, listeners, listenerMask, listenerCount);
 865                                 fireReconcileDelta(listeners, listenerMask, listenerCount);
 866                                 break;
 867                         case ElementChangedEvent.PRE_AUTO_BUILD:
 868                                 firePreAutoBuildDelta(deltaToNotify, listeners, listenerMask, listenerCount);
 869                                 break;
 870                         case ElementChangedEvent.POST_CHANGE:
 871                                 firePostChangeDelta(deltaToNotify, listeners, listenerMask, listenerCount);
 872                                 fireReconcileDelta(listeners, listenerMask, listenerCount);
 873                                 break;
 874                 }
 875
 876         }
 877
 878         private void firePreAutoBuildDelta(
 879                 IJavaElementDelta deltaToNotify,
 880                 IElementChangedListener[] listeners,
 881                 int[] listenerMask,
 882                 int listenerCount) {
 883
 884                 if (DeltaProcessor.VERBOSE){
 885                         System.out.println("FIRING PRE_AUTO_BUILD Delta ["+Thread.currentThread()+"]:"); //$NON-NLS-1$//$NON-NLS-2$
 886                         System.out.println(deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); //$NON-NLS-1$
 887                 }
 888                 if (deltaToNotify != null) {
 889                         notifyListeners(deltaToNotify, ElementChangedEvent.PRE_AUTO_BUILD, listeners, listenerMask, listenerCount);
 890                 }
 891         }
 892
 893         private void firePostChangeDelta(
 894                 IJavaElementDelta deltaToNotify,
 895                 IElementChangedListener[] listeners,
 896                 int[] listenerMask,
 897                 int listenerCount) {
 898
 899                 // post change deltas
 900                 if (DeltaProcessor.VERBOSE){
 901                         System.out.println("FIRING POST_CHANGE Delta ["+Thread.currentThread()+"]:"); //$NON-NLS-1$//$NON-NLS-2$
 902                         System.out.println(deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); //$NON-NLS-1$
 903                 }
 904                 if (deltaToNotify != null) {
 905                         // flush now so as to keep listener reactions to post their own deltas for subsequent iteration
 906                         this.flush();
 907
 908                         notifyListeners(deltaToNotify, ElementChangedEvent.POST_CHANGE, listeners, listenerMask, listenerCount);
 909                 }
 910         }
 911         private void fireReconcileDelta(
 912                 IElementChangedListener[] listeners,
 913                 int[] listenerMask,
 914                 int listenerCount) {
 915
 916
 917                 IJavaElementDelta deltaToNotify = mergeDeltas(this.reconcileDeltas.values());
 918                 if (DeltaProcessor.VERBOSE){
 919                         System.out.println("FIRING POST_RECONCILE Delta ["+Thread.currentThread()+"]:"); //$NON-NLS-1$//$NON-NLS-2$
 920                         System.out.println(deltaToNotify == null ? "<NONE>" : deltaToNotify.toString()); //$NON-NLS-1$
 921                 }
 922                 if (deltaToNotify != null) {
 923                         // flush now so as to keep listener reactions to post their own deltas for subsequent iteration
 924                         this.reconcileDeltas = new HashMap();
 925
 926                         notifyListeners(deltaToNotify, ElementChangedEvent.POST_RECONCILE, listeners, listenerMask, listenerCount);
 927                 }
 928         }
 929
 930         public void notifyListeners(IJavaElementDelta deltaToNotify, int eventType, IElementChangedListener[] listeners, int[] listenerMask, int listenerCount) {
 931                 final ElementChangedEvent extraEvent = new ElementChangedEvent(deltaToNotify, eventType);
 932                 for (int i= 0; i < listenerCount; i++) {
 933                         if ((listenerMask[i] & eventType) != 0){
 934                                 final IElementChangedListener listener = listeners[i];
 935                                 long start = -1;
 936                                 if (DeltaProcessor.VERBOSE) {
 937                                         System.out.print("Listener #" + (i+1) + "=" + listener.toString());//$NON-NLS-1$//$NON-NLS-2$
 938                                         start = System.currentTimeMillis();
 939                                 }
 940                                 // wrap callbacks with Safe runnable for subsequent listeners to be called when some are causing grief
 941                                 Platform.run(new ISafeRunnable() {
 942                                         public void handleException(Throwable exception) {
 943                                                 Util.log(exception, "Exception occurred in listener of Java element change notification"); //$NON-NLS-1$
 944                                         }
 945                                         public void run() throws Exception {
 946                                                 listener.elementChanged(extraEvent);
 947                                         }
 948                                 });
 949                                 if (DeltaProcessor.VERBOSE) {
 950                                         System.out.println(" -> " + (System.currentTimeMillis()-start) + "ms"); //$NON-NLS-1$ //$NON-NLS-2$
 951                                 }
 952                         }
 953                 }
 954         }
 955
 956         /**
 957          * Flushes all deltas without firing them.
 958          */
 959         protected void flush() {
 960                 this.javaModelDeltas = new ArrayList();
 961         }
 962
 963         /**
 964          * Flushes ZipFiles cache if there are no more clients.
 965          */
 966         public void flushZipFiles() {
 967                 synchronized(this.zipFiles) {
 968                         Thread currentThread = Thread.currentThread();
 969                         HashMap map = (HashMap)this.zipFiles.remove(currentThread);
 970                         if (map == null) return;
 971                         Iterator iterator = map.values().iterator();
 972                         while (iterator.hasNext()) {
 973                                 try {
 974                                         ZipFile zipFile = (ZipFile)iterator.next();
 975                                         if (JavaModelManager.ZIP_ACCESS_VERBOSE) {
 976                                                 System.out.println("(" + currentThread + ") [JavaModelManager.flushZipFiles()] Closing ZipFile on " +zipFile.getName()); //$NON-NLS-1$//$NON-NLS-2$
 977                                         }
 978                                         zipFile.close();
 979                                 } catch (IOException e) {
 980                                 }
 981                         }
 982                 }
 983         }
 984
 985
 986         public DeltaProcessor getDeltaProcessor() {
 987                 return this.deltaState.getDeltaProcessor();
 988         }
 989         /**
 990          * Returns the set of elements which are out of synch with their buffers.
 991          */
 992         protected Map getElementsOutOfSynchWithBuffers() {
 993                 return this.elementsOutOfSynchWithBuffers;
 994         }
 995
 996         /**
 997          * Returns the <code>IJavaElement</code> represented by the
 998          * <code>String</code> memento.
 999          */
1000         public IJavaElement getHandleFromMemento(String memento) throws JavaModelException {
1001                 if (memento == null) {
1002                         return null;
1003                 }
1004                 JavaModel model= (JavaModel) getJavaModel();
1005                 if (memento.equals("")){ // workspace memento //$NON-NLS-1$
1006                         return model;
1007                 }
1008                 int modelEnd= memento.indexOf(JavaElement.JEM_JAVAPROJECT);
1009                 if (modelEnd == -1) {
1010                         return null;
1011                 }
1012                 boolean returnProject= false;
1013                 int projectEnd= memento.indexOf(JavaElement.JEM_PACKAGEFRAGMENTROOT, modelEnd);
1014                 if (projectEnd == -1) {
1015                         projectEnd= memento.length();
1016                         returnProject= true;
1017                 }
1018                 String projectName= memento.substring(modelEnd + 1, projectEnd);
1019                 JavaProject proj= (JavaProject) model.getJavaProject(projectName);
1020                 if (returnProject) {
1021                         return proj;
1022                 }
1023                 int rootEnd= memento.indexOf(JavaElement.JEM_PACKAGEFRAGMENT, projectEnd + 1);
1024 //      TODO khartlage temp-del
1025 //              if (rootEnd == -1) {
1026 //                      return model.getHandleFromMementoForRoot(memento, proj, projectEnd, memento.length());
1027 //              }
1028 //              IPackageFragmentRoot root = model.getHandleFromMementoForRoot(memento, proj, projectEnd, rootEnd);
1029 //              if (root == null)
1030 //                      return null;
1031 //
1032 //              int end= memento.indexOf(JavaElement.JEM_COMPILATIONUNIT, rootEnd);
1033 //              if (end == -1) {
1034 //                      end= memento.indexOf(JavaElement.JEM_CLASSFILE, rootEnd);
1035 //                      if (end == -1) {
1036 //                              if (rootEnd + 1 == memento.length()) {
1037 //                                      return root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
1038 //                              } else {
1039 //                                      return root.getPackageFragment(memento.substring(rootEnd + 1));
1040 //                              }
1041 //                      }
1042 //                      //deal with class file and binary members
1043 //                      return model.getHandleFromMementoForBinaryMembers(memento, root, rootEnd, end);
1044 //              }
1045 //
1046 //              //deal with compilation units and source members
1047 //              return model.getHandleFromMementoForSourceMembers(memento, root, rootEnd, end);
1048           return null;
1049         }
1050 //      public IndexManager getIndexManager() {
1051 //              return this.deltaProcessor.indexManager;
1052 //      }
1053
1054         /**
1055          *  Returns the info for the element.
1056          */
1057         public Object getInfo(IJavaElement element) {
1058                 return this.cache.getInfo(element);
1059         }
1060
1061         /**
1062          * Returns the handle to the active Java Model.
1063          */
1064         public final JavaModel getJavaModel() {
1065                 return javaModel;
1066         }
1067
1068         /**
1069          * Returns the singleton JavaModelManager
1070          */
1071         public final static JavaModelManager getJavaModelManager() {
1072                 return Manager;
1073         }
1074
1075         /**
1076          * Returns the last built state for the given project, or null if there is none.
1077          * Deserializes the state if necessary.
1078          *
1079          * For use by image builder and evaluation support only
1080          */
1081         public Object getLastBuiltState(IProject project, IProgressMonitor monitor) {
1082                 if (!JavaProject.hasJavaNature(project)) return null; // should never be requested on non-Java projects
1083                 PerProjectInfo info = getPerProjectInfo(project, true/*create if missing*/);
1084                 if (!info.triedRead) {
1085                         info.triedRead = true;
1086                         try {
1087                                 if (monitor != null)
1088                                         monitor.subTask(Util.bind("build.readStateProgress", project.getName())); //$NON-NLS-1$
1089                                 info.savedState = readState(project);
1090                         } catch (CoreException e) {
1091                                 e.printStackTrace();
1092                         }
1093                 }
1094                 return info.savedState;
1095         }
1096
1097         /*
1098          * Returns the per-project info for the given project. If specified, create the info if the info doesn't exist.
1099          */
1100         public PerProjectInfo getPerProjectInfo(IProject project, boolean create) {
1101                 synchronized(perProjectInfo) { // use the perProjectInfo collection as its own lock
1102                         PerProjectInfo info= (PerProjectInfo) perProjectInfo.get(project);
1103                         if (info == null && create) {
1104                                 info= new PerProjectInfo(project);
1105                                 perProjectInfo.put(project, info);
1106                         }
1107                         return info;
1108                 }
1109         }
1110
1111         /*
1112          * Returns  the per-project info for the given project.
1113          * If the info doesn't exist, check for the project existence and create the info.
1114          * @throws JavaModelException if the project doesn't exist.
1115          */
1116         public PerProjectInfo getPerProjectInfoCheckExistence(IProject project) throws JavaModelException {
1117                 JavaModelManager.PerProjectInfo info = getPerProjectInfo(project, false /* don't create info */);
1118                 if (info == null) {
1119                         if (!JavaProject.hasJavaNature(project)) {
1120                                 throw ((JavaProject)JavaCore.create(project)).newNotPresentException();
1121                         }
1122                         info = getPerProjectInfo(project, true /* create info */);
1123                 }
1124                 return info;
1125         }
1126         /*
1127          * Returns the per-working copy info for the given working copy at the given path.
1128          * If it doesn't exist and if create, add a new per-working copy info with the given problem requestor.
1129          * If recordUsage, increment the per-working copy info's use count.
1130          * Returns null if it doesn't exist and not create.
1131          */
1132         public PerWorkingCopyInfo getPerWorkingCopyInfo(CompilationUnit workingCopy,boolean create, boolean recordUsage, IProblemRequestor problemRequestor) {
1133                 synchronized(perWorkingCopyInfos) { // use the perWorkingCopyInfo collection as its own lock
1134                         WorkingCopyOwner owner = workingCopy.owner;
1135                         Map workingCopyToInfos = (Map)this.perWorkingCopyInfos.get(owner);
1136                         if (workingCopyToInfos == null && create) {
1137                                 workingCopyToInfos = new HashMap();
1138                                 this.perWorkingCopyInfos.put(owner, workingCopyToInfos);
1139                         }
1140
1141                         PerWorkingCopyInfo info = workingCopyToInfos == null ? null : (PerWorkingCopyInfo) workingCopyToInfos.get(workingCopy);
1142                         if (info == null && create) {
1143                                 info= new PerWorkingCopyInfo(workingCopy, problemRequestor);
1144                                 workingCopyToInfos.put(workingCopy, info);
1145                         }
1146                         if (info != null && recordUsage) info.useCount++;
1147                         return info;
1148                 }
1149         }
1150         /**
1151          * Returns the name of the variables for which an CP variable initializer is registered through an extension point
1152          */
1153         public static String[] getRegisteredVariableNames(){
1154
1155                 Plugin jdtCorePlugin = JavaCore.getPlugin();
1156                 if (jdtCorePlugin == null) return null;
1157
1158                 ArrayList variableList = new ArrayList(5);
1159 //              IExtensionPoint extension = jdtCorePlugin.getDescriptor().getExtensionPoint(JavaModelManager.CPVARIABLE_INITIALIZER_EXTPOINT_ID);
1160 //              if (extension != null) {
1161 //                      IExtension[] extensions =  extension.getExtensions();
1162 //                      for(int i = 0; i < extensions.length; i++){
1163 //                              IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
1164 //                              for(int j = 0; j < configElements.length; j++){
1165 //                                      String varAttribute = configElements[j].getAttribute("variable"); //$NON-NLS-1$
1166 //                                      if (varAttribute != null) variableList.add(varAttribute);
1167 //                              }
1168 //                      }
1169 //              }
1170                 String[] variableNames = new String[variableList.size()];
1171                 variableList.toArray(variableNames);
1172                 return variableNames;
1173         }
1174
1175         /**
1176          * Returns the name of the container IDs for which an CP container initializer is registered through an extension point
1177          */
1178 //      public static String[] getRegisteredContainerIDs(){
1179 //
1180 //              Plugin jdtCorePlugin = PHPCore.getPlugin();
1181 //              if (jdtCorePlugin == null) return null;
1182 //
1183 //              ArrayList containerIDList = new ArrayList(5);
1184 //              IExtensionPoint extension = jdtCorePlugin.getDescriptor().getExtensionPoint(JavaModelManager.CPCONTAINER_INITIALIZER_EXTPOINT_ID);
1185 //              if (extension != null) {
1186 //                      IExtension[] extensions =  extension.getExtensions();
1187 //                      for(int i = 0; i < extensions.length; i++){
1188 //                              IConfigurationElement [] configElements = extensions[i].getConfigurationElements();
1189 //                              for(int j = 0; j < configElements.length; j++){
1190 //                                      String idAttribute = configElements[j].getAttribute("id"); //$NON-NLS-1$
1191 //                                      if (idAttribute != null) containerIDList.add(idAttribute);
1192 //                              }
1193 //                      }
1194 //              }
1195 //              String[] containerIDs = new String[containerIDList.size()];
1196 //              containerIDList.toArray(containerIDs);
1197 //              return containerIDs;
1198 //      }
1199
1200         /**
1201          * Returns the File to use for saving and restoring the last built state for the given project.
1202          */
1203         private File getSerializationFile(IProject project) {
1204                 if (!project.exists()) return null;
1205                 IPluginDescriptor descr= JavaCore.getJavaCore().getDescriptor();
1206                 IPath workingLocation= project.getPluginWorkingLocation(descr);
1207                 return workingLocation.append("state.dat").toFile(); //$NON-NLS-1$
1208         }
1209         /*
1210          * Returns the temporary cache for newly opened elements for the current thread.
1211          * Creates it if not already created.
1212          */
1213         public HashMap getTemporaryCache() {
1214                 HashMap result = (HashMap)this.temporaryCache.get();
1215                 if (result == null) {
1216                         result = new HashMap();
1217                         this.temporaryCache.set(result);
1218                 }
1219                 return result;
1220         }
1221         /**
1222          * Returns the open ZipFile at the given location. If the ZipFile
1223          * does not yet exist, it is created, opened, and added to the cache
1224          * of open ZipFiles. The location must be a absolute path.
1225          *
1226          * @exception CoreException If unable to create/open the ZipFile
1227          */
1228         public ZipFile getZipFile(IPath path) throws CoreException {
1229
1230                 synchronized(this.zipFiles) { // TODO:  use PeThreadObject which does synchronization
1231                         Thread currentThread = Thread.currentThread();
1232                         HashMap map = null;
1233                         ZipFile zipFile;
1234                         if ((map = (HashMap)this.zipFiles.get(currentThread)) != null
1235                                         && (zipFile = (ZipFile)map.get(path)) != null) {
1236
1237                                 return zipFile;
1238                         }
1239                         String fileSystemPath= null;
1240                         IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
1241                         IResource file = root.findMember(path);
1242                         if (path.isAbsolute() && file != null) {
1243                                 if (file == null) { // external file
1244                                         fileSystemPath= path.toOSString();
1245                                 } else { // internal resource (not an IFile or not existing)
1246                                         IPath location;
1247                                         if (file.getType() != IResource.FILE || (location = file.getLocation()) == null) {
1248                                                 throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Util.bind("file.notFound", path.toString()), null)); //$NON-NLS-1$
1249                                         }
1250                                         fileSystemPath= location.toOSString();
1251                                 }
1252                         } else if (!path.isAbsolute()) {
1253                                 file= root.getFile(path);
1254                                 if (file == null || file.getType() != IResource.FILE) {
1255                                         throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Util.bind("file.notFound", path.toString()), null)); //$NON-NLS-1$
1256                                 }
1257                                 IPath location = file.getLocation();
1258                                 if (location == null) {
1259                                         throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, -1, Util.bind("file.notFound", path.toString()), null)); //$NON-NLS-1$
1260                                 }
1261                                 fileSystemPath= location.toOSString();
1262                         } else {
1263                                 fileSystemPath= path.toOSString();
1264                         }
1265
1266                         try {
1267                                 if (ZIP_ACCESS_VERBOSE) {
1268                                         System.out.println("(" + currentThread + ") [JavaModelManager.getZipFile(IPath)] Creating ZipFile on " + fileSystemPath ); //$NON-NLS-1$ //$NON-NLS-2$
1269                                 }
1270                                 zipFile = new ZipFile(fileSystemPath);
1271                                 if (map != null) {
1272                                         map.put(path, zipFile);
1273                                 }
1274                                 return zipFile;
1275                         } catch (IOException e) {
1276                                 throw new CoreException(new Status(Status.ERROR, JavaCore.PLUGIN_ID, -1, Util.bind("status.IOException"), e)); //$NON-NLS-1$
1277                         }
1278                 }
1279         }
1280         /*
1281          * Returns whether there is a temporary cache for the current thread.
1282          */
1283         public boolean hasTemporaryCache() {
1284                 return this.temporaryCache.get() != null;
1285         }
1286 //      public void loadVariablesAndContainers() throws CoreException {
1287 //
1288 //              // backward compatibility, consider persistent property
1289 //              QualifiedName qName = new QualifiedName(PHPCore.PLUGIN_ID, "variables"); //$NON-NLS-1$
1290 //              String xmlString = ResourcesPlugin.getWorkspace().getRoot().getPersistentProperty(qName);
1291 //
1292 //              try {
1293 //                      if (xmlString != null){
1294 //                              StringReader reader = new StringReader(xmlString);
1295 //                              Element cpElement;
1296 //                              try {
1297 //                                      DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
1298 //                                      cpElement = parser.parse(new InputSource(reader)).getDocumentElement();
1299 //                              } catch(SAXException e) {
1300 //                                      return;
1301 //                              } catch(ParserConfigurationException e){
1302 //                                      return;
1303 //                              } finally {
1304 //                                      reader.close();
1305 //                              }
1306 //                              if (cpElement == null) return;
1307 //                              if (!cpElement.getNodeName().equalsIgnoreCase("variables")) { //$NON-NLS-1$
1308 //                                      return;
1309 //                              }
1310 //
1311 //                              NodeList list= cpElement.getChildNodes();
1312 //                              int length= list.getLength();
1313 //                              for (int i= 0; i < length; ++i) {
1314 //                                      Node node= list.item(i);
1315 //                                      short type= node.getNodeType();
1316 //                                      if (type == Node.ELEMENT_NODE) {
1317 //                                              Element element= (Element) node;
1318 //                                              if (element.getNodeName().equalsIgnoreCase("variable")) { //$NON-NLS-1$
1319 //                                                      variablePut(
1320 //                                                              element.getAttribute("name"), //$NON-NLS-1$
1321 //                                                              new Path(element.getAttribute("path"))); //$NON-NLS-1$
1322 //                                              }
1323 //                                      }
1324 //                              }
1325 //                      }
1326 //              } catch(IOException e){
1327 //              } finally {
1328 //                      if (xmlString != null){
1329 //                              ResourcesPlugin.getWorkspace().getRoot().setPersistentProperty(qName, null); // flush old one
1330 //                      }
1331 //
1332 //              }
1333 //
1334 //              // load variables and containers from preferences into cache
1335 //              Preferences preferences = PHPCore.getPlugin().getPluginPreferences();
1336 //
1337 //              // only get variable from preferences not set to their default
1338 //              String[] propertyNames = preferences.propertyNames();
1339 //              int variablePrefixLength = CP_VARIABLE_PREFERENCES_PREFIX.length();
1340 //              for (int i = 0; i < propertyNames.length; i++){
1341 //                      String propertyName = propertyNames[i];
1342 //                      if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)){
1343 //                              String varName = propertyName.substring(variablePrefixLength);
1344 //                              IPath varPath = new Path(preferences.getString(propertyName).trim());
1345 //
1346 //                              Variables.put(varName, varPath);
1347 //                              PreviousSessionVariables.put(varName, varPath);
1348 //                      }
1349 //                      if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)){
1350 //                              recreatePersistedContainer(propertyName, preferences.getString(propertyName), true/*add to container values*/);
1351 //                      }
1352 //              }
1353 //              // override persisted values for variables which have a registered initializer
1354 //              String[] registeredVariables = getRegisteredVariableNames();
1355 //              for (int i = 0; i < registeredVariables.length; i++) {
1356 //                      String varName = registeredVariables[i];
1357 //                      Variables.put(varName, null); // reset variable, but leave its entry in the Map, so it will be part of variable names.
1358 //              }
1359 //              // override persisted values for containers which have a registered initializer
1360 //              String[] registeredContainerIDs = getRegisteredContainerIDs();
1361 //              for (int i = 0; i < registeredContainerIDs.length; i++) {
1362 //                      String containerID = registeredContainerIDs[i];
1363 //                      Iterator projectIterator = Containers.keySet().iterator();
1364 //                      while (projectIterator.hasNext()){
1365 //                              IJavaProject project = (IJavaProject)projectIterator.next();
1366 //                              Map projectContainers = (Map)Containers.get(project);
1367 //                              if (projectContainers != null){
1368 //                                      Iterator containerIterator = projectContainers.keySet().iterator();
1369 //                                      while (containerIterator.hasNext()){
1370 //                                              IPath containerPath = (IPath)containerIterator.next();
1371 //                                              if (containerPath.segment(0).equals(containerID)) { // registered container
1372 //                                                      projectContainers.put(containerPath, null); // reset container value, but leave entry in Map
1373 //                                              }
1374 //                                      }
1375 //                              }
1376 //                      }
1377 //              }
1378 //      }
1379
1380         /**
1381          * Merged all awaiting deltas.
1382          */
1383         public IJavaElementDelta mergeDeltas(Collection deltas) {
1384                 if (deltas.size() == 0) return null;
1385                 if (deltas.size() == 1) return (IJavaElementDelta)deltas.iterator().next();
1386
1387                 if (DeltaProcessor.VERBOSE) {
1388                         System.out.println("MERGING " + deltas.size() + " DELTAS ["+Thread.currentThread()+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1389                 }
1390
1391                 Iterator iterator = deltas.iterator();
1392                 IJavaElement javaModel = this.getJavaModel();
1393                 JavaElementDelta rootDelta = new JavaElementDelta(javaModel);
1394                 boolean insertedTree = false;
1395                 while (iterator.hasNext()) {
1396                         JavaElementDelta delta = (JavaElementDelta)iterator.next();
1397                         if (DeltaProcessor.VERBOSE) {
1398                                 System.out.println(delta.toString());
1399                         }
1400                         IJavaElement element = delta.getElement();
1401                         if (javaModel.equals(element)) {
1402                                 IJavaElementDelta[] children = delta.getAffectedChildren();
1403                                 for (int j = 0; j < children.length; j++) {
1404                                         JavaElementDelta projectDelta = (JavaElementDelta) children[j];
1405                                         rootDelta.insertDeltaTree(projectDelta.getElement(), projectDelta);
1406                                         insertedTree = true;
1407                                 }
1408                                 IResourceDelta[] resourceDeltas = delta.getResourceDeltas();
1409                                 if (resourceDeltas != null) {
1410                                         for (int i = 0, length = resourceDeltas.length; i < length; i++) {
1411                                                 rootDelta.addResourceDelta(resourceDeltas[i]);
1412                                                 insertedTree = true;
1413                                         }
1414                                 }
1415                         } else {
1416                                 rootDelta.insertDeltaTree(element, delta);
1417                                 insertedTree = true;
1418                         }
1419                 }
1420                 if (insertedTree) {
1421                         return rootDelta;
1422                 }
1423                 else {
1424                         return null;
1425                 }
1426         }
1427
1428         /**
1429          *  Returns the info for this element without
1430          *  disturbing the cache ordering.
1431          */ // TODO: should be synchronized, could answer unitialized info or if cache is in middle of rehash, could even answer distinct element info
1432         protected Object peekAtInfo(IJavaElement element) {
1433                 return this.cache.peekAtInfo(element);
1434         }
1435
1436         /**
1437          * @see ISaveParticipant
1438          */
1439         public void prepareToSave(ISaveContext context) throws CoreException {
1440         }
1441
1442         protected void putInfo(IJavaElement element, Object info) {
1443                 this.cache.putInfo(element, info);
1444         }
1445         /*
1446          * Puts the infos in the given map (keys are IJavaElements and values are JavaElementInfos)
1447          * in the Java model cache in an atomic way.
1448          * First checks that the info for the opened element (or one of its ancestors) has not been
1449          * added to the cache. If it is the case, another thread has opened the element (or one of
1450          * its ancestors). So returns without updating the cache.
1451          */
1452         protected synchronized void putInfos(IJavaElement openedElement, Map newElements) {
1453                 // remove children
1454                 Object existingInfo = this.cache.peekAtInfo(openedElement);
1455                 if (openedElement instanceof IParent && existingInfo instanceof JavaElementInfo) {
1456                         IJavaElement[] children = ((JavaElementInfo)existingInfo).getChildren();
1457                         for (int i = 0, size = children.length; i < size; ++i) {
1458                                 JavaElement child = (JavaElement) children[i];
1459                                 try {
1460                                         child.close();
1461                                 } catch (JavaModelException e) {
1462                                         // ignore
1463                                 }
1464                         }
1465                 }
1466
1467                 Iterator iterator = newElements.keySet().iterator();
1468                 while (iterator.hasNext()) {
1469                         IJavaElement element = (IJavaElement)iterator.next();
1470                         Object info = newElements.get(element);
1471                         this.cache.putInfo(element, info);
1472                 }
1473         }
1474         /**
1475          * Reads the build state for the relevant project.
1476          */
1477         protected Object readState(IProject project) throws CoreException {
1478                 File file = getSerializationFile(project);
1479                 if (file != null && file.exists()) {
1480                         try {
1481                                 DataInputStream in= new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
1482                                 try {
1483                                         String pluginID= in.readUTF();
1484                                         if (!pluginID.equals(JavaCore.PLUGIN_ID))
1485                                                 throw new IOException(Util.bind("build.wrongFileFormat")); //$NON-NLS-1$
1486                                         String kind= in.readUTF();
1487                                         if (!kind.equals("STATE")) //$NON-NLS-1$
1488                                                 throw new IOException(Util.bind("build.wrongFileFormat")); //$NON-NLS-1$
1489                                         if (in.readBoolean())
1490                                                 return PHPBuilder.readState(project, in);
1491                                         if (PHPBuilder.DEBUG)
1492                                                 System.out.println("Saved state thinks last build failed for " + project.getName()); //$NON-NLS-1$
1493                                 } finally {
1494                                         in.close();
1495                                 }
1496                         } catch (Exception e) {
1497                                 e.printStackTrace();
1498                                 throw new CoreException(new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, Platform.PLUGIN_ERROR, "Error reading last build state for project "+ project.getName(), e)); //$NON-NLS-1$
1499                         }
1500                 }
1501                 return null;
1502         }
1503
1504 //      public static void recreatePersistedContainer(String propertyName, String containerString, boolean addToContainerValues) {
1505 //              int containerPrefixLength = CP_CONTAINER_PREFERENCES_PREFIX.length();
1506 //              int index = propertyName.indexOf('|', containerPrefixLength);
1507 //              if (containerString != null) containerString = containerString.trim();
1508 //              if (index > 0) {
1509 //                      final String projectName = propertyName.substring(containerPrefixLength, index).trim();
1510 //                      JavaProject project = (JavaProject)getJavaModelManager().getJavaModel().getJavaProject(projectName);
1511 //                      final IPath containerPath = new Path(propertyName.substring(index+1).trim());
1512 //
1513 //                      if (containerString == null || containerString.equals(CP_ENTRY_IGNORE)) {
1514 //                              containerPut(project, containerPath, null);
1515 //                      } else {
1516 //                              final IClasspathEntry[] containerEntries = project.decodeClasspath(containerString, false, false);
1517 //                              if (containerEntries != null && containerEntries != JavaProject.INVALID_CLASSPATH) {
1518 //                                      IClasspathContainer container = new IClasspathContainer() {
1519 //                                              public IClasspathEntry[] getClasspathEntries() {
1520 //                                                      return containerEntries;
1521 //                                              }
1522 //                                              public String getDescription() {
1523 //                                                      return "Persisted container ["+containerPath+" for project ["+ projectName+"]"; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
1524 //                                              }
1525 //                                              public int getKind() {
1526 //                                                      return 0;
1527 //                                              }
1528 //                                              public IPath getPath() {
1529 //                                                      return containerPath;
1530 //                                              }
1531 //                                              public String toString() {
1532 //                                                      return getDescription();
1533 //                                              }
1534 //
1535 //                                      };
1536 //                                      if (addToContainerValues) {
1537 //                                              containerPut(project, containerPath, container);
1538 //                                      }
1539 //                                      Map projectContainers = (Map)PreviousSessionContainers.get(project);
1540 //                                      if (projectContainers == null){
1541 //                                              projectContainers = new HashMap(1);
1542 //                                              PreviousSessionContainers.put(project, projectContainers);
1543 //                                      }
1544 //                                      projectContainers.put(containerPath, container);
1545 //                              }
1546 //                      }
1547 //              }
1548 //      }
1549
1550         /**
1551          * Registers the given delta with this manager.
1552          */
1553         protected void registerJavaModelDelta(IJavaElementDelta delta) {
1554                 this.javaModelDeltas.add(delta);
1555         }
1556
1557         /**
1558          * Remembers the given scope in a weak set
1559          * (so no need to remove it: it will be removed by the garbage collector)
1560          */
1561 //      public void rememberScope(AbstractSearchScope scope) {
1562 //              // NB: The value has to be null so as to not create a strong reference on the scope
1563 //              this.scopes.put(scope, null);
1564 //      }
1565
1566         /**
1567          * removeElementChangedListener method comment.
1568          */
1569         public void removeElementChangedListener(IElementChangedListener listener) {
1570
1571                 for (int i = 0; i < this.elementChangedListenerCount; i++){
1572
1573                         if (this.elementChangedListeners[i].equals(listener)){
1574
1575                                 // need to clone defensively since we might be in the middle of listener notifications (#fire)
1576                                 int length = this.elementChangedListeners.length;
1577                                 IElementChangedListener[] newListeners = new IElementChangedListener[length];
1578                                 System.arraycopy(this.elementChangedListeners, 0, newListeners, 0, i);
1579                                 int[] newMasks = new int[length];
1580                                 System.arraycopy(this.elementChangedListenerMasks, 0, newMasks, 0, i);
1581
1582                                 // copy trailing listeners
1583                                 int trailingLength = this.elementChangedListenerCount - i - 1;
1584                                 if (trailingLength > 0){
1585                                         System.arraycopy(this.elementChangedListeners, i+1, newListeners, i, trailingLength);
1586                                         System.arraycopy(this.elementChangedListenerMasks, i+1, newMasks, i, trailingLength);
1587                                 }
1588
1589                                 // update manager listener state (#fire need to iterate over original listeners through a local variable to hold onto
1590                                 // the original ones)
1591                                 this.elementChangedListeners = newListeners;
1592                                 this.elementChangedListenerMasks = newMasks;
1593                                 this.elementChangedListenerCount--;
1594                                 return;
1595                         }
1596                 }
1597         }
1598
1599 //      PROTECTED VOID REMOVEINFO(IJAVAELEMENT ELEMENT) {
1600 //              THIS.CACHE.REMOVEINFO(ELEMENT);
1601 //      }
1602         /*
1603          * Removes all cached info for the given element (including all children)
1604          * from the cache.
1605          * Returns the info for the given element, or null if it was closed.
1606          */
1607         public synchronized Object removeInfoAndChildren(JavaElement element) throws JavaModelException {
1608                 Object info = this.cache.peekAtInfo(element);
1609                 if (info != null) {
1610                         boolean wasVerbose = false;
1611                         try {
1612                                 if (VERBOSE) {
1613                                         System.out.println("CLOSING Element ("+ Thread.currentThread()+"): " + element.toStringWithAncestors());  //$NON-NLS-1$//$NON-NLS-2$
1614                                         wasVerbose = true;
1615                                         VERBOSE = false;
1616                                 }
1617                                 element.closing(info);
1618                                 if (element instanceof IParent && info instanceof JavaElementInfo) {
1619                                         IJavaElement[] children = ((JavaElementInfo)info).getChildren();
1620                                         for (int i = 0, size = children.length; i < size; ++i) {
1621                                                 JavaElement child = (JavaElement) children[i];
1622                                                 child.close();
1623                                         }
1624                                 }
1625                                 this.cache.removeInfo(element);
1626                                 if (wasVerbose) {
1627                                         System.out.println("-> Package cache size = " + this.cache.pkgSize()); //$NON-NLS-1$
1628                                         System.out.println("-> Openable cache filling ratio = " + NumberFormat.getInstance().format(this.cache.openableFillingRatio()) + "%"); //$NON-NLS-1$//$NON-NLS-2$
1629                                 }
1630                         } finally {
1631                                 JavaModelManager.VERBOSE = wasVerbose;
1632                         }
1633                         return info;
1634                 }
1635                 return null;
1636         }
1637         public void removePerProjectInfo(JavaProject javaProject) {
1638                 synchronized(perProjectInfo) { // use the perProjectInfo collection as its own lock
1639                         IProject project = javaProject.getProject();
1640                         PerProjectInfo info= (PerProjectInfo) perProjectInfo.get(project);
1641                         if (info != null) {
1642                                 perProjectInfo.remove(project);
1643                         }
1644                 }
1645         }
1646         /*
1647          * Resets the temporary cache for newly created elements to null.
1648          */
1649         public void resetTemporaryCache() {
1650                 this.temporaryCache.set(null);
1651         }
1652         /**
1653          * @see ISaveParticipant
1654          */
1655         public void rollback(ISaveContext context){
1656         }
1657
1658         private void saveState(PerProjectInfo info, ISaveContext context) throws CoreException {
1659
1660                 // passed this point, save actions are non trivial
1661                 if (context.getKind() == ISaveContext.SNAPSHOT) return;
1662
1663                 // save built state
1664                 if (info.triedRead) saveBuiltState(info);
1665         }
1666
1667         /**
1668          * Saves the built state for the project.
1669          */
1670         private void saveBuiltState(PerProjectInfo info) throws CoreException {
1671                 if (PHPBuilder.DEBUG)
1672                         System.out.println(Util.bind("build.saveStateProgress", info.project.getName())); //$NON-NLS-1$
1673                 File file = getSerializationFile(info.project);
1674                 if (file == null) return;
1675                 long t = System.currentTimeMillis();
1676                 try {
1677                         DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
1678                         try {
1679                                 out.writeUTF(JavaCore.PLUGIN_ID);
1680                                 out.writeUTF("STATE"); //$NON-NLS-1$
1681                                 if (info.savedState == null) {
1682                                         out.writeBoolean(false);
1683                                 } else {
1684                                         out.writeBoolean(true);
1685                                         PHPBuilder.writeState(info.savedState, out);
1686                                 }
1687                         } finally {
1688                                 out.close();
1689                         }
1690                 } catch (RuntimeException e) {
1691                         try {file.delete();} catch(SecurityException se) {}
1692                         throw new CoreException(
1693                                 new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, Platform.PLUGIN_ERROR,
1694                                         Util.bind("build.cannotSaveState", info.project.getName()), e)); //$NON-NLS-1$
1695                 } catch (IOException e) {
1696                         try {file.delete();} catch(SecurityException se) {}
1697                         throw new CoreException(
1698                                 new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, Platform.PLUGIN_ERROR,
1699                                         Util.bind("build.cannotSaveState", info.project.getName()), e)); //$NON-NLS-1$
1700                 }
1701                 if (PHPBuilder.DEBUG) {
1702                         t = System.currentTimeMillis() - t;
1703                         System.out.println(Util.bind("build.saveStateComplete", String.valueOf(t))); //$NON-NLS-1$
1704                 }
1705         }
1706
1707         /**
1708          * @see ISaveParticipant
1709          */
1710         public void saving(ISaveContext context) throws CoreException {
1711
1712                 IProject savedProject = context.getProject();
1713                 if (savedProject != null) {
1714                         if (!JavaProject.hasJavaNature(savedProject)) return; // ignore
1715                         PerProjectInfo info = getPerProjectInfo(savedProject, true /* create info */);
1716                         saveState(info, context);
1717                         return;
1718                 }
1719
1720                 ArrayList vStats= null; // lazy initialized
1721                 for (Iterator iter =  perProjectInfo.values().iterator(); iter.hasNext();) {
1722                         try {
1723                                 PerProjectInfo info = (PerProjectInfo) iter.next();
1724                                 saveState(info, context);
1725                         } catch (CoreException e) {
1726                                 if (vStats == null)
1727                                         vStats= new ArrayList();
1728                                 vStats.add(e.getStatus());
1729                         }
1730                 }
1731                 if (vStats != null) {
1732                         IStatus[] stats= new IStatus[vStats.size()];
1733                         vStats.toArray(stats);
1734                         throw new CoreException(new MultiStatus(JavaCore.PLUGIN_ID, IStatus.ERROR, stats, Util.bind("build.cannotSaveStates"), null)); //$NON-NLS-1$
1735                 }
1736         }
1737
1738         /**
1739          * Record the order in which to build the java projects (batch build). This order is based
1740          * on the projects classpath settings.
1741          */
1742         protected void setBuildOrder(String[] javaBuildOrder) throws JavaModelException {
1743
1744                 // optional behaviour
1745                 // possible value of index 0 is Compute
1746                 if (!JavaCore.COMPUTE.equals(JavaCore.getOption(JavaCore.CORE_JAVA_BUILD_ORDER))) return; // cannot be customized at project level
1747
1748                 if (javaBuildOrder == null || javaBuildOrder.length <= 1) return;
1749
1750                 IWorkspace workspace = ResourcesPlugin.getWorkspace();
1751                 IWorkspaceDescription description = workspace.getDescription();
1752                 String[] wksBuildOrder = description.getBuildOrder();
1753
1754                 String[] newOrder;
1755                 if (wksBuildOrder == null){
1756                         newOrder = javaBuildOrder;
1757                 } else {
1758                         // remove projects which are already mentionned in java builder order
1759                         int javaCount = javaBuildOrder.length;
1760                         HashMap newSet = new HashMap(javaCount); // create a set for fast check
1761                         for (int i = 0; i < javaCount; i++){
1762                                 newSet.put(javaBuildOrder[i], javaBuildOrder[i]);
1763                         }
1764                         int removed = 0;
1765                         int oldCount = wksBuildOrder.length;
1766                         for (int i = 0; i < oldCount; i++){
1767                                 if (newSet.containsKey(wksBuildOrder[i])){
1768                                         wksBuildOrder[i] = null;
1769                                         removed++;
1770                                 }
1771                         }
1772                         // add Java ones first
1773                         newOrder = new String[oldCount - removed + javaCount];
1774                         System.arraycopy(javaBuildOrder, 0, newOrder, 0, javaCount); // java projects are built first
1775
1776                         // copy previous items in their respective order
1777                         int index = javaCount;
1778                         for (int i = 0; i < oldCount; i++){
1779                                 if (wksBuildOrder[i] != null){
1780                                         newOrder[index++] = wksBuildOrder[i];
1781                                 }
1782                         }
1783                 }
1784                 // commit the new build order out
1785                 description.setBuildOrder(newOrder);
1786                 try {
1787                         workspace.setDescription(description);
1788                 } catch(CoreException e){
1789                         throw new JavaModelException(e);
1790                 }
1791         }
1792
1793         /**
1794          * Sets the last built state for the given project, or null to reset it.
1795          */
1796         public void setLastBuiltState(IProject project, Object state) {
1797                 if (!JavaProject.hasJavaNature(project)) return; // should never be requested on non-Java projects
1798                 PerProjectInfo info = getPerProjectInfo(project, true /*create if missing*/);
1799                 info.triedRead = true; // no point trying to re-read once using setter
1800                 info.savedState = state;
1801                 if (state == null) { // delete state file to ensure a full build happens if the workspace crashes
1802                         try {
1803                                 File file = getSerializationFile(project);
1804                                 if (file != null && file.exists())
1805                                         file.delete();
1806                         } catch(SecurityException se) {}
1807                 }
1808         }
1809
1810         public void shutdown () {
1811 //      TODO khartlage temp-del
1812 //              if (this.deltaProcessor.indexManager != null){ // no more indexing
1813 //                      this.deltaProcessor.indexManager.shutdown();
1814 //              }
1815                 try {
1816                         IJavaModel model = this.getJavaModel();
1817                         if (model != null) {
1818
1819                                 model.close();
1820                         }
1821                 } catch (JavaModelException e) {
1822                 }
1823         }
1824
1825         /**
1826          * Turns the firing mode to on. That is, deltas that are/have been
1827          * registered will be fired.
1828          */
1829         public void startDeltas() {
1830                 this.isFiring= true;
1831         }
1832
1833         /**
1834          * Turns the firing mode to off. That is, deltas that are/have been
1835          * registered will not be fired until deltas are started again.
1836          */
1837         public void stopDeltas() {
1838                 this.isFiring= false;
1839         }
1840
1841         /**
1842          * Update Java Model given some delta
1843          */
1844 //      public void updateJavaModel(IJavaElementDelta customDelta) {
1845 //
1846 //              if (customDelta == null){
1847 //                      for (int i = 0, length = this.javaModelDeltas.size(); i < length; i++){
1848 //                              IJavaElementDelta delta = (IJavaElementDelta)this.javaModelDeltas.get(i);
1849 //                              this.modelUpdater.processJavaDelta(delta);
1850 //                      }
1851 //              } else {
1852 //                      this.modelUpdater.processJavaDelta(customDelta);
1853 //              }
1854 //      }
1855
1856
1857
1858         public static IPath variableGet(String variableName){
1859                 return (IPath)Variables.get(variableName);
1860         }
1861
1862         public static String[] variableNames(){
1863                 int length = Variables.size();
1864                 String[] result = new String[length];
1865                 Iterator vars = Variables.keySet().iterator();
1866                 int index = 0;
1867                 while (vars.hasNext()) {
1868                         result[index++] = (String) vars.next();
1869                 }
1870                 return result;
1871         }
1872
1873         public static void variablePut(String variableName, IPath variablePath){
1874
1875                 // update cache - do not only rely on listener refresh
1876                 if (variablePath == null) {
1877                         Variables.remove(variableName);
1878                         PreviousSessionVariables.remove(variableName);
1879                 } else {
1880                         Variables.put(variableName, variablePath);
1881                 }
1882
1883                 // do not write out intermediate initialization value
1884                 if (variablePath == JavaModelManager.VariableInitializationInProgress){
1885                         return;
1886                 }
1887                 Preferences preferences = JavaCore.getPlugin().getPluginPreferences();
1888                 String variableKey = CP_VARIABLE_PREFERENCES_PREFIX+variableName;
1889                 String variableString = variablePath == null ? CP_ENTRY_IGNORE : variablePath.toString();
1890                 preferences.setDefault(variableKey, CP_ENTRY_IGNORE); // use this default to get rid of removed ones
1891                 preferences.setValue(variableKey, variableString);
1892                 JavaCore.getPlugin().savePluginPreferences();
1893         }
1894         /*
1895          * Returns all the working copies which have the given owner.
1896          * Adds the working copies of the primary owner if specified.
1897          * Returns null if it has none.
1898          */
1899         public ICompilationUnit[] getWorkingCopies(WorkingCopyOwner owner, boolean addPrimary) {
1900                 synchronized(perWorkingCopyInfos) {
1901                         ICompilationUnit[] primaryWCs = addPrimary && owner != DefaultWorkingCopyOwner.PRIMARY
1902                                 ? getWorkingCopies(DefaultWorkingCopyOwner.PRIMARY, false)
1903                                 : null;
1904                         Map workingCopyToInfos = (Map)perWorkingCopyInfos.get(owner);
1905                         if (workingCopyToInfos == null) return primaryWCs;
1906                         int primaryLength = primaryWCs == null ? 0 : primaryWCs.length;
1907                         int size = workingCopyToInfos.size(); // note size is > 0 otherwise pathToPerWorkingCopyInfos would be null
1908                         ICompilationUnit[] result = new ICompilationUnit[primaryLength + size];
1909                         if (primaryWCs != null) {
1910                                 System.arraycopy(primaryWCs, 0, result, 0, primaryLength);
1911                         }
1912                         Iterator iterator = workingCopyToInfos.values().iterator();
1913                         int index = primaryLength;
1914                         while(iterator.hasNext()) {
1915                                 result[index++] = ((JavaModelManager.PerWorkingCopyInfo)iterator.next()).getWorkingCopy();
1916                         }
1917                         return result;
1918                 }
1919         }
1920 }