plugins/org.eclipse.jst.j2ee.ui/j2ee_ui/org/eclipse/jst/j2ee/internal/dialogs/TypeJavaSearchScope.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2003, 2005 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
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.j2ee.internal.dialogs;

 import java.util.ArrayList;
 import java.util.HashSet;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaModel;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IMember;
 import org.eclipse.jdt.core.IOpenable;
 import org.eclipse.jdt.core.IPackageFragment;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.search.IJavaSearchScope;

 /**
  * This class was derived from JavaSearchScope as that class did not have a
  * provision to exclude classpath entries that are not exported A Java-specific
  * scope for searching relative to one or more java elements.
  */
 public class TypeJavaSearchScope implements IJavaSearchScope {

 	private boolean includeExportedClassPathEntriesOnly = true;

 	private ArrayList elements;

 	/*
 	 * The paths of the resources in this search scope (or the classpath
 	 * entries' paths if the resources are projects)
 	 */
 	private IPath[] paths;
 	private boolean[] pathWithSubFolders;
 	private int pathsCount;

 	private IPath[] enclosingProjectsAndJars;

 	public TypeJavaSearchScope() {
 		this.initialize();

 		// disabled for now as this could be expensive
 		// JavaModelManager.getJavaModelManager().rememberScope(this);
 	}

 	private void addEnclosingProjectOrJar(IPath path) {
 		int length = this.enclosingProjectsAndJars.length;
 		for (int i = 0; i < length; i++) {
 			if (this.enclosingProjectsAndJars[i].equals(path))
 				return;
 		}
 		System.arraycopy(this.enclosingProjectsAndJars, 0, this.enclosingProjectsAndJars = new IPath[length + 1], 0, length);
 		this.enclosingProjectsAndJars[length] = path;
 	}

 	/**
 	 * Method addProject. This method adds all the classpath entries for the
 	 * current project to the search scope.
 	 *
 	 * @param javaProject
 	 * @param includesPrereqProjects
 	 * @param visitedProjects
 	 * @throws JavaModelException
 	 */
 	public void addProject(IJavaProject javaProject, boolean includesPrereqProjects, HashSet visitedProjects) throws JavaModelException {
 		IProject project = javaProject.getProject();
 		if (!project.isAccessible() || !visitedProjects.add(project))
 			return;

 		this.addEnclosingProjectOrJar(project.getFullPath());

 		IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
 		IJavaModel model = javaProject.getJavaModel();
 		for (int i = 0, length = entries.length; i < length; i++) {
 			IClasspathEntry entry = entries[i];
 			switch (entry.getEntryKind()) {
 				case IClasspathEntry.CPE_LIBRARY :
 					IPath path = entry.getPath();
 					this.add(path, true);
 					this.addEnclosingProjectOrJar(path);
 					break;
 				case IClasspathEntry.CPE_PROJECT :
 					if (includesPrereqProjects) {
 						this.add(model.getJavaProject(entry.getPath().lastSegment()), true, visitedProjects);
 					}
 					break;
 				case IClasspathEntry.CPE_SOURCE :
 					this.add(entry.getPath(), true);
 					break;
 			}
 		}
 	}

 	/**
 	 * Method add. This method filters out all the classpath entries of the
 	 * project which are not exported.
 	 *
 	 * @param javaProject
 	 * @param includesPrereqProjects
 	 * @param visitedProjects
 	 * @throws JavaModelException
 	 */
 	public void add(IJavaProject javaProject, boolean includesPrereqProjects, HashSet visitedProjects) throws JavaModelException {
 		IProject project = javaProject.getProject();
 		if (!project.isAccessible() || !visitedProjects.add(project))
 			return;

 		this.addEnclosingProjectOrJar(project.getFullPath());

 		IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
 		IJavaModel model = javaProject.getJavaModel();
 		for (int i = 0, length = entries.length; i < length; i++) {
 			IClasspathEntry entry = entries[i];
 			if (includeExportedClassPathEntriesOnly()) {
 				if (!entry.isExported() && entry.getEntryKind() != IClasspathEntry.CPE_SOURCE)
 					continue;
 			}
 			switch (entry.getEntryKind()) {
 				case IClasspathEntry.CPE_LIBRARY :
 					IPath path = entry.getPath();
 					this.add(path, true);
 					this.addEnclosingProjectOrJar(path);
 					break;
 				case IClasspathEntry.CPE_PROJECT :
 					if (includesPrereqProjects) {
 						this.add(model.getJavaProject(entry.getPath().lastSegment()), true, visitedProjects);
 					}
 					break;
 				case IClasspathEntry.CPE_SOURCE :
 					this.add(entry.getPath(), true);
 					break;
 			}
 		}
 	}
 	public void add(IJavaElement element) throws JavaModelException {
 		IPackageFragmentRoot root = null;
 		switch (element.getElementType()) {
 			case IJavaElement.JAVA_MODEL :
 				// a workspace sope should be used
 				break;
 			case IJavaElement.JAVA_PROJECT :
 				this.add((IJavaProject) element, true, new HashSet(2));
 				break;
 			case IJavaElement.PACKAGE_FRAGMENT_ROOT :
 				root = (IPackageFragmentRoot) element;
 				this.add(root.getPath(), true);
 				break;
 			case IJavaElement.PACKAGE_FRAGMENT :
 				root = (IPackageFragmentRoot) element.getParent();
 				if (root.isArchive()) {
 					this.add(root.getPath().append(new Path(element.getElementName().replace('.', '/'))), false);
 				} else {
 					IResource resource = element.getUnderlyingResource();
 					if (resource != null && resource.isAccessible()) {
 						this.add(resource.getFullPath(), false);
 					}
 				}
 				break;
 			default :
 				// remember sub-cu (or sub-class file) java elements
 				if (element instanceof IMember) {
 					if (this.elements == null) {
 						this.elements = new ArrayList();
 					}
 					this.elements.add(element);
 				}
 				this.add(this.fullPath(element), true);

 				// find package fragment root including this java element
 				IJavaElement parent = element.getParent();
 				while (parent != null && !(parent instanceof IPackageFragmentRoot)) {
 					parent = parent.getParent();
 				}
 				if (parent instanceof IPackageFragmentRoot) {
 					root = (IPackageFragmentRoot) parent;
 				}
 		}

 		if (root != null) {
 			if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
 				this.addEnclosingProjectOrJar(root.getPath());
 			} else {
 				this.addEnclosingProjectOrJar(root.getJavaProject().getProject().getFullPath());
 			}
 		}
 	}

 	/**
 	 * Adds the given path to this search scope. Remember if subfolders need to
 	 * be included as well.
 	 */
 	private void add(IPath path, boolean withSubFolders) {
 		if (this.paths.length == this.pathsCount) {
 			System.arraycopy(this.paths, 0, this.paths = new IPath[this.pathsCount * 2], 0, this.pathsCount);
 			System.arraycopy(this.pathWithSubFolders, 0, this.pathWithSubFolders = new boolean[this.pathsCount * 2], 0, this.pathsCount);
 		}
 		this.paths[this.pathsCount] = path;
 		this.pathWithSubFolders[this.pathsCount++] = withSubFolders;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see IJavaSearchScope#encloses(String)
 	 */
 	public boolean encloses(String resourcePathString) {
 		IPath resourcePath;
 		int separatorIndex = resourcePathString.indexOf(JAR_FILE_ENTRY_SEPARATOR);
 		if (separatorIndex != -1) {
 			resourcePath = new Path(resourcePathString.substring(0, separatorIndex)).append(new Path(resourcePathString.substring(separatorIndex + 1)));
 		} else {
 			resourcePath = new Path(resourcePathString);
 		}
 		return this.encloses(resourcePath);
 	}

 	/**
 	 * Returns whether this search scope encloses the given path.
 	 */
 	private boolean encloses(IPath path) {
 		for (int i = 0; i < this.pathsCount; i++) {
 			if (this.pathWithSubFolders[i]) {
 				if (this.paths[i].isPrefixOf(path)) {
 					return true;
 				}
 			} else {
 				IPath scopePath = this.paths[i];
 				if (scopePath.isPrefixOf(path) && (scopePath.segmentCount() == path.segmentCount() - 1)) {
 					return true;
 				}
 			}
 		}
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see IJavaSearchScope#encloses(IJavaElement)
 	 */
 	public boolean encloses(IJavaElement element) {
 		if (this.elements != null) {
 			for (int i = 0, length = this.elements.size(); i < length; i++) {
 				IJavaElement scopeElement = (IJavaElement) this.elements.get(i);
 				IJavaElement searchedElement = element;
 				while (searchedElement != null) {
 					if (searchedElement.equals(scopeElement)) {
 						return true;
 					}
 					searchedElement = searchedElement.getParent();
 				}
 			}
 			return false;
 		}
 		return this.encloses(this.fullPath(element));
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see IJavaSearchScope#enclosingProjectsAndJars()
 	 */
 	public IPath[] enclosingProjectsAndJars() {
 		return this.enclosingProjectsAndJars;
 	}
 	private IPath fullPath(IJavaElement element) {
 		if (element instanceof IPackageFragmentRoot) {
 			return ((IPackageFragmentRoot) element).getPath();
 		}
 		IJavaElement parent = element.getParent();
 		IPath parentPath = parent == null ? null : this.fullPath(parent);
 		IPath childPath;
 		if (element instanceof IPackageFragment) {
 			childPath = new Path(element.getElementName().replace('.', '/'));
 		} else if (element instanceof IOpenable) {
 			childPath = new Path(element.getElementName());
 		} else {
 			return parentPath;
 		}
 		return parentPath == null ? childPath : parentPath.append(childPath);
 	}

 	protected void initialize() {
 		this.paths = new IPath[1];
 		this.pathWithSubFolders = new boolean[1];
 		this.pathsCount = 0;
 		this.enclosingProjectsAndJars = new IPath[0];
 	}
 	/**
 	 * Gets the includeExportedClassPathEntriesOnly.
 	 *
 	 * @return Returns a boolean
 	 */
 	public boolean includeExportedClassPathEntriesOnly() {
 		return includeExportedClassPathEntriesOnly;
 	}

 	/**
 	 * Sets the includeExportedClassPathEntriesOnly.
 	 *
 	 * @param includeExportedClassPathEntriesOnly
 	 *            The includeExportedClassPathEntriesOnly to set
 	 */
 	public void setIncludeExportedClassPathEntriesOnly(boolean includeExportedClassPathEntriesOnly) {
 		this.includeExportedClassPathEntriesOnly = includeExportedClassPathEntriesOnly;
 	}
 	/**
 	 * @see IJavaSearchScope#includesBinaries()
 	 * @deprecated
 	 */
 	public boolean includesBinaries() {
 		return true;
 	}

 	/**
 	 * @see IJavaSearchScope#includesClasspaths()
 	 * @deprecated
 	 */
 	public boolean includesClasspaths() {
 		return true;
 	}

 	/**
 	 * @see IJavaSearchScope#setIncludesBinaries(boolean)
 	 * @deprecated
 	 */
 	public void setIncludesBinaries(boolean includesBinaries) {
 		//Default nothing
 	}

 	/**
 	 * @see IJavaSearchScope#setIncludesClasspaths(boolean)
 	 * @deprecated
 	 */
 	public void setIncludesClasspaths(boolean includesClasspaths) {
 		//Default nothing
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2003, 2005 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
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.j2ee.internal.dialogs;

	import java.util.ArrayList;
	import java.util.HashSet;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.jdt.core.IClasspathEntry;
	import org.eclipse.jdt.core.IJavaElement;
	import org.eclipse.jdt.core.IJavaModel;
	import org.eclipse.jdt.core.IJavaProject;
	import org.eclipse.jdt.core.IMember;
	import org.eclipse.jdt.core.IOpenable;
	import org.eclipse.jdt.core.IPackageFragment;
	import org.eclipse.jdt.core.IPackageFragmentRoot;
	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.core.search.IJavaSearchScope;

	/**
	* This class was derived from JavaSearchScope as that class did not have a
	* provision to exclude classpath entries that are not exported A Java-specific
	* scope for searching relative to one or more java elements.
	*/
	public class TypeJavaSearchScope implements IJavaSearchScope {

	private boolean includeExportedClassPathEntriesOnly = true;

	private ArrayList elements;

	/*
	* The paths of the resources in this search scope (or the classpath
	* entries' paths if the resources are projects)
	*/
	private IPath[] paths;
	private boolean[] pathWithSubFolders;
	private int pathsCount;

	private IPath[] enclosingProjectsAndJars;

	public TypeJavaSearchScope() {
	this.initialize();

	// disabled for now as this could be expensive
	// JavaModelManager.getJavaModelManager().rememberScope(this);
	}

	private void addEnclosingProjectOrJar(IPath path) {
	int length = this.enclosingProjectsAndJars.length;
	for (int i = 0; i < length; i++) {
	if (this.enclosingProjectsAndJars[i].equals(path))
	return;
	}
	System.arraycopy(this.enclosingProjectsAndJars, 0, this.enclosingProjectsAndJars = new IPath[length + 1], 0, length);
	this.enclosingProjectsAndJars[length] = path;
	}

	/**
	* Method addProject. This method adds all the classpath entries for the
	* current project to the search scope.
	*
	* @param javaProject
	* @param includesPrereqProjects
	* @param visitedProjects
	* @throws JavaModelException
	*/
	public void addProject(IJavaProject javaProject, boolean includesPrereqProjects, HashSet visitedProjects) throws JavaModelException {
	IProject project = javaProject.getProject();
	if (!project.isAccessible() \|\| !visitedProjects.add(project))
	return;

	this.addEnclosingProjectOrJar(project.getFullPath());

	IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
	IJavaModel model = javaProject.getJavaModel();
	for (int i = 0, length = entries.length; i < length; i++) {
	IClasspathEntry entry = entries[i];
	switch (entry.getEntryKind()) {
	case IClasspathEntry.CPE_LIBRARY :
	IPath path = entry.getPath();
	this.add(path, true);
	this.addEnclosingProjectOrJar(path);
	break;
	case IClasspathEntry.CPE_PROJECT :
	if (includesPrereqProjects) {
	this.add(model.getJavaProject(entry.getPath().lastSegment()), true, visitedProjects);
	}
	break;
	case IClasspathEntry.CPE_SOURCE :
	this.add(entry.getPath(), true);
	break;
	}
	}
	}

	/**
	* Method add. This method filters out all the classpath entries of the
	* project which are not exported.
	*
	* @param javaProject
	* @param includesPrereqProjects
	* @param visitedProjects
	* @throws JavaModelException
	*/
	public void add(IJavaProject javaProject, boolean includesPrereqProjects, HashSet visitedProjects) throws JavaModelException {
	IProject project = javaProject.getProject();
	if (!project.isAccessible() \|\| !visitedProjects.add(project))
	return;

	this.addEnclosingProjectOrJar(project.getFullPath());

	IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
	IJavaModel model = javaProject.getJavaModel();
	for (int i = 0, length = entries.length; i < length; i++) {
	IClasspathEntry entry = entries[i];
	if (includeExportedClassPathEntriesOnly()) {
	if (!entry.isExported() && entry.getEntryKind() != IClasspathEntry.CPE_SOURCE)
	continue;
	}
	switch (entry.getEntryKind()) {
	case IClasspathEntry.CPE_LIBRARY :
	IPath path = entry.getPath();
	this.add(path, true);
	this.addEnclosingProjectOrJar(path);
	break;
	case IClasspathEntry.CPE_PROJECT :
	if (includesPrereqProjects) {
	this.add(model.getJavaProject(entry.getPath().lastSegment()), true, visitedProjects);
	}
	break;
	case IClasspathEntry.CPE_SOURCE :
	this.add(entry.getPath(), true);
	break;
	}
	}
	}
	public void add(IJavaElement element) throws JavaModelException {
	IPackageFragmentRoot root = null;
	switch (element.getElementType()) {
	case IJavaElement.JAVA_MODEL :
	// a workspace sope should be used
	break;
	case IJavaElement.JAVA_PROJECT :
	this.add((IJavaProject) element, true, new HashSet(2));
	break;
	case IJavaElement.PACKAGE_FRAGMENT_ROOT :
	root = (IPackageFragmentRoot) element;
	this.add(root.getPath(), true);
	break;
	case IJavaElement.PACKAGE_FRAGMENT :
	root = (IPackageFragmentRoot) element.getParent();
	if (root.isArchive()) {
	this.add(root.getPath().append(new Path(element.getElementName().replace('.', '/'))), false);
	} else {
	IResource resource = element.getUnderlyingResource();
	if (resource != null && resource.isAccessible()) {
	this.add(resource.getFullPath(), false);
	}
	}
	break;
	default :
	// remember sub-cu (or sub-class file) java elements
	if (element instanceof IMember) {
	if (this.elements == null) {
	this.elements = new ArrayList();
	}
	this.elements.add(element);
	}
	this.add(this.fullPath(element), true);

	// find package fragment root including this java element
	IJavaElement parent = element.getParent();
	while (parent != null && !(parent instanceof IPackageFragmentRoot)) {
	parent = parent.getParent();
	}
	if (parent instanceof IPackageFragmentRoot) {
	root = (IPackageFragmentRoot) parent;
	}
	}

	if (root != null) {
	if (root.getKind() == IPackageFragmentRoot.K_BINARY) {
	this.addEnclosingProjectOrJar(root.getPath());
	} else {
	this.addEnclosingProjectOrJar(root.getJavaProject().getProject().getFullPath());
	}
	}
	}

	/**
	* Adds the given path to this search scope. Remember if subfolders need to
	* be included as well.
	*/
	private void add(IPath path, boolean withSubFolders) {
	if (this.paths.length == this.pathsCount) {
	System.arraycopy(this.paths, 0, this.paths = new IPath[this.pathsCount * 2], 0, this.pathsCount);
	System.arraycopy(this.pathWithSubFolders, 0, this.pathWithSubFolders = new boolean[this.pathsCount * 2], 0, this.pathsCount);
	}
	this.paths[this.pathsCount] = path;
	this.pathWithSubFolders[this.pathsCount++] = withSubFolders;
	}

	/*
	* (non-Javadoc)
	*
	* @see IJavaSearchScope#encloses(String)
	*/
	public boolean encloses(String resourcePathString) {
	IPath resourcePath;
	int separatorIndex = resourcePathString.indexOf(JAR_FILE_ENTRY_SEPARATOR);
	if (separatorIndex != -1) {
	resourcePath = new Path(resourcePathString.substring(0, separatorIndex)).append(new Path(resourcePathString.substring(separatorIndex + 1)));
	} else {
	resourcePath = new Path(resourcePathString);
	}
	return this.encloses(resourcePath);
	}

	/**
	* Returns whether this search scope encloses the given path.
	*/
	private boolean encloses(IPath path) {
	for (int i = 0; i < this.pathsCount; i++) {
	if (this.pathWithSubFolders[i]) {
	if (this.paths[i].isPrefixOf(path)) {
	return true;
	}
	} else {
	IPath scopePath = this.paths[i];
	if (scopePath.isPrefixOf(path) && (scopePath.segmentCount() == path.segmentCount() - 1)) {
	return true;
	}
	}
	}
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see IJavaSearchScope#encloses(IJavaElement)
	*/
	public boolean encloses(IJavaElement element) {
	if (this.elements != null) {
	for (int i = 0, length = this.elements.size(); i < length; i++) {
	IJavaElement scopeElement = (IJavaElement) this.elements.get(i);
	IJavaElement searchedElement = element;
	while (searchedElement != null) {
	if (searchedElement.equals(scopeElement)) {
	return true;
	}
	searchedElement = searchedElement.getParent();
	}
	}
	return false;
	}
	return this.encloses(this.fullPath(element));
	}

	/*
	* (non-Javadoc)
	*
	* @see IJavaSearchScope#enclosingProjectsAndJars()
	*/
	public IPath[] enclosingProjectsAndJars() {
	return this.enclosingProjectsAndJars;
	}
	private IPath fullPath(IJavaElement element) {
	if (element instanceof IPackageFragmentRoot) {
	return ((IPackageFragmentRoot) element).getPath();
	}
	IJavaElement parent = element.getParent();
	IPath parentPath = parent == null ? null : this.fullPath(parent);
	IPath childPath;
	if (element instanceof IPackageFragment) {
	childPath = new Path(element.getElementName().replace('.', '/'));
	} else if (element instanceof IOpenable) {
	childPath = new Path(element.getElementName());
	} else {
	return parentPath;
	}
	return parentPath == null ? childPath : parentPath.append(childPath);
	}

	protected void initialize() {
	this.paths = new IPath[1];
	this.pathWithSubFolders = new boolean[1];
	this.pathsCount = 0;
	this.enclosingProjectsAndJars = new IPath[0];
	}
	/**
	* Gets the includeExportedClassPathEntriesOnly.
	*
	* @return Returns a boolean
	*/
	public boolean includeExportedClassPathEntriesOnly() {
	return includeExportedClassPathEntriesOnly;
	}

	/**
	* Sets the includeExportedClassPathEntriesOnly.
	*
	* @param includeExportedClassPathEntriesOnly
	* The includeExportedClassPathEntriesOnly to set
	*/
	public void setIncludeExportedClassPathEntriesOnly(boolean includeExportedClassPathEntriesOnly) {
	this.includeExportedClassPathEntriesOnly = includeExportedClassPathEntriesOnly;
	}
	/**
	* @see IJavaSearchScope#includesBinaries()
	* @deprecated
	*/
	public boolean includesBinaries() {
	return true;
	}

	/**
	* @see IJavaSearchScope#includesClasspaths()
	* @deprecated
	*/
	public boolean includesClasspaths() {
	return true;
	}

	/**
	* @see IJavaSearchScope#setIncludesBinaries(boolean)
	* @deprecated
	*/
	public void setIncludesBinaries(boolean includesBinaries) {
	//Default nothing
	}

	/**
	* @see IJavaSearchScope#setIncludesClasspaths(boolean)
	* @deprecated
	*/
	public void setIncludesClasspaths(boolean includesClasspaths) {
	//Default nothing
	}

	}