core/plugins/org.eclipse.dltk.core/model/org/eclipse/dltk/internal/core/util/HandleFactory.java - dltk/org.eclipse.dltk.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2007 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.core.util;

 import java.util.HashMap;
 import java.util.HashSet;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.dltk.compiler.CharOperation;
 import org.eclipse.dltk.compiler.env.lookup.Scope;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.DLTKLanguageManager;
 import org.eclipse.dltk.core.IBuildpathEntry;
 import org.eclipse.dltk.core.IDLTKLanguageToolkit;
 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptFolder;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.ISourceModule;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.core.search.IDLTKSearchScope;
 import org.eclipse.dltk.internal.compiler.lookup.TypeScope;
 import org.eclipse.dltk.internal.core.Model;
 import org.eclipse.dltk.internal.core.ModelManager;
 import org.eclipse.dltk.internal.core.Openable;
 import org.eclipse.dltk.internal.core.ScriptProject;

 /**
  * Creates script element handles.
  */
 public class HandleFactory {

 	/**
 	 * Cache package fragment root information to optimize speed performance.
 	 */
 	private String lastPkgFragmentRootPath;
 	private IProjectFragment lastPkgFragmentRoot;

 	/**
 	 * Cache package handles to optimize memory.
 	 */
 	private HashtableOfArrayToObject packageHandles;

 	private Model model;

 	public HandleFactory() {
 		this.model = ModelManager.getModelManager().getModel();
 	}

 	/**
 	 * Creates an Openable handle from the given resource path.
 	 *
 	 * If not null, uses the given scope as a hint for getting DLTK project
 	 * handles.
 	 */
 	public Openable createOpenable(String resourcePath, IDLTKSearchScope scope) {
 		int separatorIndex;
 		if ((separatorIndex = resourcePath
 				.indexOf(IDLTKSearchScope.FILE_ENTRY_SEPARATOR)) > -1) {
 			// path to a class file inside a archive
 			// Optimization: cache package fragment root handle and package
 			// handles
 			int rootPathLength;
 			if (this.lastPkgFragmentRootPath == null
 					|| (rootPathLength = this.lastPkgFragmentRootPath.length()) != resourcePath
 							.length()
 					|| !resourcePath.regionMatches(0,
 							this.lastPkgFragmentRootPath, 0, rootPathLength)) {
 				String archivePath = resourcePath.substring(0, separatorIndex);
 				IProjectFragment root = this.getArchiveProjectFragment(
 						archivePath, scope);
 				if (root == null)
 					return null; // match is outside classpath
 				this.lastPkgFragmentRootPath = archivePath;
 				this.lastPkgFragmentRoot = root;
 				this.packageHandles = new HashtableOfArrayToObject(5);
 			}
 			// create handle
 			String classFilePath = resourcePath.substring(separatorIndex + 1);
 			String[] simpleNames = Path.fromPortableString(classFilePath)
 					.segments();
 			String[] pkgName;
 			int length = simpleNames.length - 1;
 			if (length > 0) {
 				pkgName = new String[length];
 				System.arraycopy(simpleNames, 0, pkgName, 0, length);
 			} else {
 				pkgName = CharOperation.NO_STRINGS;
 			}
 			IScriptFolder pkgFragment = (IScriptFolder) this.packageHandles
 					.get(pkgName);
 			if (pkgFragment == null) {
 				pkgFragment = this.lastPkgFragmentRoot
 						.getScriptFolder(toPath(pkgName));
 				this.packageHandles.put(pkgName, pkgFragment);
 			}
 			ISourceModule classFile = pkgFragment
 					.getSourceModule(simpleNames[length]);
 			return (Openable) classFile;
 		} else {
 			// path to a file in a directory
 			// Optimization: cache package fragment root handle and package
 			// handles
 			int rootPathLength = -1;
 			if (this.lastPkgFragmentRootPath == null
 					|| !(resourcePath.startsWith(this.lastPkgFragmentRootPath)
 							&& (rootPathLength = this.lastPkgFragmentRootPath
 									.length()) > 0 && resourcePath
 							.charAt(rootPathLength) == '/')) {
 				IProjectFragment root = this.getProjectFragment(resourcePath);
 				if (root == null)
 					return null; // match is outside classpath
 				this.lastPkgFragmentRoot = root;
 				this.lastPkgFragmentRootPath = this.lastPkgFragmentRoot
 						.getPath().toString();
 				this.packageHandles = new HashtableOfArrayToObject(5);
 			}
 			// create handle
 			resourcePath = resourcePath.substring(this.lastPkgFragmentRootPath
 					.length());
 			String[] simpleNames = Path.fromPortableString(resourcePath)
 					.segments();
 			String[] pkgName;
 			int length = simpleNames.length - 1;
 			if (length > 0) {
 				pkgName = new String[length];
 				System.arraycopy(simpleNames, 0, pkgName, 0, length);
 			} else {
 				pkgName = CharOperation.NO_STRINGS;
 			}
 			IScriptFolder pkgFragment = (IScriptFolder) this.packageHandles
 					.get(pkgName);
 			if (pkgFragment == null) {
 				IPath ppath = toPath(pkgName);
 				IProjectFragment root = this.lastPkgFragmentRoot;
 				pkgFragment = root.getScriptFolder(ppath);
 				this.packageHandles.put(pkgName, pkgFragment);
 			}
 			String simpleName = simpleNames[length];
 			ISourceModule unit = pkgFragment.getSourceModule(simpleName);
 			return (Openable) unit;
 		}
 	}

 	private IPath toPath(String[] pkgName) {
 		IPath path = new Path(""); //$NON-NLS-1$
 		for (int i = 0; i < pkgName.length; ++i) {
 			path = path.append(pkgName[i]);
 		}
 		return path;
 	}

 	/**
 	 * Returns a handle denoting the class member identified by its scope.
 	 */
 	public IModelElement createElement(TypeScope scope, ISourceModule unit,
 			HashSet existingElements, HashMap knownScopes) {
 		return createElement(scope, scope.referenceContext.sourceStart(), unit,
 				existingElements, knownScopes);
 	}

 	/**
 	 * Create handle by adding child to parent obtained by recursing into parent
 	 * scopes.
 	 */
 	private IModelElement createElement(Scope scope, int elementPosition,
 			ISourceModule unit, HashSet existingElements, HashMap knownScopes) {
 		if (DLTKCore.DEBUG) {
 			System.err.println("TODO: HandleFactory: Add implementation..."); //$NON-NLS-1$
 		}
 		return null;
 	}

 	/**
 	 * Returns the package fragment root that corresponds to the given jar path.
 	 * See createOpenable(...) for the format of the jar path string. If not
 	 * null, uses the given scope as a hint for getting script project handles.
 	 */
 	private IProjectFragment getArchiveProjectFragment(
 			String archivePathString, IDLTKSearchScope scope) {

 		IPath archivePath = Path.fromPortableString(archivePathString);

 		Object target = Model.getTarget(ResourcesPlugin.getWorkspace()
 				.getRoot(), archivePath, false);
 		if (target instanceof IFile) {
 			// internal jar: is it on the classpath of its project?
 			// e.g. org.eclipse.swt.win32/ws/win32/swt.jar
 			// is NOT on the classpath of org.eclipse.swt.win32
 			IFile archiveFile = (IFile) target;
 			ScriptProject scriptProject = (ScriptProject) this.model
 					.getScriptProject(archiveFile);
 			IBuildpathEntry[] classpathEntries;
 			try {
 				classpathEntries = scriptProject.getResolvedBuildpath();
 				for (int j = 0, entryCount = classpathEntries.length; j < entryCount; j++) {
 					if (classpathEntries[j].getPath().equals(archivePath)) {
 						return scriptProject.getProjectFragment(archiveFile);
 					}
 				}
 			} catch (ModelException e) {
 				// ignore and try to find another project
 			}
 		}

 		// walk projects in the scope and find the first one that has the given
 		// archive path in its classpath
 		IScriptProject[] projects;
 		if (scope != null) {
 			IPath[] enclosingProjectsAndArchives = scope
 					.enclosingProjectsAndZips();
 			int length = enclosingProjectsAndArchives.length;
 			projects = new IScriptProject[length];
 			int index = 0;
 			for (int i = 0; i < length; i++) {
 				IPath path = enclosingProjectsAndArchives[i];
 				if (!org.eclipse.dltk.compiler.util.Util.isArchiveFileName(
 						scope.getLanguageToolkit(), path.lastSegment())) {
 					projects[index++] = this.model.getScriptProject(path
 							.segment(0));
 				}
 			}
 			if (index < length) {
 				System.arraycopy(projects, 0,
 						projects = new IScriptProject[index], 0, index);
 			}
 			IProjectFragment root = getArchiveFolder(archivePath, target,
 					projects);
 			if (root != null) {
 				return root;
 			}
 		}

 		// not found in the scope, walk all projects
 		try {
 			IDLTKLanguageToolkit toolkit = null;
 			if (scope != null) {
 				toolkit = scope.getLanguageToolkit();
 			}
 			if (toolkit == null) {
 				return null;
 			}
 			projects = this.model.getScriptProjects(toolkit.getNatureId());
 		} catch (ModelException e) {
 			// script model is not accessible
 			return null;
 		}
 		return getArchiveFolder(archivePath, target, projects);
 	}

 	private IProjectFragment getArchiveFolder(IPath archivePath, Object target,
 			IScriptProject[] projects) {
 		for (int i = 0, projectCount = projects.length; i < projectCount; i++) {
 			try {
 				ScriptProject scriptProject = (ScriptProject) projects[i];
 				IBuildpathEntry classpathEntry = scriptProject
 						.getBuildpathEntryFor(archivePath);
 				if (classpathEntry != null) {
 					if (target instanceof IFile) {
 						// internal jar
 						return scriptProject.getProjectFragment((IFile) target);
 					} else {
 						// external jar
 						return scriptProject.getProjectFragment0(archivePath);
 					}
 				}
 			} catch (ModelException e) {
 				// ModelException from getResolvedClasspath - a problem occured
 				// while accessing project: nothing we can do, ignore
 			}
 		}
 		return null;
 	}

 	private static IProject[] getAllProjects() {
 		return ResourcesPlugin.getWorkspace().getRoot().getProjects();
 	}

 	/**
 	 * Returns the package fragment root that contains the given resource path.
 	 */
 	private IProjectFragment getProjectFragment(String pathString) {
 		IPath path = Path.fromPortableString(pathString);
 		IProject[] projects = getAllProjects();
 		for (int i = 0, max = projects.length; i < max; i++) {
 			try {
 				IProject project = projects[i];
 				if (!project.isAccessible()
 						|| !DLTKLanguageManager.hasScriptNature(project))
 					continue;
 				IScriptProject scriptProject = this.model
 						.getScriptProject(project);
 				IProjectFragment[] roots = scriptProject.getProjectFragments();
 				for (int j = 0, rootCount = roots.length; j < rootCount; j++) {
 					IProjectFragment root = roots[j];
 					if (root.getPath().isPrefixOf(path)
 							&& !Util.isExcluded(path, root, false)) {
 						return root;
 					}
 				}
 			} catch (CoreException e) {
 				// CoreException from hasNature - should not happen since we
 				// check that the project is accessible
 				// ModelException from getProjectFragments - a problem occured
 				// while accessing project: nothing we can do, ignore
 			}
 		}
 		return null;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2007 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.core.util;

	import java.util.HashMap;
	import java.util.HashSet;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.dltk.compiler.CharOperation;
	import org.eclipse.dltk.compiler.env.lookup.Scope;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.DLTKLanguageManager;
	import org.eclipse.dltk.core.IBuildpathEntry;
	import org.eclipse.dltk.core.IDLTKLanguageToolkit;
	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptFolder;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.ISourceModule;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.core.search.IDLTKSearchScope;
	import org.eclipse.dltk.internal.compiler.lookup.TypeScope;
	import org.eclipse.dltk.internal.core.Model;
	import org.eclipse.dltk.internal.core.ModelManager;
	import org.eclipse.dltk.internal.core.Openable;
	import org.eclipse.dltk.internal.core.ScriptProject;

	/**
	* Creates script element handles.
	*/
	public class HandleFactory {

	/**
	* Cache package fragment root information to optimize speed performance.
	*/
	private String lastPkgFragmentRootPath;
	private IProjectFragment lastPkgFragmentRoot;

	/**
	* Cache package handles to optimize memory.
	*/
	private HashtableOfArrayToObject packageHandles;

	private Model model;

	public HandleFactory() {
	this.model = ModelManager.getModelManager().getModel();
	}

	/**
	* Creates an Openable handle from the given resource path.
	*
	* If not null, uses the given scope as a hint for getting DLTK project
	* handles.
	*/
	public Openable createOpenable(String resourcePath, IDLTKSearchScope scope) {
	int separatorIndex;
	if ((separatorIndex = resourcePath
	.indexOf(IDLTKSearchScope.FILE_ENTRY_SEPARATOR)) > -1) {
	// path to a class file inside a archive
	// Optimization: cache package fragment root handle and package
	// handles
	int rootPathLength;
	if (this.lastPkgFragmentRootPath == null
	\|\| (rootPathLength = this.lastPkgFragmentRootPath.length()) != resourcePath
	.length()
	\|\| !resourcePath.regionMatches(0,
	this.lastPkgFragmentRootPath, 0, rootPathLength)) {
	String archivePath = resourcePath.substring(0, separatorIndex);
	IProjectFragment root = this.getArchiveProjectFragment(
	archivePath, scope);
	if (root == null)
	return null; // match is outside classpath
	this.lastPkgFragmentRootPath = archivePath;
	this.lastPkgFragmentRoot = root;
	this.packageHandles = new HashtableOfArrayToObject(5);
	}
	// create handle
	String classFilePath = resourcePath.substring(separatorIndex + 1);
	String[] simpleNames = Path.fromPortableString(classFilePath)
	.segments();
	String[] pkgName;
	int length = simpleNames.length - 1;
	if (length > 0) {
	pkgName = new String[length];
	System.arraycopy(simpleNames, 0, pkgName, 0, length);
	} else {
	pkgName = CharOperation.NO_STRINGS;
	}
	IScriptFolder pkgFragment = (IScriptFolder) this.packageHandles
	.get(pkgName);
	if (pkgFragment == null) {
	pkgFragment = this.lastPkgFragmentRoot
	.getScriptFolder(toPath(pkgName));
	this.packageHandles.put(pkgName, pkgFragment);
	}
	ISourceModule classFile = pkgFragment
	.getSourceModule(simpleNames[length]);
	return (Openable) classFile;
	} else {
	// path to a file in a directory
	// Optimization: cache package fragment root handle and package
	// handles
	int rootPathLength = -1;
	if (this.lastPkgFragmentRootPath == null
	\|\| !(resourcePath.startsWith(this.lastPkgFragmentRootPath)
	&& (rootPathLength = this.lastPkgFragmentRootPath
	.length()) > 0 && resourcePath
	.charAt(rootPathLength) == '/')) {
	IProjectFragment root = this.getProjectFragment(resourcePath);
	if (root == null)
	return null; // match is outside classpath
	this.lastPkgFragmentRoot = root;
	this.lastPkgFragmentRootPath = this.lastPkgFragmentRoot
	.getPath().toString();
	this.packageHandles = new HashtableOfArrayToObject(5);
	}
	// create handle
	resourcePath = resourcePath.substring(this.lastPkgFragmentRootPath
	.length());
	String[] simpleNames = Path.fromPortableString(resourcePath)
	.segments();
	String[] pkgName;
	int length = simpleNames.length - 1;
	if (length > 0) {
	pkgName = new String[length];
	System.arraycopy(simpleNames, 0, pkgName, 0, length);
	} else {
	pkgName = CharOperation.NO_STRINGS;
	}
	IScriptFolder pkgFragment = (IScriptFolder) this.packageHandles
	.get(pkgName);
	if (pkgFragment == null) {
	IPath ppath = toPath(pkgName);
	IProjectFragment root = this.lastPkgFragmentRoot;
	pkgFragment = root.getScriptFolder(ppath);
	this.packageHandles.put(pkgName, pkgFragment);
	}
	String simpleName = simpleNames[length];
	ISourceModule unit = pkgFragment.getSourceModule(simpleName);
	return (Openable) unit;
	}
	}

	private IPath toPath(String[] pkgName) {
	IPath path = new Path(""); //$NON-NLS-1$
	for (int i = 0; i < pkgName.length; ++i) {
	path = path.append(pkgName[i]);
	}
	return path;
	}

	/**
	* Returns a handle denoting the class member identified by its scope.
	*/
	public IModelElement createElement(TypeScope scope, ISourceModule unit,
	HashSet existingElements, HashMap knownScopes) {
	return createElement(scope, scope.referenceContext.sourceStart(), unit,
	existingElements, knownScopes);
	}

	/**
	* Create handle by adding child to parent obtained by recursing into parent
	* scopes.
	*/
	private IModelElement createElement(Scope scope, int elementPosition,
	ISourceModule unit, HashSet existingElements, HashMap knownScopes) {
	if (DLTKCore.DEBUG) {
	System.err.println("TODO: HandleFactory: Add implementation..."); //$NON-NLS-1$
	}
	return null;
	}

	/**
	* Returns the package fragment root that corresponds to the given jar path.
	* See createOpenable(...) for the format of the jar path string. If not
	* null, uses the given scope as a hint for getting script project handles.
	*/
	private IProjectFragment getArchiveProjectFragment(
	String archivePathString, IDLTKSearchScope scope) {

	IPath archivePath = Path.fromPortableString(archivePathString);

	Object target = Model.getTarget(ResourcesPlugin.getWorkspace()
	.getRoot(), archivePath, false);
	if (target instanceof IFile) {
	// internal jar: is it on the classpath of its project?
	// e.g. org.eclipse.swt.win32/ws/win32/swt.jar
	// is NOT on the classpath of org.eclipse.swt.win32
	IFile archiveFile = (IFile) target;
	ScriptProject scriptProject = (ScriptProject) this.model
	.getScriptProject(archiveFile);
	IBuildpathEntry[] classpathEntries;
	try {
	classpathEntries = scriptProject.getResolvedBuildpath();
	for (int j = 0, entryCount = classpathEntries.length; j < entryCount; j++) {
	if (classpathEntries[j].getPath().equals(archivePath)) {
	return scriptProject.getProjectFragment(archiveFile);
	}
	}
	} catch (ModelException e) {
	// ignore and try to find another project
	}
	}

	// walk projects in the scope and find the first one that has the given
	// archive path in its classpath
	IScriptProject[] projects;
	if (scope != null) {
	IPath[] enclosingProjectsAndArchives = scope
	.enclosingProjectsAndZips();
	int length = enclosingProjectsAndArchives.length;
	projects = new IScriptProject[length];
	int index = 0;
	for (int i = 0; i < length; i++) {
	IPath path = enclosingProjectsAndArchives[i];
	if (!org.eclipse.dltk.compiler.util.Util.isArchiveFileName(
	scope.getLanguageToolkit(), path.lastSegment())) {
	projects[index++] = this.model.getScriptProject(path
	.segment(0));
	}
	}
	if (index < length) {
	System.arraycopy(projects, 0,
	projects = new IScriptProject[index], 0, index);
	}
	IProjectFragment root = getArchiveFolder(archivePath, target,
	projects);
	if (root != null) {
	return root;
	}
	}

	// not found in the scope, walk all projects
	try {
	IDLTKLanguageToolkit toolkit = null;
	if (scope != null) {
	toolkit = scope.getLanguageToolkit();
	}
	if (toolkit == null) {
	return null;
	}
	projects = this.model.getScriptProjects(toolkit.getNatureId());
	} catch (ModelException e) {
	// script model is not accessible
	return null;
	}
	return getArchiveFolder(archivePath, target, projects);
	}

	private IProjectFragment getArchiveFolder(IPath archivePath, Object target,
	IScriptProject[] projects) {
	for (int i = 0, projectCount = projects.length; i < projectCount; i++) {
	try {
	ScriptProject scriptProject = (ScriptProject) projects[i];
	IBuildpathEntry classpathEntry = scriptProject
	.getBuildpathEntryFor(archivePath);
	if (classpathEntry != null) {
	if (target instanceof IFile) {
	// internal jar
	return scriptProject.getProjectFragment((IFile) target);
	} else {
	// external jar
	return scriptProject.getProjectFragment0(archivePath);
	}
	}
	} catch (ModelException e) {
	// ModelException from getResolvedClasspath - a problem occured
	// while accessing project: nothing we can do, ignore
	}
	}
	return null;
	}

	private static IProject[] getAllProjects() {
	return ResourcesPlugin.getWorkspace().getRoot().getProjects();
	}

	/**
	* Returns the package fragment root that contains the given resource path.
	*/
	private IProjectFragment getProjectFragment(String pathString) {
	IPath path = Path.fromPortableString(pathString);
	IProject[] projects = getAllProjects();
	for (int i = 0, max = projects.length; i < max; i++) {
	try {
	IProject project = projects[i];
	if (!project.isAccessible()
	\|\| !DLTKLanguageManager.hasScriptNature(project))
	continue;
	IScriptProject scriptProject = this.model
	.getScriptProject(project);
	IProjectFragment[] roots = scriptProject.getProjectFragments();
	for (int j = 0, rootCount = roots.length; j < rootCount; j++) {
	IProjectFragment root = roots[j];
	if (root.getPath().isPrefixOf(path)
	&& !Util.isExcluded(path, root, false)) {
	return root;
	}
	}
	} catch (CoreException e) {
	// CoreException from hasNature - should not happen since we
	// check that the project is accessible
	// ModelException from getProjectFragments - a problem occured
	// while accessing project: nothing we can do, ignore
	}
	}
	return null;
	}
	}