net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/JavaModel.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.util.ArrayList;
  14 import java.util.HashSet;
  15
  16 import net.sourceforge.phpdt.core.IJavaElement;
  17 import net.sourceforge.phpdt.core.IJavaModel;
  18 import net.sourceforge.phpdt.core.IJavaProject;
  19 import net.sourceforge.phpdt.core.JavaModelException;
  20
  21 import org.eclipse.core.resources.IFile;
  22 import org.eclipse.core.resources.IFolder;
  23 import org.eclipse.core.resources.IProject;
  24 import org.eclipse.core.resources.IResource;
  25 import org.eclipse.core.resources.IWorkspace;
  26 import org.eclipse.core.resources.ResourcesPlugin;
  27 import org.eclipse.core.runtime.IPath;
  28 import org.eclipse.core.runtime.Path;
  29 import org.eclipse.jface.util.Assert;
  30
  31
  32 /**
  33  * Implementation of <code>IJavaModel<code>. The Java Model maintains a cache of
  34  * active <code>IJavaProject</code>s in a workspace. A Java Model is specific to a
  35  * workspace. To retrieve a workspace's model, use the
  36  * <code>#getJavaModel(IWorkspace)</code> method.
  37  *
  38  * @see IJavaModel
  39  */
  40 public class JavaModel extends Openable implements IJavaModel {
  41
  42         /**
  43          * A set of java.io.Files used as a cache of external jars that
  44          * are known to be existing.
  45          * Note this cache is kept for the whole session.
  46          */
  47         public static HashSet existingExternalFiles = new HashSet();
  48
  49 /**
  50  * Constructs a new Java Model on the given workspace.
  51  * Note that only one instance of JavaModel handle should ever be created.
  52  * One should only indirect through JavaModelManager#getJavaModel() to get
  53  * access to it.
  54  *
  55  * @exception Error if called more than once
  56  */
  57 protected JavaModel() throws Error {
  58         super(JAVA_MODEL, null, "" /*workspace has empty name*/); //$NON-NLS-1$
  59 }
  60 /*
  61  * @see IJavaModel
  62  */
  63 //public boolean contains(IResource resource) {
  64 //      switch (resource.getType()) {
  65 //              case IResource.ROOT:
  66 //              case IResource.PROJECT:
  67 //                      return true;
  68 //      }
  69 //      // file or folder
  70 //      IJavaProject[] projects;
  71 //      try {
  72 //              projects = this.getJavaProjects();
  73 //      } catch (JavaModelException e) {
  74 //              return false;
  75 //      }
  76 //      for (int i = 0, length = projects.length; i < length; i++) {
  77 //              JavaProject project = (JavaProject)projects[i];
  78 //
  79 //              if (!project.contains(resource)) {
  80 //                      return false;
  81 //              }
  82 //      }
  83 //      return true;
  84 //}
  85 /**
  86  * @see IJavaModel
  87  */
  88 //public void copy(IJavaElement[] elements, IJavaElement[] containers, IJavaElement[] siblings, String[] renamings, boolean force, IProgressMonitor monitor) throws JavaModelException {
  89 //      if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
  90 //              runOperation(new CopyResourceElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
  91 //      } else {
  92 //              runOperation(new CopyElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
  93 //      }
  94 //}
  95 /**
  96  * Returns a new element info for this element.
  97  */
  98 //protected OpenableElementInfo createElementInfo() {
  99 //      return new JavaModelInfo();
 100 //}
 101
 102 /**
 103  * @see IJavaModel
 104  */
 105 //public void delete(IJavaElement[] elements, boolean force, IProgressMonitor monitor) throws JavaModelException {
 106 //      if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
 107 //              runOperation(new DeleteResourceElementsOperation(elements, force), monitor);
 108 //      } else {
 109 //              runOperation(new DeleteElementsOperation(elements, force), monitor);
 110 //      }
 111 //}
 112 /**
 113  * Finds the given project in the list of the java model's children.
 114  * Returns null if not found.
 115  */
 116 public IJavaProject findJavaProject(IProject project) {
 117         try {
 118                 IJavaProject[] projects = this.getOldJavaProjectsList();
 119                 for (int i = 0, length = projects.length; i < length; i++) {
 120                         IJavaProject javaProject = projects[i];
 121                         if (project.equals(javaProject.getProject())) {
 122                                 return javaProject;
 123                         }
 124                 }
 125         } catch (JavaModelException e) {
 126         }
 127         return null;
 128 }
 129
 130 /**
 131  * Flushes the cache of external files known to be existing.
 132  */
 133 public static void flushExternalFileCache() {
 134         existingExternalFiles = new HashSet();
 135 }
 136
 137 /**
 138  */
 139 //protected boolean generateInfos(
 140 //      OpenableElementInfo info,
 141 //      IProgressMonitor pm,
 142 //      Map newElements,
 143 //      IResource underlyingResource)   throws JavaModelException {
 144 //
 145 //      JavaModelManager.getJavaModelManager().putInfo(this, info);
 146 //      // determine my children
 147 //      IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
 148 //      for (int i = 0, max = projects.length; i < max; i++) {
 149 //              IProject project = projects[i];
 150 //              if (JavaProject.hasJavaNature(project)) {
 151 //                      info.addChild(getJavaProject(project));
 152 //              }
 153 //      }
 154 //      return true;
 155 //}
 156 /**
 157  * Returns the <code>IJavaElement</code> represented by the <code>String</code>
 158  * memento.
 159  * @see getHandleMemento()
 160  */
 161 //protected IJavaElement getHandleFromMementoForBinaryMembers(String memento, IPackageFragmentRoot root, int rootEnd, int end) throws JavaModelException {
 162 //
 163 //      //deal with class file and binary members
 164 //      IPackageFragment frag = null;
 165 //      if (rootEnd == end - 1) {
 166 //              //default package
 167 //              frag= root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
 168 //      } else {
 169 //              frag= root.getPackageFragment(memento.substring(rootEnd + 1, end));
 170 //      }
 171 //      int oldEnd = end;
 172 //      end = memento.indexOf(JavaElement.JEM_TYPE, oldEnd);
 173 //      if (end == -1) {
 174 //              //we ended with a class file
 175 //              return frag.getClassFile(memento.substring(oldEnd + 1));
 176 //      }
 177 //      IClassFile cf = frag.getClassFile(memento.substring(oldEnd + 1, end));
 178 //      oldEnd = end;
 179 //      end = memento.indexOf(JavaElement.JEM_TYPE, oldEnd);
 180 //      oldEnd = end;
 181 //      end = memento.indexOf(JavaElement.JEM_FIELD, end);
 182 //      if (end != -1) {
 183 //              //binary field
 184 //              IType type = cf.getType();
 185 //              return type.getField(memento.substring(end + 1));
 186 //      }
 187 //      end = memento.indexOf(JavaElement.JEM_METHOD, oldEnd);
 188 //      if (end != -1) {
 189 //              //binary method
 190 //              oldEnd = end;
 191 //              IType type = cf.getType();
 192 //              String methodName;
 193 //              end = memento.lastIndexOf(JavaElement.JEM_METHOD);
 194 //              String[] parameterTypes = null;
 195 //              if (end == oldEnd) {
 196 //                      methodName = memento.substring(end + 1);
 197 //                      //no parameter types
 198 //                      parameterTypes = new String[] {};
 199 //              } else {
 200 //                      String parameters = memento.substring(oldEnd + 1);
 201 //                      StringTokenizer tokenizer = new StringTokenizer(parameters, new String(new char[] {JavaElement.JEM_METHOD}));
 202 //                      parameterTypes = new String[tokenizer.countTokens() - 1];
 203 //                      methodName= tokenizer.nextToken();
 204 //                      int i = 0;
 205 //                      while (tokenizer.hasMoreTokens()) {
 206 //                              parameterTypes[i] = tokenizer.nextToken();
 207 //                              i++;
 208 //                      }
 209 //              }
 210 //              return type.getMethod(methodName, parameterTypes);
 211 //      }
 212 //
 213 //      //binary type
 214 //      return cf.getType();
 215 //}
 216 /**
 217  * Returns the <code>IPackageFragmentRoot</code> represented by the <code>String</code>
 218  * memento.
 219  * @see getHandleMemento()
 220  */
 221 //protected IPackageFragmentRoot getHandleFromMementoForRoot(String memento, JavaProject project, int projectEnd, int rootEnd) {
 222 //      String rootName = null;
 223 //      if (rootEnd == projectEnd - 1) {
 224 //              //default root
 225 //              rootName = IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH;
 226 //      } else {
 227 //              rootName = memento.substring(projectEnd + 1, rootEnd);
 228 //      }
 229 //      return project.getPackageFragmentRoot(new Path(rootName));
 230 //}
 231 /**
 232  * Returns the <code>IJavaElement</code> represented by the <code>String</code>
 233  * memento.
 234  * @see getHandleMemento()
 235  */
 236 //protected IJavaElement getHandleFromMementoForSourceMembers(String memento, IPackageFragmentRoot root, int rootEnd, int end) throws JavaModelException {
 237 //
 238 //      //deal with compilation units and source members
 239 //      IPackageFragment frag = null;
 240 //      if (rootEnd == end - 1) {
 241 //              //default package
 242 //              frag= root.getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
 243 //      } else {
 244 //              frag= root.getPackageFragment(memento.substring(rootEnd + 1, end));
 245 //      }
 246 //      int oldEnd = end;
 247 //      end = memento.indexOf(JavaElement.JEM_PACKAGEDECLARATION, end);
 248 //      if (end != -1) {
 249 //              //package declaration
 250 //              ICompilationUnit cu = frag.getCompilationUnit(memento.substring(oldEnd + 1, end));
 251 //              return cu.getPackageDeclaration(memento.substring(end + 1));
 252 //      }
 253 //      end = memento.indexOf(JavaElement.JEM_IMPORTDECLARATION, oldEnd);
 254 //      if (end != -1) {
 255 //              //import declaration
 256 //              ICompilationUnit cu = frag.getCompilationUnit(memento.substring(oldEnd + 1, end));
 257 //              return cu.getImport(memento.substring(end + 1));
 258 //      }
 259 //      int typeStart = memento.indexOf(JavaElement.JEM_TYPE, oldEnd);
 260 //      if (typeStart == -1) {
 261 //              //we ended with a compilation unit
 262 //              return frag.getCompilationUnit(memento.substring(oldEnd + 1));
 263 //      }
 264 //
 265 //      //source members
 266 //      ICompilationUnit cu = frag.getCompilationUnit(memento.substring(oldEnd + 1, typeStart));
 267 //      end = memento.indexOf(JavaElement.JEM_FIELD, oldEnd);
 268 //      if (end != -1) {
 269 //              //source field
 270 //              IType type = getHandleFromMementoForSourceType(memento, cu, typeStart, end);
 271 //              return type.getField(memento.substring(end + 1));
 272 //      }
 273 //      end = memento.indexOf(JavaElement.JEM_METHOD, oldEnd);
 274 //      if (end != -1) {
 275 //              //source method
 276 //              IType type = getHandleFromMementoForSourceType(memento, cu, typeStart, end);
 277 //              oldEnd = end;
 278 //              String methodName;
 279 //              end = memento.lastIndexOf(JavaElement.JEM_METHOD);
 280 //              String[] parameterTypes = null;
 281 //              if (end == oldEnd) {
 282 //                      methodName = memento.substring(end + 1);
 283 //                      //no parameter types
 284 //                      parameterTypes = new String[] {};
 285 //              } else {
 286 //                      String parameters = memento.substring(oldEnd + 1);
 287 //                      StringTokenizer mTokenizer = new StringTokenizer(parameters, new String(new char[] {JavaElement.JEM_METHOD}));
 288 //                      parameterTypes = new String[mTokenizer.countTokens() - 1];
 289 //                      methodName = mTokenizer.nextToken();
 290 //                      int i = 0;
 291 //                      while (mTokenizer.hasMoreTokens()) {
 292 //                              parameterTypes[i] = mTokenizer.nextToken();
 293 //                              i++;
 294 //                      }
 295 //              }
 296 //              return type.getMethod(methodName, parameterTypes);
 297 //      }
 298 //
 299 //      end = memento.indexOf(JavaElement.JEM_INITIALIZER, oldEnd);
 300 //      if (end != -1 ) {
 301 //              //initializer
 302 //              IType type = getHandleFromMementoForSourceType(memento, cu, typeStart, end);
 303 //              return type.getInitializer(Integer.parseInt(memento.substring(end + 1)));
 304 //      }
 305 //      //source type
 306 //      return getHandleFromMementoForSourceType(memento, cu, typeStart, memento.length());
 307 //}
 308 /**
 309  * Returns the <code>IJavaElement</code> represented by the <code>String</code>
 310  * memento.
 311  * @see getHandleMemento()
 312  */
 313 //protected IType getHandleFromMementoForSourceType(String memento, ICompilationUnit cu, int typeStart, int typeEnd) throws JavaModelException {
 314 //      int end = memento.lastIndexOf(JavaElement.JEM_TYPE);
 315 //      IType type = null;
 316 //      if (end == typeStart) {
 317 //              String typeName = memento.substring(typeStart + 1, typeEnd);
 318 //              type = cu.getType(typeName);
 319 //
 320 //      } else {
 321 //              String typeNames = memento.substring(typeStart + 1, typeEnd);
 322 //              StringTokenizer tokenizer = new StringTokenizer(typeNames, new String(new char[] {JavaElement.JEM_TYPE}));
 323 //              type = cu.getType(tokenizer.nextToken());
 324 //              while (tokenizer.hasMoreTokens()) {
 325 //                      //deal with inner types
 326 //                      type= type.getType(tokenizer.nextToken());
 327 //              }
 328 //      }
 329 //      return type;
 330 //}
 331 /**
 332  * @see JavaElement#getHandleMemento()
 333  */
 334 public String getHandleMemento(){
 335         return getElementName();
 336 }
 337 /**
 338  * Returns the <code>char</code> that marks the start of this handles
 339  * contribution to a memento.
 340  */
 341 protected char getHandleMementoDelimiter(){
 342         Assert.isTrue(false, "Should not be called"); //$NON-NLS-1$
 343         return 0;
 344 }
 345 /**
 346  * @see IJavaModel
 347  */
 348 public IJavaProject getJavaProject(String name) {
 349         return new JavaProject(ResourcesPlugin.getWorkspace().getRoot().getProject(name), this);
 350 }
 351 /**
 352  * Returns the active Java project associated with the specified
 353  * resource, or <code>null</code> if no Java project yet exists
 354  * for the resource.
 355  *
 356  * @exception IllegalArgumentException if the given resource
 357  * is not one of an IProject, IFolder, or IFile.
 358  */
 359 public IJavaProject getJavaProject(IResource resource) {
 360         switch(resource.getType()){
 361                 case IResource.FOLDER:
 362                         return new JavaProject(((IFolder)resource).getProject(), this);
 363                 case IResource.FILE:
 364                         return new JavaProject(((IFile)resource).getProject(), this);
 365                 case IResource.PROJECT:
 366                         return new JavaProject((IProject)resource, this);
 367                 default:
 368                         throw new IllegalArgumentException(Util.bind("element.invalidResourceForProject")); //$NON-NLS-1$
 369         }
 370 }
 371 /**
 372  * @see IJavaModel
 373  */
 374 public IJavaProject[] getJavaProjects() throws JavaModelException {
 375         ArrayList list = getChildrenOfType(JAVA_PROJECT);
 376         IJavaProject[] array= new IJavaProject[list.size()];
 377         list.toArray(array);
 378         return array;
 379
 380 }
 381 ///**
 382 // * @see IJavaModel
 383 // */
 384 //public Object[] getNonJavaResources() throws JavaModelException {
 385 //              return ((JavaModelInfo) getElementInfo()).getNonJavaResources();
 386 //}
 387
 388 /**
 389  * Workaround for bug 15168 circular errors not reported
 390  * Returns the list of java projects before resource delta processing
 391  * has started.
 392  */
 393 public IJavaProject[] getOldJavaProjectsList() throws JavaModelException {
 394         JavaModelManager manager = JavaModelManager.getJavaModelManager();
 395         return
 396                 manager.javaProjectsCache == null ?
 397                         this.getJavaProjects() :
 398                         manager.javaProjectsCache;
 399 }
 400 /*
 401  * @see IJavaElement
 402  */
 403 public IPath getPath() {
 404         return Path.ROOT;
 405 }
 406 /*
 407  * @see IJavaElement
 408  */
 409 public IResource getResource() {
 410         return ResourcesPlugin.getWorkspace().getRoot();
 411 }
 412 /**
 413  * @see IOpenable
 414  */
 415 public IResource getUnderlyingResource() throws JavaModelException {
 416         return null;
 417 }
 418 /**
 419  * Returns the workbench associated with this object.
 420  */
 421 public IWorkspace getWorkspace() {
 422         return ResourcesPlugin.getWorkspace();
 423 }
 424
 425 /**
 426  * @see IJavaModel
 427  */
 428 //public void move(IJavaElement[] elements, IJavaElement[] containers, IJavaElement[] siblings, String[] renamings, boolean force, IProgressMonitor monitor) throws JavaModelException {
 429 //      if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
 430 //              runOperation(new MoveResourceElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
 431 //      } else {
 432 //              runOperation(new MoveElementsOperation(elements, containers, force), elements, siblings, renamings, monitor);
 433 //      }
 434 //}
 435
 436 /**
 437  * @see IJavaModel#refreshExternalArchives(IJavaElement[], IProgressMonitor)
 438  */
 439 //public void refreshExternalArchives(IJavaElement[] elementsScope, IProgressMonitor monitor) throws JavaModelException {
 440 //      if (elementsScope == null){
 441 //              elementsScope = new IJavaElement[] { this };
 442 //      }
 443 //      JavaModelManager.getJavaModelManager().deltaProcessor.checkExternalArchiveChanges(elementsScope, monitor);
 444 //}
 445
 446 /**
 447  * @see IJavaModel
 448  */
 449 //public void rename(IJavaElement[] elements, IJavaElement[] destinations, String[] renamings, boolean force, IProgressMonitor monitor) throws JavaModelException {
 450 //      MultiOperation op;
 451 //      if (elements != null && elements.length > 0 && elements[0] != null && elements[0].getElementType() < IJavaElement.TYPE) {
 452 //              op = new RenameResourceElementsOperation(elements, destinations, renamings, force);
 453 //      } else {
 454 //              op = new RenameElementsOperation(elements, destinations, renamings, force);
 455 //      }
 456 //
 457 //      runOperation(op, monitor);
 458 //}
 459 /*
 460  * @see JavaElement#rootedAt(IJavaProject)
 461  */
 462 public IJavaElement rootedAt(IJavaProject project) {
 463         return this;
 464
 465 }
 466 /**
 467  * Configures and runs the <code>MultiOperation</code>.
 468  */
 469 //protected void runOperation(MultiOperation op, IJavaElement[] elements, IJavaElement[] siblings, String[] renamings, IProgressMonitor monitor) throws JavaModelException {
 470 //      op.setRenamings(renamings);
 471 //      if (siblings != null) {
 472 //              for (int i = 0; i < elements.length; i++) {
 473 //                      op.setInsertBefore(elements[i], siblings[i]);
 474 //              }
 475 //      }
 476 //      runOperation(op, monitor);
 477 //}
 478 /**
 479  * @private Debugging purposes
 480  */
 481 protected void toStringInfo(int tab, StringBuffer buffer, Object info) {
 482         buffer.append(this.tabString(tab));
 483         buffer.append("Java Model"); //$NON-NLS-1$
 484         if (info == null) {
 485                 buffer.append(" (not open)"); //$NON-NLS-1$
 486         }
 487 }
 488
 489 /**
 490  * Helper method - returns the targeted item (IResource if internal or java.io.File if external),
 491  * or null if unbound
 492  * Internal items must be referred to using container relative paths.
 493  */
 494 //public static Object getTarget(IContainer container, IPath path, boolean checkResourceExistence) {
 495 //
 496 //      if (path == null) return null;
 497 //
 498 //      // lookup - inside the container
 499 //      if (path.getDevice() == null) { // container relative paths should not contain a device
 500 //                                                                                              // (see http://dev.eclipse.org/bugs/show_bug.cgi?id=18684)
 501 //                                                                                              // (case of a workspace rooted at d:\ )
 502 //              IResource resource = container.findMember(path);
 503 //              if (resource != null){
 504 //                      if (!checkResourceExistence ||resource.exists()) return resource;
 505 //                      return null;
 506 //              }
 507 //      }
 508 //
 509 //      // if path is relative, it cannot be an external path
 510 //      // (see http://dev.eclipse.org/bugs/show_bug.cgi?id=22517)
 511 //      if (!path.isAbsolute()) return null;
 512 //
 513 //      // lookup - outside the container
 514 //      File externalFile = new File(path.toOSString());
 515 //      if (!checkResourceExistence) {
 516 //              return externalFile;
 517 //      } else if (existingExternalFiles.contains(externalFile)) {
 518 //              return externalFile;
 519 //      } else {
 520 //              if (JavaModelManager.ZIP_ACCESS_VERBOSE) {
 521 //                      System.out.println("(" + Thread.currentThread() + ") [JavaModel.getTarget(...)] Checking existence of " + path.toString()); //$NON-NLS-1$ //$NON-NLS-2$
 522 //              }
 523 //              if (externalFile.exists()) {
 524 //                      // cache external file
 525 //                      existingExternalFiles.add(externalFile);
 526 //                      return externalFile;
 527 //              }
 528 //      }
 529 //      return null;
 530 //}
 531 }