core/plugins/org.eclipse.dltk.ui/src/org/eclipse/dltk/internal/ui/model/DLTKElementResourceMapping.java

/*******************************************************************************
 * Copyright (c) 2000, 2017 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 *******************************************************************************/
package org.eclipse.dltk.internal.ui.model;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.mapping.RemoteResourceMappingContext;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.resources.mapping.ResourceMappingContext;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.IProjectFragment;
import org.eclipse.dltk.core.IScriptFolder;
import org.eclipse.dltk.core.IScriptModel;
import org.eclipse.dltk.core.IScriptProject;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.IType;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.internal.ui.browsing.LogicalPackage;
import org.eclipse.dltk.ui.DLTKUIPlugin;

/**
 * An abstract super class to describe mappings from a model element to a set of
 * resources. The class also provides factory methods to create resource
 * mappings.
 *
 */
public abstract class DLTKElementResourceMapping extends ResourceMapping {

	protected DLTKElementResourceMapping() {
	}

	public IModelElement getModelElement() {
		Object o = getModelObject();
		if (o instanceof IModelElement)
			return (IModelElement) o;
		return null;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof DLTKElementResourceMapping))
			return false;
		return getModelElement()
				.equals(((DLTKElementResourceMapping) obj).getModelElement());
	}

	@Override
	public int hashCode() {
		IModelElement modelElement = getModelElement();
		if (modelElement == null)
			return super.hashCode();

		return modelElement.hashCode();
	}

	@Override
	public String getModelProviderId() {
		return ScriptModelProvider.DLTK_MODEL_PROVIDER_ID;
	}

	@Override
	public boolean contains(ResourceMapping mapping) {
		if (mapping instanceof DLTKElementResourceMapping) {
			DLTKElementResourceMapping javaMapping = (DLTKElementResourceMapping) mapping;
			IModelElement element = getModelElement();
			IModelElement other = javaMapping.getModelElement();
			if (other != null && element != null)
				return element.getPath().isPrefixOf(other.getPath());
		}
		return false;
	}

	// ---- the factory code
	// ---------------------------------------------------------------

	private static final class ScriptModelResourceMapping
			extends DLTKElementResourceMapping {
		private final IScriptModel fModel;

		private ScriptModelResourceMapping(IScriptModel model) {
			Assert.isNotNull(model);
			fModel = model;
		}

		@Override
		public Object getModelObject() {
			return fModel;
		}

		@Override
		public IProject[] getProjects() {
			IScriptProject[] projects = null;
			try {
				projects = fModel.getScriptProjects();
			} catch (ModelException e) {
				DLTKUIPlugin.log(e);
				return new IProject[0];
			}
			IProject[] result = new IProject[projects.length];
			for (int i = 0; i < projects.length; i++) {
				result[i] = projects[i].getProject();
			}
			return result;
		}

		@Override
		public ResourceTraversal[] getTraversals(ResourceMappingContext context,
				IProgressMonitor monitor) throws CoreException {
			IScriptProject[] projects = fModel.getScriptProjects();
			ResourceTraversal[] result = new ResourceTraversal[projects.length];
			for (int i = 0; i < projects.length; i++) {
				result[i] = new ResourceTraversal(
						new IResource[] { projects[i].getProject() },
						IResource.DEPTH_INFINITE, 0);
			}
			return result;
		}
	}

	private static final class ScriptProjectResourceMapping
			extends DLTKElementResourceMapping {
		private final IScriptProject fProject;

		private ScriptProjectResourceMapping(IScriptProject project) {
			Assert.isNotNull(project);
			fProject = project;
		}

		@Override
		public Object getModelObject() {
			return fProject;
		}

		@Override
		public IProject[] getProjects() {
			return new IProject[] { fProject.getProject() };
		}

		@Override
		public ResourceTraversal[] getTraversals(ResourceMappingContext context,
				IProgressMonitor monitor) throws CoreException {
			return new ResourceTraversal[] { new ResourceTraversal(
					new IResource[] { fProject.getProject() },
					IResource.DEPTH_INFINITE, 0) };
		}
	}

	private static final class PackageFragementRootResourceMapping
			extends DLTKElementResourceMapping {
		private final IProjectFragment fRoot;

		private PackageFragementRootResourceMapping(IProjectFragment root) {
			Assert.isNotNull(root);
			fRoot = root;
		}

		@Override
		public Object getModelObject() {
			return fRoot;
		}

		@Override
		public IProject[] getProjects() {
			return new IProject[] { fRoot.getScriptProject().getProject() };
		}

		@Override
		public ResourceTraversal[] getTraversals(ResourceMappingContext context,
				IProgressMonitor monitor) throws CoreException {
			return new ResourceTraversal[] { new ResourceTraversal(
					new IResource[] { fRoot.getResource() },
					IResource.DEPTH_INFINITE, 0) };
		}
	}

	private static final class LocalPackageFragementTraversal
			extends ResourceTraversal {
		private final IScriptFolder fPack;

		public LocalPackageFragementTraversal(IScriptFolder pack)
				throws CoreException {
			super(new IResource[] { pack.getResource() }, IResource.DEPTH_ONE,
					0);
			fPack = pack;
		}

		@Override
		public void accept(IResourceVisitor visitor) throws CoreException {
			IFile[] files = getPackageContent(fPack);
			final IResource resource = fPack.getResource();
			if (resource != null)
				visitor.visit(resource);
			for (int i = 0; i < files.length; i++) {
				visitor.visit(files[i]);
			}
		}
	}

	private static final class ScriptFolderResourceMapping
			extends DLTKElementResourceMapping {
		private final IScriptFolder fPack;

		private ScriptFolderResourceMapping(IScriptFolder pack) {
			Assert.isNotNull(pack);
			fPack = pack;
		}

		@Override
		public Object getModelObject() {
			return fPack;
		}

		@Override
		public IProject[] getProjects() {
			return new IProject[] { fPack.getScriptProject().getProject() };
		}

		@Override
		public ResourceTraversal[] getTraversals(ResourceMappingContext context,
				IProgressMonitor monitor) throws CoreException {
			if (context instanceof RemoteResourceMappingContext) {
				return new ResourceTraversal[] { new ResourceTraversal(
						new IResource[] { fPack.getResource() },
						IResource.DEPTH_ONE, 0) };
			} else if (fPack.getResource() != null) {
				return new ResourceTraversal[] {
						new LocalPackageFragementTraversal(fPack) };
			} else {
				return new ResourceTraversal[0];
			}
		}

		@Override
		public void accept(ResourceMappingContext context,
				IResourceVisitor visitor, IProgressMonitor monitor)
				throws CoreException {
			if (context instanceof RemoteResourceMappingContext) {
				super.accept(context, visitor, monitor);
			} else {
				// We assume a local context.
				IFile[] files = getPackageContent(fPack);
				if (monitor == null)
					monitor = new NullProgressMonitor();
				monitor.beginTask("", files.length + 1); //$NON-NLS-1$
				final IResource resource = fPack.getResource();
				if (resource != null)
					visitor.visit(resource);
				monitor.worked(1);
				for (int i = 0; i < files.length; i++) {
					visitor.visit(files[i]);
					monitor.worked(1);
				}
			}
		}
	}

	private static IFile[] getPackageContent(IScriptFolder pack)
			throws CoreException {
		List<IFile> result = new ArrayList<>();
		IContainer container = (IContainer) pack.getResource();
		if (container != null) {
			IResource[] members = container.members();
			for (int m = 0; m < members.length; m++) {
				IResource member = members[m];
				if (member instanceof IFile) {
					IFile file = (IFile) member;
					if ("class".equals(file.getFileExtension()) //$NON-NLS-1$
							&& file.isDerived())
						continue;
					result.add((IFile) member);
				}
			}
		}
		return result.toArray(new IFile[result.size()]);
	}

	private static final class SourceModuleResourceMapping
			extends DLTKElementResourceMapping {
		private final ISourceModule fUnit;

		private SourceModuleResourceMapping(ISourceModule unit) {
			Assert.isNotNull(unit);
			fUnit = unit;
		}

		@Override
		public Object getModelObject() {
			return fUnit;
		}

		@Override
		public IProject[] getProjects() {
			return new IProject[] { fUnit.getScriptProject().getProject() };
		}

		@Override
		public ResourceTraversal[] getTraversals(ResourceMappingContext context,
				IProgressMonitor monitor) throws CoreException {
			return new ResourceTraversal[] { new ResourceTraversal(
					new IResource[] { fUnit.getResource() },
					IResource.DEPTH_ONE, 0) };
		}
	}

	private static final class LogicalPackageResourceMapping
			extends ResourceMapping {
		private final IScriptFolder[] fFragments;

		private LogicalPackageResourceMapping(IScriptFolder[] fragments) {
			fFragments = fragments;
		}

		@Override
		public Object getModelObject() {
			return fFragments;
		}

		@Override
		public IProject[] getProjects() {
			Set<IProject> result = new HashSet<>();
			for (int i = 0; i < fFragments.length; i++) {
				result.add(fFragments[i].getScriptProject().getProject());
			}
			return result.toArray(new IProject[result.size()]);
		}

		@Override
		public ResourceTraversal[] getTraversals(ResourceMappingContext context,
				IProgressMonitor monitor) throws CoreException {
			List<ResourceTraversal> result = new ArrayList<>();
			if (context instanceof RemoteResourceMappingContext) {
				for (int i = 0; i < fFragments.length; i++) {
					result.add(new ResourceTraversal(
							new IResource[] { fFragments[i].getResource() },
							IResource.DEPTH_ONE, 0));
				}
			} else {
				for (int i = 0; i < fFragments.length; i++) {
					result.add(
							new LocalPackageFragementTraversal(fFragments[i]));
				}
			}
			return result.toArray(new ResourceTraversal[result.size()]);
		}

		@Override
		public String getModelProviderId() {
			return ScriptModelProvider.DLTK_MODEL_PROVIDER_ID;
		}
	}

	public static ResourceMapping create(IModelElement element) {
		switch (element.getElementType()) {
		case IModelElement.TYPE:
			return create((IType) element);
		case IModelElement.SOURCE_MODULE:
			return create((ISourceModule) element);
		case IModelElement.SCRIPT_FOLDER:
			return create((IScriptFolder) element);
		case IModelElement.PROJECT_FRAGMENT:
			return create((IProjectFragment) element);
		case IModelElement.SCRIPT_PROJECT:
			return create((IScriptProject) element);
		case IModelElement.SCRIPT_MODEL:
			return create((IScriptModel) element);
		default:
			return null;
		}

	}

	public static ResourceMapping create(final IScriptModel model) {
		return new ScriptModelResourceMapping(model);
	}

	public static ResourceMapping create(final IScriptProject project) {
		return new ScriptProjectResourceMapping(project);
	}

	public static ResourceMapping create(final IProjectFragment root) {
		if (root.isExternal())
			return null;
		return new PackageFragementRootResourceMapping(root);
	}

	public static ResourceMapping create(final IScriptFolder pack) {
		// test if in an archive
		IProjectFragment root = (IProjectFragment) pack
				.getAncestor(IModelElement.PROJECT_FRAGMENT);
		if (!root.isArchive()) {
			return new ScriptFolderResourceMapping(pack);
		}
		return null;
	}

	public static ResourceMapping create(ISourceModule unit) {
		if ((unit == null) || (unit.getResource() == null))
			return null;
		return new SourceModuleResourceMapping(unit.getPrimary());
	}

	public static ResourceMapping create(IType type) {
		// top level types behave like the CU
		IModelElement parent = type.getParent();
		if (parent instanceof ISourceModule) {
			return create((ISourceModule) parent);
		}
		return null;
	}

	public static ResourceMapping create(LogicalPackage logicalPackage) {
		IScriptFolder[] fragments = logicalPackage.getFragments();
		List toProcess = new ArrayList(fragments.length);
		for (int i = 0; i < fragments.length; i++) {
			// only add if not part of an archive
			IProjectFragment root = (IProjectFragment) fragments[i]
					.getAncestor(IModelElement.PROJECT_FRAGMENT);
			if (!root.isArchive()) {
				toProcess.add(fragments[i]);
			}
		}
		if (toProcess.size() == 0)
			return null;
		return new LogicalPackageResourceMapping((IScriptFolder[]) toProcess
				.toArray(new IScriptFolder[toProcess.size()]));
	}
}