001: /*******************************************************************************
002: * Copyright (c) 2000, 2006 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.corext.util;
011:
012: import java.util.ArrayList;
013: import java.util.HashSet;
014: import java.util.List;
015: import java.util.Set;
016:
017: import org.eclipse.core.resources.mapping.RemoteResourceMappingContext;
018: import org.eclipse.core.resources.mapping.ResourceMapping;
019: import org.eclipse.core.resources.mapping.ResourceMappingContext;
020: import org.eclipse.core.resources.mapping.ResourceTraversal;
021:
022: import org.eclipse.core.runtime.Assert;
023: import org.eclipse.core.runtime.CoreException;
024: import org.eclipse.core.runtime.IProgressMonitor;
025: import org.eclipse.core.runtime.NullProgressMonitor;
026:
027: import org.eclipse.core.resources.IContainer;
028: import org.eclipse.core.resources.IFile;
029: import org.eclipse.core.resources.IProject;
030: import org.eclipse.core.resources.IResource;
031: import org.eclipse.core.resources.IResourceVisitor;
032:
033: import org.eclipse.jdt.core.IClassFile;
034: import org.eclipse.jdt.core.ICompilationUnit;
035: import org.eclipse.jdt.core.IJavaElement;
036: import org.eclipse.jdt.core.IJavaModel;
037: import org.eclipse.jdt.core.IJavaProject;
038: import org.eclipse.jdt.core.IPackageFragment;
039: import org.eclipse.jdt.core.IPackageFragmentRoot;
040: import org.eclipse.jdt.core.IType;
041: import org.eclipse.jdt.core.JavaModelException;
042:
043: import org.eclipse.jdt.internal.ui.JavaPlugin;
044: import org.eclipse.jdt.internal.ui.browsing.LogicalPackage;
045: import org.eclipse.jdt.internal.ui.model.JavaModelProvider;
046:
047: /**
048: * An abstract super class to describe mappings from a Java element to a
049: * set of resources. The class also provides factory methods to create
050: * resource mappings.
051: *
052: * @since 3.1
053: */
054: public abstract class JavaElementResourceMapping extends
055: ResourceMapping {
056:
057: protected JavaElementResourceMapping() {
058: }
059:
060: public IJavaElement getJavaElement() {
061: Object o = getModelObject();
062: if (o instanceof IJavaElement)
063: return (IJavaElement) o;
064: return null;
065: }
066:
067: public boolean equals(Object obj) {
068: if (!(obj instanceof JavaElementResourceMapping))
069: return false;
070: return getJavaElement().equals(
071: ((JavaElementResourceMapping) obj).getJavaElement());
072: }
073:
074: public int hashCode() {
075: IJavaElement javaElement = getJavaElement();
076: if (javaElement == null)
077: return super .hashCode();
078:
079: return javaElement.hashCode();
080: }
081:
082: public String getModelProviderId() {
083: return JavaModelProvider.JAVA_MODEL_PROVIDER_ID;
084: }
085:
086: public boolean contains(ResourceMapping mapping) {
087: if (mapping instanceof JavaElementResourceMapping) {
088: JavaElementResourceMapping javaMapping = (JavaElementResourceMapping) mapping;
089: IJavaElement element = getJavaElement();
090: IJavaElement other = javaMapping.getJavaElement();
091: if (other != null && element != null)
092: return element.getPath().isPrefixOf(other.getPath());
093: }
094: return false;
095: }
096:
097: //---- the factory code ---------------------------------------------------------------
098:
099: private static final class JavaModelResourceMapping extends
100: JavaElementResourceMapping {
101: private final IJavaModel fJavaModel;
102:
103: private JavaModelResourceMapping(IJavaModel model) {
104: Assert.isNotNull(model);
105: fJavaModel = model;
106: }
107:
108: public Object getModelObject() {
109: return fJavaModel;
110: }
111:
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:
127: public ResourceTraversal[] getTraversals(
128: ResourceMappingContext context, IProgressMonitor monitor)
129: throws CoreException {
130: IJavaProject[] projects = fJavaModel.getJavaProjects();
131: ResourceTraversal[] result = new ResourceTraversal[projects.length];
132: for (int i = 0; i < projects.length; i++) {
133: result[i] = new ResourceTraversal(
134: new IResource[] { projects[i].getProject() },
135: IResource.DEPTH_INFINITE, 0);
136: }
137: return result;
138: }
139: }
140:
141: private static final class JavaProjectResourceMapping extends
142: JavaElementResourceMapping {
143: private final IJavaProject fProject;
144:
145: private JavaProjectResourceMapping(IJavaProject project) {
146: Assert.isNotNull(project);
147: fProject = project;
148: }
149:
150: public Object getModelObject() {
151: return fProject;
152: }
153:
154: public IProject[] getProjects() {
155: return new IProject[] { fProject.getProject() };
156: }
157:
158: public ResourceTraversal[] getTraversals(
159: ResourceMappingContext context, IProgressMonitor monitor)
160: throws CoreException {
161: return new ResourceTraversal[] { new ResourceTraversal(
162: new IResource[] { fProject.getProject() },
163: IResource.DEPTH_INFINITE, 0) };
164: }
165: }
166:
167: private static final class PackageFragementRootResourceMapping
168: extends JavaElementResourceMapping {
169: private final IPackageFragmentRoot fRoot;
170:
171: private PackageFragementRootResourceMapping(
172: IPackageFragmentRoot root) {
173: Assert.isNotNull(root);
174: fRoot = root;
175: }
176:
177: public Object getModelObject() {
178: return fRoot;
179: }
180:
181: public IProject[] getProjects() {
182: return new IProject[] { fRoot.getJavaProject().getProject() };
183: }
184:
185: public ResourceTraversal[] getTraversals(
186: ResourceMappingContext context, IProgressMonitor monitor)
187: throws CoreException {
188: return new ResourceTraversal[] { new ResourceTraversal(
189: new IResource[] { fRoot.getResource() },
190: IResource.DEPTH_INFINITE, 0) };
191: }
192: }
193:
194: private static final class LocalPackageFragementTraversal extends
195: ResourceTraversal {
196: private final IPackageFragment fPack;
197:
198: public LocalPackageFragementTraversal(IPackageFragment pack)
199: throws CoreException {
200: super (new IResource[] { pack.getResource() },
201: IResource.DEPTH_ONE, 0);
202: fPack = pack;
203: }
204:
205: public void accept(IResourceVisitor visitor)
206: throws CoreException {
207: IFile[] files = getPackageContent(fPack);
208: final IResource resource = fPack.getResource();
209: if (resource != null)
210: visitor.visit(resource);
211: for (int i = 0; i < files.length; i++) {
212: visitor.visit(files[i]);
213: }
214: }
215: }
216:
217: private static final class PackageFragmentResourceMapping extends
218: JavaElementResourceMapping {
219: private final IPackageFragment fPack;
220:
221: private PackageFragmentResourceMapping(IPackageFragment pack) {
222: Assert.isNotNull(pack);
223: fPack = pack;
224: }
225:
226: public Object getModelObject() {
227: return fPack;
228: }
229:
230: public IProject[] getProjects() {
231: return new IProject[] { fPack.getJavaProject().getProject() };
232: }
233:
234: public ResourceTraversal[] getTraversals(
235: ResourceMappingContext context, IProgressMonitor monitor)
236: throws CoreException {
237: if (context instanceof RemoteResourceMappingContext) {
238: return new ResourceTraversal[] { new ResourceTraversal(
239: new IResource[] { fPack.getResource() },
240: IResource.DEPTH_ONE, 0) };
241: } else {
242: return new ResourceTraversal[] { new LocalPackageFragementTraversal(
243: fPack) };
244: }
245: }
246:
247: public void accept(ResourceMappingContext context,
248: IResourceVisitor visitor, IProgressMonitor monitor)
249: throws CoreException {
250: if (context instanceof RemoteResourceMappingContext) {
251: super .accept(context, visitor, monitor);
252: } else {
253: // We assume a local context.
254: IFile[] files = getPackageContent(fPack);
255: if (monitor == null)
256: monitor = new NullProgressMonitor();
257: monitor.beginTask("", files.length + 1); //$NON-NLS-1$
258: final IResource resource = fPack.getResource();
259: if (resource != null)
260: visitor.visit(resource);
261: monitor.worked(1);
262: for (int i = 0; i < files.length; i++) {
263: visitor.visit(files[i]);
264: monitor.worked(1);
265: }
266: }
267: }
268: }
269:
270: private static IFile[] getPackageContent(IPackageFragment pack)
271: throws CoreException {
272: List result = new ArrayList();
273: IContainer container = (IContainer) pack.getResource();
274: if (container != null) {
275: IResource[] members = container.members();
276: for (int m = 0; m < members.length; m++) {
277: IResource member = members[m];
278: if (member instanceof IFile) {
279: IFile file = (IFile) member;
280: if ("class".equals(file.getFileExtension()) && file.isDerived()) //$NON-NLS-1$
281: continue;
282: result.add(member);
283: }
284: }
285: }
286: return (IFile[]) result.toArray(new IFile[result.size()]);
287: }
288:
289: private static final class CompilationUnitResourceMapping extends
290: JavaElementResourceMapping {
291: private final ICompilationUnit fUnit;
292:
293: private CompilationUnitResourceMapping(ICompilationUnit unit) {
294: Assert.isNotNull(unit);
295: fUnit = unit;
296: }
297:
298: public Object getModelObject() {
299: return fUnit;
300: }
301:
302: public IProject[] getProjects() {
303: return new IProject[] { fUnit.getJavaProject().getProject() };
304: }
305:
306: public ResourceTraversal[] getTraversals(
307: ResourceMappingContext context, IProgressMonitor monitor)
308: throws CoreException {
309: return new ResourceTraversal[] { new ResourceTraversal(
310: new IResource[] { fUnit.getResource() },
311: IResource.DEPTH_ONE, 0) };
312: }
313: }
314:
315: private static final class ClassFileResourceMapping extends
316: JavaElementResourceMapping {
317: private final IClassFile fClassFile;
318:
319: private ClassFileResourceMapping(IClassFile classFile) {
320: fClassFile = classFile;
321: }
322:
323: public Object getModelObject() {
324: return fClassFile;
325: }
326:
327: public IProject[] getProjects() {
328: return new IProject[] { fClassFile.getJavaProject()
329: .getProject() };
330: }
331:
332: public ResourceTraversal[] getTraversals(
333: ResourceMappingContext context, IProgressMonitor monitor)
334: throws CoreException {
335: return new ResourceTraversal[] { new ResourceTraversal(
336: new IResource[] { fClassFile.getResource() },
337: IResource.DEPTH_ONE, 0) };
338: }
339: }
340:
341: private static final class LogicalPackageResourceMapping extends
342: ResourceMapping {
343: private final IPackageFragment[] fFragments;
344:
345: private LogicalPackageResourceMapping(
346: IPackageFragment[] fragments) {
347: fFragments = fragments;
348: }
349:
350: public Object getModelObject() {
351: return fFragments;
352: }
353:
354: public IProject[] getProjects() {
355: Set result = new HashSet();
356: for (int i = 0; i < fFragments.length; i++) {
357: result.add(fFragments[i].getJavaProject().getProject());
358: }
359: return (IProject[]) result.toArray(new IProject[result
360: .size()]);
361: }
362:
363: public ResourceTraversal[] getTraversals(
364: ResourceMappingContext context, IProgressMonitor monitor)
365: throws CoreException {
366: List result = new ArrayList();
367: if (context instanceof RemoteResourceMappingContext) {
368: for (int i = 0; i < fFragments.length; i++) {
369: result.add(new ResourceTraversal(
370: new IResource[] { fFragments[i]
371: .getResource() },
372: IResource.DEPTH_ONE, 0));
373: }
374: } else {
375: for (int i = 0; i < fFragments.length; i++) {
376: result.add(new LocalPackageFragementTraversal(
377: fFragments[i]));
378: }
379: }
380: return (ResourceTraversal[]) result
381: .toArray(new ResourceTraversal[result.size()]);
382: }
383:
384: public String getModelProviderId() {
385: return JavaModelProvider.JAVA_MODEL_PROVIDER_ID;
386: }
387: }
388:
389: public static ResourceMapping create(IJavaElement element) {
390: switch (element.getElementType()) {
391: case IJavaElement.TYPE:
392: return create((IType) element);
393: case IJavaElement.COMPILATION_UNIT:
394: return create((ICompilationUnit) element);
395: case IJavaElement.CLASS_FILE:
396: return create((IClassFile) element);
397: case IJavaElement.PACKAGE_FRAGMENT:
398: return create((IPackageFragment) element);
399: case IJavaElement.PACKAGE_FRAGMENT_ROOT:
400: return create((IPackageFragmentRoot) element);
401: case IJavaElement.JAVA_PROJECT:
402: return create((IJavaProject) element);
403: case IJavaElement.JAVA_MODEL:
404: return create((IJavaModel) element);
405: default:
406: return null;
407: }
408:
409: }
410:
411: public static ResourceMapping create(final IJavaModel model) {
412: return new JavaModelResourceMapping(model);
413: }
414:
415: public static ResourceMapping create(final IJavaProject project) {
416: return new JavaProjectResourceMapping(project);
417: }
418:
419: public static ResourceMapping create(final IPackageFragmentRoot root) {
420: if (root.isExternal())
421: return null;
422: return new PackageFragementRootResourceMapping(root);
423: }
424:
425: public static ResourceMapping create(final IPackageFragment pack) {
426: // test if in an archive
427: IPackageFragmentRoot root = (IPackageFragmentRoot) pack
428: .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
429: if (!root.isArchive()) {
430: return new PackageFragmentResourceMapping(pack);
431: }
432: return null;
433: }
434:
435: public static ResourceMapping create(ICompilationUnit unit) {
436: if (unit == null)
437: return null;
438: return new CompilationUnitResourceMapping(unit.getPrimary());
439: }
440:
441: public static ResourceMapping create(IClassFile classFile) {
442: // test if in a archive
443: IPackageFragmentRoot root = (IPackageFragmentRoot) classFile
444: .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
445: if (!root.isArchive()) {
446: return new ClassFileResourceMapping(classFile);
447: }
448: return null;
449: }
450:
451: public static ResourceMapping create(IType type) {
452: // top level types behave like the CU
453: IJavaElement parent = type.getParent();
454: if (parent instanceof ICompilationUnit) {
455: return create((ICompilationUnit) parent);
456: }
457: return null;
458: }
459:
460: public static ResourceMapping create(LogicalPackage logicalPackage) {
461: IPackageFragment[] fragments = logicalPackage.getFragments();
462: List toProcess = new ArrayList(fragments.length);
463: for (int i = 0; i < fragments.length; i++) {
464: // only add if not part of an archive
465: IPackageFragmentRoot root = (IPackageFragmentRoot) fragments[i]
466: .getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
467: if (!root.isArchive()) {
468: toProcess.add(fragments[i]);
469: }
470: }
471: if (toProcess.size() == 0)
472: return null;
473: return new LogicalPackageResourceMapping(
474: (IPackageFragment[]) toProcess
475: .toArray(new IPackageFragment[toProcess.size()]));
476: }
477: }
|