core/plugins/org.eclipse.dltk.launching/src/org/eclipse/dltk/internal/launching/DefaultProjectBuildpathEntry.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2016 IBM Corporation and others.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  *******************************************************************************/
 package org.eclipse.dltk.internal.launching;

 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.debug.core.ILaunchConfiguration;
 import org.eclipse.dltk.core.BuildpathContainerInitializer;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.IBuildpathContainer;
 import org.eclipse.dltk.core.IBuildpathEntry;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.launching.IRuntimeBuildpathEntry;
 import org.eclipse.dltk.launching.LaunchingMessages;
 import org.eclipse.dltk.launching.ScriptRuntime;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;

 import com.ibm.icu.text.MessageFormat;

 /**
  * Default user buildpath entries for a script project
  */
 public class DefaultProjectBuildpathEntry
 		extends AbstractRuntimeBuildpathEntry {

 	public static final String TYPE_ID = "org.eclipse.dltk.launching.buildpathentry.defaultBuildpath"; //$NON-NLS-1$

 	/**
 	 * Whether only exported entries should be on the runtime buildpath. By
 	 * default all entries are on the runtime buildpath.
 	 */
 	private boolean fExportedEntriesOnly = false;

 	/**
 	 * Default constructor need to instantiate extensions
 	 */
 	public DefaultProjectBuildpathEntry() {
 	}

 	/**
 	 * Constructs a new buildpath entry for the given project.
 	 *
 	 * @param project
 	 *            Script project
 	 */
 	public DefaultProjectBuildpathEntry(IScriptProject project) {
 		setScriptProject(project);
 	}

 	@Override
 	protected void buildMemento(Document document, Element memento)
 			throws CoreException {
 		memento.setAttribute("project", getScriptProject().getElementName()); //$NON-NLS-1$
 		memento.setAttribute("exportedEntriesOnly", //$NON-NLS-1$
 				Boolean.toString(fExportedEntriesOnly));
 	}

 	@Override
 	public void initializeFrom(Element memento) throws CoreException {
 		String name = memento.getAttribute("project"); //$NON-NLS-1$
 		if (name == null) {
 			abort(LaunchingMessages.DefaultProjectBuildpathEntry_3, null);
 		}
 		IScriptProject project = DLTKCore.create(
 				ResourcesPlugin.getWorkspace().getRoot().getProject(name));
 		setScriptProject(project);
 		name = memento.getAttribute("exportedEntriesOnly"); //$NON-NLS-1$
 		if (name == null) {
 			fExportedEntriesOnly = false;
 		} else {
 			fExportedEntriesOnly = Boolean.valueOf(name).booleanValue();
 		}
 	}

 	@Override
 	public String getTypeId() {
 		return TYPE_ID;
 	}

 	@Override
 	public int getType() {
 		return OTHER;
 	}

 	protected IProject getProject() {
 		return getScriptProject().getProject();
 	}

 	@Override
 	public String getLocation() {
 		return getProject().getLocation().toOSString();
 	}

 	@Override
 	public URI getLocationURI() {
 		return getProject().getLocationURI();
 	}

 	@Override
 	public IPath getPath() {
 		return getProject().getFullPath();
 	}

 	@Override
 	public IResource getResource() {
 		return getProject();
 	}

 	@Override
 	public IRuntimeBuildpathEntry[] getRuntimeBuildpathEntries(
 			ILaunchConfiguration configuration) throws CoreException {
 		IBuildpathEntry entry = DLTKCore
 				.newProjectEntry(getScriptProject().getProject().getFullPath());
 		List buildpathEntries = new ArrayList(5);
 		List<IBuildpathEntry> expanding = new ArrayList<>(5);
 		expandProject(entry, buildpathEntries, expanding);
 		IRuntimeBuildpathEntry[] runtimeEntries = new IRuntimeBuildpathEntry[buildpathEntries
 				.size()];
 		for (int i = 0; i < runtimeEntries.length; i++) {
 			Object e = buildpathEntries.get(i);
 			if (e instanceof IBuildpathEntry) {
 				IBuildpathEntry cpe = (IBuildpathEntry) e;
 				runtimeEntries[i] = new RuntimeBuildpathEntry(cpe);
 			} else {
 				runtimeEntries[i] = (IRuntimeBuildpathEntry) e;
 			}
 		}
 		// remove bootpath entries - this is a default user buildpath
 		List<IRuntimeBuildpathEntry> ordered = new ArrayList<>(
 				runtimeEntries.length);
 		for (int i = 0; i < runtimeEntries.length; i++) {
 			if (runtimeEntries[i]
 					.getBuildpathProperty() == IRuntimeBuildpathEntry.USER_ENTRY) {
 				ordered.add(runtimeEntries[i]);
 			}
 		}
 		return ordered.toArray(new IRuntimeBuildpathEntry[ordered.size()]);
 	}

 	/**
 	 * Returns the transitive closure of buildpath entries for the given project
 	 * entry.
 	 *
 	 * @param projectEntry
 	 *            project buildpath entry
 	 * @param expandedPath
 	 *            a list of entries already expanded, should be empty to begin,
 	 *            and contains the result
 	 * @param expanding
 	 *            a list of projects that have been or are currently being
 	 *            expanded (to detect cycles)
 	 * @exception CoreException
 	 *                if unable to expand the buildpath
 	 */
 	private void expandProject(IBuildpathEntry projectEntry, List expandedPath,
 			List<IBuildpathEntry> expanding) throws CoreException {
 		expanding.add(projectEntry);
 		// 1. Get the raw buildpath
 		// 2. Replace source folder entries with a project entry
 		IPath projectPath = projectEntry.getPath();
 		IResource res = ResourcesPlugin.getWorkspace().getRoot()
 				.findMember(projectPath.lastSegment());
 		if (res == null) {
 			// add project entry and return
 			expandedPath.add(projectEntry);
 			return;
 		}
 		IScriptProject project = (IScriptProject) DLTKCore.create(res);
 		if (project == null || !project.getProject().isOpen()
 				|| !project.exists()) {
 			// add project entry and return
 			expandedPath.add(projectEntry);
 			return;
 		}

 		IBuildpathEntry[] buildPath = project.getRawBuildpath();
 		List<IBuildpathEntry> unexpandedPath = new ArrayList<>(
 				buildPath.length);
 		// boolean projectAdded = false;
 		for (int i = 0; i < buildPath.length; i++) {
 			IBuildpathEntry buildpathEntry = buildPath[i];
 			if (buildpathEntry.getEntryKind() == IBuildpathEntry.BPE_SOURCE) { // sources
 				// are
 				// always
 				// added
 				unexpandedPath.add(buildpathEntry);
 			} else {
 				// add exported entires, as configured
 				if (buildpathEntry.isExported()) {
 					unexpandedPath.add(buildpathEntry);
 				} else if (!isExportedEntriesOnly()
 						|| project.equals(getScriptProject())) {
 					// add non exported entries from root project or if we are
 					// including all entries
 					unexpandedPath.add(buildpathEntry);
 				}
 			}
 		}
 		// 3. expand each project entry (except for the root project)
 		// 4. replace each container entry with a runtime entry associated with
 		// the project
 		Iterator<IBuildpathEntry> iter = unexpandedPath.iterator();
 		while (iter.hasNext()) {
 			IBuildpathEntry entry = iter.next();
 			if (entry == projectEntry) {
 				expandedPath.add(entry);
 			} else {
 				switch (entry.getEntryKind()) {
 				case IBuildpathEntry.BPE_PROJECT:
 					if (!expanding.contains(entry)) {
 						expandProject(entry, expandedPath, expanding);
 					}
 					break;
 				case IBuildpathEntry.BPE_CONTAINER:
 					IBuildpathContainer container = DLTKCore
 							.getBuildpathContainer(entry.getPath(), project);
 					int property = -1;
 					if (container != null) {
 						switch (container.getKind()) {
 						case IBuildpathContainer.K_APPLICATION:
 							property = IRuntimeBuildpathEntry.USER_ENTRY;
 							break;
 						case IBuildpathContainer.K_DEFAULT_SYSTEM:
 							property = IRuntimeBuildpathEntry.STANDARD_ENTRY;
 							break;
 						case IBuildpathContainer.K_SYSTEM:
 							property = IRuntimeBuildpathEntry.BOOTSTRAP_ENTRY;
 							break;
 						}
 						IRuntimeBuildpathEntry r = ScriptRuntime
 								.newRuntimeContainerBuildpathEntry(
 										entry.getPath(), property, project);
 						// check for duplicate/redundant entries
 						boolean duplicate = false;
 						BuildpathContainerInitializer initializer = DLTKCore
 								.getBuildpathContainerInitializer(
 										r.getPath().segment(0));
 						for (int i = 0; i < expandedPath.size(); i++) {
 							Object o = expandedPath.get(i);
 							if (o instanceof IRuntimeBuildpathEntry) {
 								IRuntimeBuildpathEntry re = (IRuntimeBuildpathEntry) o;
 								if (re.getType() == IRuntimeBuildpathEntry.CONTAINER) {
 									BuildpathContainerInitializer initializer2 = DLTKCore
 											.getBuildpathContainerInitializer(
 													re.getPath().segment(0));
 									Object id1 = null;
 									Object id2 = null;
 									if (initializer == null) {
 										id1 = r.getPath().segment(0);
 									} else {
 										id1 = initializer.getComparisonID(
 												r.getPath(), project);
 									}
 									if (initializer2 == null) {
 										id2 = re.getPath().segment(0);
 									} else {
 										IScriptProject context = re
 												.getScriptProject();
 										if (context == null) {
 											context = project;
 										}
 										id2 = initializer2.getComparisonID(
 												re.getPath(), context);
 									}
 									if (id1 == null) {
 										duplicate = id2 == null;
 									} else {
 										duplicate = id1.equals(id2);
 									}
 									if (duplicate) {
 										break;
 									}
 								}
 							}
 						}
 						if (!duplicate) {
 							expandedPath.add(r);
 						}
 					}
 					break;
 				default:
 					if (!expandedPath.contains(entry)) {
 						expandedPath.add(entry);
 					}
 					break;
 				}
 			}
 		}
 		return;
 	}

 	@Override
 	public boolean isComposite() {
 		return true;
 	}

 	@Override
 	public String getName() {
 		if (isExportedEntriesOnly()) {
 			return MessageFormat.format(
 					LaunchingMessages.DefaultProjectBuildpathEntry_2,
 					getScriptProject().getElementName());
 		}
 		return MessageFormat.format(
 				LaunchingMessages.DefaultProjectBuildpathEntry_4,
 				getScriptProject().getElementName());
 	}

 	@Override
 	public boolean equals(Object obj) {
 		if (obj instanceof DefaultProjectBuildpathEntry) {
 			DefaultProjectBuildpathEntry entry = (DefaultProjectBuildpathEntry) obj;
 			return entry.getScriptProject().equals(getScriptProject())
 					&& entry.isExportedEntriesOnly() == isExportedEntriesOnly();
 		}
 		return false;
 	}

 	@Override
 	public int hashCode() {
 		return getScriptProject().hashCode();
 	}

 	/**
 	 * Sets whether the runtime buildpath computaion should only include
 	 * exported entries in referenced projects.
 	 *
 	 * @param exportedOnly
 	 *
 	 */
 	public void setExportedEntriesOnly(boolean exportedOnly) {
 		fExportedEntriesOnly = exportedOnly;
 	}

 	/**
 	 * Returns whether the buildpath computation only includes exported entries
 	 * in referenced projects.
 	 *
 	 * @return
 	 *
 	 */
 	public boolean isExportedEntriesOnly() {
 		return fExportedEntriesOnly;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2016 IBM Corporation and others.
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	*******************************************************************************/
	package org.eclipse.dltk.internal.launching;

	import java.net.URI;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.debug.core.ILaunchConfiguration;
	import org.eclipse.dltk.core.BuildpathContainerInitializer;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.IBuildpathContainer;
	import org.eclipse.dltk.core.IBuildpathEntry;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.launching.IRuntimeBuildpathEntry;
	import org.eclipse.dltk.launching.LaunchingMessages;
	import org.eclipse.dltk.launching.ScriptRuntime;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;

	import com.ibm.icu.text.MessageFormat;

	/**
	* Default user buildpath entries for a script project
	*/
	public class DefaultProjectBuildpathEntry
	extends AbstractRuntimeBuildpathEntry {

	public static final String TYPE_ID = "org.eclipse.dltk.launching.buildpathentry.defaultBuildpath"; //$NON-NLS-1$

	/**
	* Whether only exported entries should be on the runtime buildpath. By
	* default all entries are on the runtime buildpath.
	*/
	private boolean fExportedEntriesOnly = false;

	/**
	* Default constructor need to instantiate extensions
	*/
	public DefaultProjectBuildpathEntry() {
	}

	/**
	* Constructs a new buildpath entry for the given project.
	*
	* @param project
	* Script project
	*/
	public DefaultProjectBuildpathEntry(IScriptProject project) {
	setScriptProject(project);
	}

	@Override
	protected void buildMemento(Document document, Element memento)
	throws CoreException {
	memento.setAttribute("project", getScriptProject().getElementName()); //$NON-NLS-1$
	memento.setAttribute("exportedEntriesOnly", //$NON-NLS-1$
	Boolean.toString(fExportedEntriesOnly));
	}

	@Override
	public void initializeFrom(Element memento) throws CoreException {
	String name = memento.getAttribute("project"); //$NON-NLS-1$
	if (name == null) {
	abort(LaunchingMessages.DefaultProjectBuildpathEntry_3, null);
	}
	IScriptProject project = DLTKCore.create(
	ResourcesPlugin.getWorkspace().getRoot().getProject(name));
	setScriptProject(project);
	name = memento.getAttribute("exportedEntriesOnly"); //$NON-NLS-1$
	if (name == null) {
	fExportedEntriesOnly = false;
	} else {
	fExportedEntriesOnly = Boolean.valueOf(name).booleanValue();
	}
	}

	@Override
	public String getTypeId() {
	return TYPE_ID;
	}

	@Override
	public int getType() {
	return OTHER;
	}

	protected IProject getProject() {
	return getScriptProject().getProject();
	}

	@Override
	public String getLocation() {
	return getProject().getLocation().toOSString();
	}

	@Override
	public URI getLocationURI() {
	return getProject().getLocationURI();
	}

	@Override
	public IPath getPath() {
	return getProject().getFullPath();
	}

	@Override
	public IResource getResource() {
	return getProject();
	}

	@Override
	public IRuntimeBuildpathEntry[] getRuntimeBuildpathEntries(
	ILaunchConfiguration configuration) throws CoreException {
	IBuildpathEntry entry = DLTKCore
	.newProjectEntry(getScriptProject().getProject().getFullPath());
	List buildpathEntries = new ArrayList(5);
	List<IBuildpathEntry> expanding = new ArrayList<>(5);
	expandProject(entry, buildpathEntries, expanding);
	IRuntimeBuildpathEntry[] runtimeEntries = new IRuntimeBuildpathEntry[buildpathEntries
	.size()];
	for (int i = 0; i < runtimeEntries.length; i++) {
	Object e = buildpathEntries.get(i);
	if (e instanceof IBuildpathEntry) {
	IBuildpathEntry cpe = (IBuildpathEntry) e;
	runtimeEntries[i] = new RuntimeBuildpathEntry(cpe);
	} else {
	runtimeEntries[i] = (IRuntimeBuildpathEntry) e;
	}
	}
	// remove bootpath entries - this is a default user buildpath
	List<IRuntimeBuildpathEntry> ordered = new ArrayList<>(
	runtimeEntries.length);
	for (int i = 0; i < runtimeEntries.length; i++) {
	if (runtimeEntries[i]
	.getBuildpathProperty() == IRuntimeBuildpathEntry.USER_ENTRY) {
	ordered.add(runtimeEntries[i]);
	}
	}
	return ordered.toArray(new IRuntimeBuildpathEntry[ordered.size()]);
	}

	/**
	* Returns the transitive closure of buildpath entries for the given project
	* entry.
	*
	* @param projectEntry
	* project buildpath entry
	* @param expandedPath
	* a list of entries already expanded, should be empty to begin,
	* and contains the result
	* @param expanding
	* a list of projects that have been or are currently being
	* expanded (to detect cycles)
	* @exception CoreException
	* if unable to expand the buildpath
	*/
	private void expandProject(IBuildpathEntry projectEntry, List expandedPath,
	List<IBuildpathEntry> expanding) throws CoreException {
	expanding.add(projectEntry);
	// 1. Get the raw buildpath
	// 2. Replace source folder entries with a project entry
	IPath projectPath = projectEntry.getPath();
	IResource res = ResourcesPlugin.getWorkspace().getRoot()
	.findMember(projectPath.lastSegment());
	if (res == null) {
	// add project entry and return
	expandedPath.add(projectEntry);
	return;
	}
	IScriptProject project = (IScriptProject) DLTKCore.create(res);
	if (project == null \|\| !project.getProject().isOpen()
	\|\| !project.exists()) {
	// add project entry and return
	expandedPath.add(projectEntry);
	return;
	}

	IBuildpathEntry[] buildPath = project.getRawBuildpath();
	List<IBuildpathEntry> unexpandedPath = new ArrayList<>(
	buildPath.length);
	// boolean projectAdded = false;
	for (int i = 0; i < buildPath.length; i++) {
	IBuildpathEntry buildpathEntry = buildPath[i];
	if (buildpathEntry.getEntryKind() == IBuildpathEntry.BPE_SOURCE) { // sources
	// are
	// always
	// added
	unexpandedPath.add(buildpathEntry);
	} else {
	// add exported entires, as configured
	if (buildpathEntry.isExported()) {
	unexpandedPath.add(buildpathEntry);
	} else if (!isExportedEntriesOnly()
	\|\| project.equals(getScriptProject())) {
	// add non exported entries from root project or if we are
	// including all entries
	unexpandedPath.add(buildpathEntry);
	}
	}
	}
	// 3. expand each project entry (except for the root project)
	// 4. replace each container entry with a runtime entry associated with
	// the project
	Iterator<IBuildpathEntry> iter = unexpandedPath.iterator();
	while (iter.hasNext()) {
	IBuildpathEntry entry = iter.next();
	if (entry == projectEntry) {
	expandedPath.add(entry);
	} else {
	switch (entry.getEntryKind()) {
	case IBuildpathEntry.BPE_PROJECT:
	if (!expanding.contains(entry)) {
	expandProject(entry, expandedPath, expanding);
	}
	break;
	case IBuildpathEntry.BPE_CONTAINER:
	IBuildpathContainer container = DLTKCore
	.getBuildpathContainer(entry.getPath(), project);
	int property = -1;
	if (container != null) {
	switch (container.getKind()) {
	case IBuildpathContainer.K_APPLICATION:
	property = IRuntimeBuildpathEntry.USER_ENTRY;
	break;
	case IBuildpathContainer.K_DEFAULT_SYSTEM:
	property = IRuntimeBuildpathEntry.STANDARD_ENTRY;
	break;
	case IBuildpathContainer.K_SYSTEM:
	property = IRuntimeBuildpathEntry.BOOTSTRAP_ENTRY;
	break;
	}
	IRuntimeBuildpathEntry r = ScriptRuntime
	.newRuntimeContainerBuildpathEntry(
	entry.getPath(), property, project);
	// check for duplicate/redundant entries
	boolean duplicate = false;
	BuildpathContainerInitializer initializer = DLTKCore
	.getBuildpathContainerInitializer(
	r.getPath().segment(0));
	for (int i = 0; i < expandedPath.size(); i++) {
	Object o = expandedPath.get(i);
	if (o instanceof IRuntimeBuildpathEntry) {
	IRuntimeBuildpathEntry re = (IRuntimeBuildpathEntry) o;
	if (re.getType() == IRuntimeBuildpathEntry.CONTAINER) {
	BuildpathContainerInitializer initializer2 = DLTKCore
	.getBuildpathContainerInitializer(
	re.getPath().segment(0));
	Object id1 = null;
	Object id2 = null;
	if (initializer == null) {
	id1 = r.getPath().segment(0);
	} else {
	id1 = initializer.getComparisonID(
	r.getPath(), project);
	}
	if (initializer2 == null) {
	id2 = re.getPath().segment(0);
	} else {
	IScriptProject context = re
	.getScriptProject();
	if (context == null) {
	context = project;
	}
	id2 = initializer2.getComparisonID(
	re.getPath(), context);
	}
	if (id1 == null) {
	duplicate = id2 == null;
	} else {
	duplicate = id1.equals(id2);
	}
	if (duplicate) {
	break;
	}
	}
	}
	}
	if (!duplicate) {
	expandedPath.add(r);
	}
	}
	break;
	default:
	if (!expandedPath.contains(entry)) {
	expandedPath.add(entry);
	}
	break;
	}
	}
	}
	return;
	}

	@Override
	public boolean isComposite() {
	return true;
	}

	@Override
	public String getName() {
	if (isExportedEntriesOnly()) {
	return MessageFormat.format(
	LaunchingMessages.DefaultProjectBuildpathEntry_2,
	getScriptProject().getElementName());
	}
	return MessageFormat.format(
	LaunchingMessages.DefaultProjectBuildpathEntry_4,
	getScriptProject().getElementName());
	}

	@Override
	public boolean equals(Object obj) {
	if (obj instanceof DefaultProjectBuildpathEntry) {
	DefaultProjectBuildpathEntry entry = (DefaultProjectBuildpathEntry) obj;
	return entry.getScriptProject().equals(getScriptProject())
	&& entry.isExportedEntriesOnly() == isExportedEntriesOnly();
	}
	return false;
	}

	@Override
	public int hashCode() {
	return getScriptProject().hashCode();
	}

	/**
	* Sets whether the runtime buildpath computaion should only include
	* exported entries in referenced projects.
	*
	* @param exportedOnly
	*
	*/
	public void setExportedEntriesOnly(boolean exportedOnly) {
	fExportedEntriesOnly = exportedOnly;
	}

	/**
	* Returns whether the buildpath computation only includes exported entries
	* in referenced projects.
	*
	* @return
	*
	*/
	public boolean isExportedEntriesOnly() {
	return fExportedEntriesOnly;
	}

	}