case-study/jdt-before/core extension/org/eclipse/jdt/internal/corext/util/JavaElementResourceMapping.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package org.eclipse.jdt.internal.corext.util;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Set;
  18
  19 import org.eclipse.core.runtime.Assert;
  20 import org.eclipse.core.runtime.CoreException;
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.core.runtime.IStatus;
  23
  24 import org.eclipse.core.resources.IContainer;
  25 import org.eclipse.core.resources.IFolder;
  26 import org.eclipse.core.resources.IProject;
  27 import org.eclipse.core.resources.IResource;
  28 import org.eclipse.core.resources.mapping.RemoteResourceMappingContext;
  29 import org.eclipse.core.resources.mapping.ResourceMapping;
  30 import org.eclipse.core.resources.mapping.ResourceMappingContext;
  31 import org.eclipse.core.resources.mapping.ResourceTraversal;
  32
  33 import org.eclipse.jdt.core.IClassFile;
  34 import org.eclipse.jdt.core.ICompilationUnit;
  35 import org.eclipse.jdt.core.IJavaElement;
  36 import org.eclipse.jdt.core.IJavaModel;
  37 import org.eclipse.jdt.core.IJavaProject;
  38 import org.eclipse.jdt.core.IPackageFragment;
  39 import org.eclipse.jdt.core.IPackageFragmentRoot;
  40 import org.eclipse.jdt.core.IType;
  41 import org.eclipse.jdt.core.JavaModelException;
  42
  43 import org.eclipse.jdt.internal.ui.JavaPlugin;
  44 import org.eclipse.jdt.internal.ui.browsing.LogicalPackage;
  45 import org.eclipse.jdt.internal.ui.model.JavaModelProvider;
  46
  47 /**
  48  * An abstract super class to describe mappings from a Java element to a
  49  * set of resources. The class also provides factory methods to create
  50  * resource mappings.
  51  *
  52  * @since 3.1
  53  */
  54 public abstract class JavaElementResourceMapping extends ResourceMapping {
  55
  56         protected JavaElementResourceMapping() {
  57         }
  58
  59         public IJavaElement getJavaElement() {
  60                 Object o= getModelObject();
  61                 if (o instanceof IJavaElement)
  62                         return (IJavaElement)o;
  63                 return null;
  64         }
  65
  66         @Override
  67         public boolean equals(Object obj) {
  68                 if (!(obj instanceof JavaElementResourceMapping))
  69                         return false;
  70                 return getJavaElement().equals(((JavaElementResourceMapping)obj).getJavaElement());
  71         }
  72
  73         @Override
  74         public int hashCode() {
  75                 IJavaElement javaElement= getJavaElement();
  76                 if (javaElement == null)
  77                         return super.hashCode();
  78
  79                 return javaElement.hashCode();
  80         }
  81
  82         @Override
  83         public String getModelProviderId() {
  84                 return JavaModelProvider.JAVA_MODEL_PROVIDER_ID;
  85         }
  86
  87         @Override
  88         public boolean contains(ResourceMapping mapping) {
  89                 if (mapping instanceof JavaElementResourceMapping) {
  90                         JavaElementResourceMapping javaMapping = (JavaElementResourceMapping) mapping;
  91                         IJavaElement element = getJavaElement();
  92                         IJavaElement other = javaMapping.getJavaElement();
  93                         if (other != null && element != null)
  94                                 return element.getPath().isPrefixOf(other.getPath());
  95                 }
  96                 return false;
  97         }
  98
  99         //---- the factory code ---------------------------------------------------------------
 100
 101         private static final class JavaModelResourceMapping extends JavaElementResourceMapping {
 102                 private final IJavaModel fJavaModel;
 103                 private JavaModelResourceMapping(IJavaModel model) {
 104                         Assert.isNotNull(model);
 105                         fJavaModel= model;
 106                 }
 107                 @Override
 108                 public Object getModelObject() {
 109                         return fJavaModel;
 110                 }
 111                 @Override
 112                 public IProject[] getProjects() {
 113                         IJavaProject[] projects= null;
 114                         try {
 115                                 projects= fJavaModel.getJavaProjects();
 116                         } catch (JavaModelException e) {
 117                                 JavaPlugin.log(e);
 118                                 return new IProject[0];
 119                         }
 120                         IProject[] result= new IProject[projects.length];
 121                         for (int i= 0; i < projects.length; i++) {
 122                                 result[i]= projects[i].getProject();
 123                         }
 124                         return result;
 125                 }
 126                 @Override
 127                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 128                         IJavaProject[] projects= fJavaModel.getJavaProjects();
 129                         ResourceTraversal[] result= new ResourceTraversal[projects.length];
 130                         for (int i= 0; i < projects.length; i++) {
 131                                 result[i]= new ResourceTraversal(new IResource[] {projects[i].getProject()}, IResource.DEPTH_INFINITE, 0);
 132                         }
 133                         return result;
 134                 }
 135         }
 136
 137         private static final class JavaProjectResourceMapping extends JavaElementResourceMapping {
 138                 private final IJavaProject fProject;
 139                 private JavaProjectResourceMapping(IJavaProject project) {
 140                         Assert.isNotNull(project);
 141                         fProject= project;
 142                 }
 143                 @Override
 144                 public Object getModelObject() {
 145                         return fProject;
 146                 }
 147                 @Override
 148                 public IProject[] getProjects() {
 149                         return new IProject[] {fProject.getProject() };
 150                 }
 151                 @Override
 152                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 153                         return new ResourceTraversal[] {
 154                                 new ResourceTraversal(new IResource[] {fProject.getProject()}, IResource.DEPTH_INFINITE, 0)
 155                         };
 156                 }
 157         }
 158
 159         private static final class PackageFragementRootResourceMapping extends JavaElementResourceMapping {
 160                 private final IPackageFragmentRoot fRoot;
 161                 private PackageFragementRootResourceMapping(IPackageFragmentRoot root) {
 162                         Assert.isNotNull(root);
 163                         fRoot= root;
 164                 }
 165                 @Override
 166                 public Object getModelObject() {
 167                         return fRoot;
 168                 }
 169                 @Override
 170                 public IProject[] getProjects() {
 171                         return new IProject[] {fRoot.getJavaProject().getProject() };
 172                 }
 173                 @Override
 174                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 175                         return new ResourceTraversal[] {
 176                                 new ResourceTraversal(new IResource[] {fRoot.getResource()}, IResource.DEPTH_INFINITE, 0)
 177                         };
 178                 }
 179         }
 180
 181         private static final class PackageFragmentResourceMapping extends JavaElementResourceMapping {
 182                 private final IPackageFragment fPack;
 183                 private PackageFragmentResourceMapping(IPackageFragment pack) {
 184                         Assert.isNotNull(pack);
 185                         fPack= pack;
 186                 }
 187                 @Override
 188                 public Object getModelObject() {
 189                         return fPack;
 190                 }
 191                 @Override
 192                 public IProject[] getProjects() {
 193                         return new IProject[] { fPack.getJavaProject().getProject() };
 194                 }
 195                 @Override
 196                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 197                         if (context instanceof RemoteResourceMappingContext) {
 198                                 return getRemotePackageFragmentTraversals(fPack, (RemoteResourceMappingContext)context, monitor);
 199                         } else {
 200                                 return getPackageFragmentTraversals(fPack);
 201                         }
 202                 }
 203         }
 204
 205         private static ResourceTraversal[] getPackageFragmentTraversals(IPackageFragment pack) throws CoreException {
 206                 ArrayList<ResourceTraversal> res= new ArrayList<ResourceTraversal>();
 207                 IContainer container= (IContainer)pack.getResource();
 208
 209                 if (container != null) {
 210                         res.add(new ResourceTraversal(new IResource[] { container }, IResource.DEPTH_ONE, 0));
 211                         if (pack.exists()) { // folder may not exist any more, see https://bugs.eclipse.org/bugs/show_bug.cgi?id=269167
 212                                 Object[] nonJavaResources= pack.getNonJavaResources();
 213                                 for (int i= 0; i < nonJavaResources.length; i++) {
 214                                         Object resource= nonJavaResources[i];
 215                                         if (resource instanceof IFolder) {
 216                                                 res.add(new ResourceTraversal(new IResource[] { (IResource)resource }, IResource.DEPTH_INFINITE, 0));
 217                                         }
 218                                 }
 219                         }
 220                 }
 221
 222                 return res.toArray(new ResourceTraversal[res.size()]);
 223         }
 224
 225         private static ResourceTraversal[] getRemotePackageFragmentTraversals(IPackageFragment pack, RemoteResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 226                 ArrayList<ResourceTraversal> res= new ArrayList<ResourceTraversal>();
 227                 IContainer container= (IContainer)pack.getResource();
 228
 229                 if (container != null) {
 230                         res.add(new ResourceTraversal(new IResource[] {container}, IResource.DEPTH_ONE, 0));
 231                         IResource[] remoteMembers= context.fetchRemoteMembers(container, monitor);
 232                         if (remoteMembers == null) {
 233                                 remoteMembers= context.fetchMembers(container, monitor);
 234                         }
 235                         if (remoteMembers != null) {
 236                                 for (int i= 0; i < remoteMembers.length; i++) {
 237                                         IResource member= remoteMembers[i];
 238                                         if (member instanceof IFolder
 239                                                         && JavaConventionsUtil.validatePackageName(member.getName(), pack).getSeverity() == IStatus.ERROR) {
 240                                                 res.add(new ResourceTraversal(new IResource[] { member }, IResource.DEPTH_INFINITE, 0));
 241                                         }
 242                                 }
 243                         }
 244                 }
 245                 return res.toArray(new ResourceTraversal[res.size()]);
 246         }
 247
 248         private static final class CompilationUnitResourceMapping extends JavaElementResourceMapping {
 249                 private final ICompilationUnit fUnit;
 250                 private CompilationUnitResourceMapping(ICompilationUnit unit) {
 251                         Assert.isNotNull(unit);
 252                         fUnit= unit;
 253                 }
 254                 @Override
 255                 public Object getModelObject() {
 256                         return fUnit;
 257                 }
 258                 @Override
 259                 public IProject[] getProjects() {
 260                         return new IProject[] {fUnit.getJavaProject().getProject() };
 261                 }
 262                 @Override
 263                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 264                         return new ResourceTraversal[] {
 265                                 new ResourceTraversal(new IResource[] {fUnit.getResource()}, IResource.DEPTH_ONE, 0)
 266                         };
 267                 }
 268         }
 269
 270         private static final class ClassFileResourceMapping extends JavaElementResourceMapping {
 271                 private final IClassFile fClassFile;
 272                 private ClassFileResourceMapping(IClassFile classFile) {
 273                         fClassFile= classFile;
 274                 }
 275                 @Override
 276                 public Object getModelObject() {
 277                         return fClassFile;
 278                 }
 279                 @Override
 280                 public IProject[] getProjects() {
 281                         return new IProject[] { fClassFile.getJavaProject().getProject() };
 282                 }
 283                 @Override
 284                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 285                         return new ResourceTraversal[] {
 286                                 new ResourceTraversal(new IResource[] {fClassFile.getResource()}, IResource.DEPTH_ONE, 0)
 287                         };
 288                 }
 289         }
 290
 291         private static final class LogicalPackageResourceMapping extends ResourceMapping {
 292                 private final IPackageFragment[] fFragments;
 293                 private LogicalPackageResourceMapping(IPackageFragment[] fragments) {
 294                         fFragments= fragments;
 295                 }
 296                 @Override
 297                 public Object getModelObject() {
 298                         return fFragments;
 299                 }
 300                 @Override
 301                 public IProject[] getProjects() {
 302                         Set<IProject> result= new HashSet<IProject>();
 303                         for (int i= 0; i < fFragments.length; i++) {
 304                                 result.add(fFragments[i].getJavaProject().getProject());
 305                         }
 306                         return result.toArray(new IProject[result.size()]);
 307                 }
 308                 @Override
 309                 public ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException {
 310                         List<ResourceTraversal> result= new ArrayList<ResourceTraversal>();
 311                         if (context instanceof RemoteResourceMappingContext) {
 312                                 for (int i= 0; i < fFragments.length; i++) {
 313                                         result.addAll(Arrays.asList(getRemotePackageFragmentTraversals(fFragments[i], (RemoteResourceMappingContext)context, monitor)));
 314                                 }
 315                         } else {
 316                                 for (int i= 0; i < fFragments.length; i++) {
 317                                         result.addAll(Arrays.asList(getPackageFragmentTraversals(fFragments[i])));
 318                                 }
 319                         }
 320                         return result.toArray(new ResourceTraversal[result.size()]);
 321                 }
 322
 323                 @Override
 324                 public String getModelProviderId() {
 325                         return JavaModelProvider.JAVA_MODEL_PROVIDER_ID;
 326                 }
 327         }
 328
 329         public static ResourceMapping create(IJavaElement element) {
 330                 switch (element.getElementType()) {
 331                         case IJavaElement.TYPE:
 332                                 return create((IType)element);
 333                         case IJavaElement.COMPILATION_UNIT:
 334                                 return create((ICompilationUnit)element);
 335                         case IJavaElement.CLASS_FILE:
 336                                 return create((IClassFile)element);
 337                         case IJavaElement.PACKAGE_FRAGMENT:
 338                                 return create((IPackageFragment)element);
 339                         case IJavaElement.PACKAGE_FRAGMENT_ROOT:
 340                                 return create((IPackageFragmentRoot)element);
 341                         case IJavaElement.JAVA_PROJECT:
 342                                 return create((IJavaProject)element);
 343                         case IJavaElement.JAVA_MODEL:
 344                                 return create((IJavaModel)element);
 345                         default:
 346                                 return null;
 347                 }
 348
 349         }
 350
 351         public static ResourceMapping create(final IJavaModel model) {
 352                 return new JavaModelResourceMapping(model);
 353         }
 354
 355         public static ResourceMapping create(final IJavaProject project) {
 356                 return new JavaProjectResourceMapping(project);
 357         }
 358
 359         public static ResourceMapping create(final IPackageFragmentRoot root) {
 360                 if (root.isExternal())
 361                         return null;
 362                 return new PackageFragementRootResourceMapping(root);
 363         }
 364
 365         public static ResourceMapping create(final IPackageFragment pack) {
 366                 // test if in an archive
 367                 IPackageFragmentRoot root= (IPackageFragmentRoot)pack.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
 368                 if (!root.isArchive() && !root.isExternal()) {
 369                         return new PackageFragmentResourceMapping(pack);
 370                 }
 371                 return null;
 372         }
 373
 374         public static ResourceMapping create(ICompilationUnit unit) {
 375                 if (unit == null)
 376                         return null;
 377                 return new CompilationUnitResourceMapping(unit.getPrimary());
 378         }
 379
 380         public static ResourceMapping create(IClassFile classFile) {
 381                 // test if in a archive
 382                 IPackageFragmentRoot root= (IPackageFragmentRoot)classFile.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
 383                 if (!root.isArchive() && !root.isExternal()) {
 384                         return new ClassFileResourceMapping(classFile);
 385                 }
 386                 return null;
 387         }
 388
 389         public static ResourceMapping create(IType type) {
 390                 // top level types behave like the CU
 391                 IJavaElement parent= type.getParent();
 392                 if (parent instanceof ICompilationUnit) {
 393                         return create((ICompilationUnit)parent);
 394                 }
 395                 return null;
 396         }
 397
 398         public static ResourceMapping create(LogicalPackage logicalPackage) {
 399                 IPackageFragment[] fragments= logicalPackage.getFragments();
 400                 List<IPackageFragment> toProcess= new ArrayList<IPackageFragment>(fragments.length);
 401                 for (int i= 0; i < fragments.length; i++) {
 402                         // only add if not part of an archive
 403                         IPackageFragmentRoot root= (IPackageFragmentRoot)fragments[i].getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
 404                         if (!root.isArchive() && !root.isExternal()) {
 405                                 toProcess.add(fragments[i]);
 406                         }
 407                 }
 408                 if (toProcess.size() == 0)
 409                         return null;
 410                 return new LogicalPackageResourceMapping(toProcess.toArray(new IPackageFragment[toProcess.size()]));
 411         }
 412 }