plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/BeaninfoEntry.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2006 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
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jem.internal.beaninfo.core;
 /*


  */

 import java.util.ArrayList;
 import java.util.List;
 import java.util.logging.Level;

 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;
 import org.eclipse.jdt.core.*;
 import org.w3c.dom.*;

 import org.eclipse.jem.internal.beaninfo.adapters.*;

 /**
  * Beaninfo entry. Location of the beaninfos. Much like a standard classpath entry.
  * The BeanInfos are either in a jar or another project. They can be supplied as
  * a local file in the project, or as an external jar, or as external jar through a
  * variable, or an external jar through a plugin.
  * <p>
  * An external jar through containers is not valid because container are attached to
  * projects. they aren't standalone.
  *
  * @version 	1.0
  * @author
  */
 public class BeaninfoEntry implements IBeaninfosDocEntry {

 	final static String sBeaninfo = "beaninfo"; // Beaninfo entry, shared with BeaninfosDoc. //$NON-NLS-1$

 	public static final int BIE_PLUGIN = 100;	// Beaninfo jar can be found in a plugin.

 	static int kindFromString(String kindStr) {
 		if (kindStr == null || kindStr.length() == 0)
 			return BIE_PLUGIN;	// Default to plugin. If coming from beaninfoconfig, there should always be kind. But if coming from plugin.xml there shouldn't be one.
 		if (kindStr.equalsIgnoreCase("con")) //$NON-NLS-1$
 			return IClasspathEntry.CPE_CONTAINER;
 		if (kindStr.equalsIgnoreCase("var")) //$NON-NLS-1$
 			return IClasspathEntry.CPE_VARIABLE;
 		if (kindStr.equalsIgnoreCase("src")) //$NON-NLS-1$
 			return IClasspathEntry.CPE_SOURCE;
 		if (kindStr.equalsIgnoreCase("lib")) //$NON-NLS-1$
 			return IClasspathEntry.CPE_LIBRARY;
 		if (kindStr.equalsIgnoreCase("plugin")) //$NON-NLS-1$
 			return BIE_PLUGIN;
 		return -1;
 	}

 	static String kindToString(int kind) {

 		switch (kind) {
 			case IClasspathEntry.CPE_PROJECT :
 				return "src"; // backward compatibility //$NON-NLS-1$
 			case IClasspathEntry.CPE_SOURCE :
 				return "src"; //$NON-NLS-1$
 			case IClasspathEntry.CPE_LIBRARY :
 				return "lib"; //$NON-NLS-1$
 			case IClasspathEntry.CPE_VARIABLE :
 				return "var"; //$NON-NLS-1$
 			case IClasspathEntry.CPE_CONTAINER:
 				return "con"; //$NON-NLS-1$
 			case BIE_PLUGIN:
 				return "plugin";	//$NON-NLS-1$
 			default :
 				return "unknown"; //$NON-NLS-1$
 		}
 	}

 	/**
 	 * Return the appropriate kind of entry when we know it is a classpath entry.
 	 */
 	public static IClasspathEntry createEntry(int kind, IPath path, IProject project, boolean isExported) {
 		switch (kind) {

 			case IClasspathEntry.CPE_LIBRARY :
 				if (path.isAbsolute())
 					return JavaCore.newLibraryEntry(path, null, null, isExported);
 				break;

 			case IClasspathEntry.CPE_SOURCE :
 				if (path.isAbsolute()) {
 					// must be an entry in this project or specify another project
 					String projSegment = path.segment(0);
 					if (project != null && projSegment != null && projSegment.equals(project.getName())) {
 						// this project
 						return JavaCore.newSourceEntry(path);
 					} else {
 						// another project
 						return JavaCore.newProjectEntry(path, isExported);
 					}
 				}
 				break;

 			case IClasspathEntry.CPE_VARIABLE :
 				return JavaCore.newVariableEntry(path, null, null, isExported);

 			case IClasspathEntry.CPE_CONTAINER:
 				return JavaCore.newContainerEntry(path, isExported);

 		}

 		return null;
 	}
 	/**
 	 * Read the entry in from the element.
 	 */
 	public static BeaninfoEntry readEntry(IReader reader, Object element, IProject project) {
 		String elementKind = reader.getAttribute(element, BeaninfosDoc.sKind);
 		String pathStr = reader.getAttribute(element, BeaninfosDoc.sPath);
 		// ensure path is absolute
 		IPath path = new Path(pathStr);
 		int kind = kindFromString(elementKind);
 		if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && kind != BIE_PLUGIN && !path.isAbsolute()) {
 			path = project != null ? project.getFullPath().append(path) : path.makeAbsolute(); // Some folder/jar within this project
 		}

 		// exported flag
 		String exportedString = reader.getAttribute(element, BeaninfosDoc.sExported);
 		boolean isExported = "true".equalsIgnoreCase(exportedString); //$NON-NLS-1$
 		//$NON-NLS-1$

 		// recreate the entry
 		IClasspathEntry cpEntry = null;
 		IPath pluginPath = null;
 		if (kind != BIE_PLUGIN) {
 			cpEntry = createEntry(kind, path, project, isExported);
 		} else {
 			if (path.isAbsolute())
 				pluginPath = path;
 			else {
 				// Kludge This should only be a plugin type if from configuration element. So we will cast to that
 				// and get the plugin id to create an absolute plugin path.
 				if (element instanceof IConfigurationElement) {
 					pluginPath = new Path('/'+((IConfigurationElement) element).getDeclaringExtension().getContributor().getName()).append(path);
 				} else
 					return null;	// Not valid because can't have plugin from .beaninfoconfig file.
 			}
 		}

 		ArrayList searchpaths = new ArrayList();
 		Object children = reader.getChildren(element);
 		int childrenLength = reader.getLength(children);
 		for (int i = 0; i < childrenLength; i++) {
 			Object child = reader.getItem(children, i);
 			if (reader.isNodeTypeElement(child)) {
 				Object entry = null;
 				if (reader.getNodeName(child).equalsIgnoreCase(SearchpathEntry.sSearchpath)) {
 					entry = SearchpathEntry.readEntry(reader, child, project, true);
 				}
 				if (entry != null)
 					searchpaths.add(entry);
 			}
 		}

 		if (cpEntry != null)
 			return new BeaninfoEntry(
 				cpEntry,
 				(SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]),
 				isExported);
 		else return new BeaninfoEntry(
 				pluginPath,
 				(SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]),
 				isExported);
 	}

 	protected IClasspathEntry entry; // Store it as a classpath entry for convienence. It is the RAW classpath entry. This is only used when pointing to something other than a plugin.
 	protected IPath pluginPath;	// When stored in a plugin, this will be set instead.
 	protected boolean isExported;
 	protected SearchpathEntry[] searchpaths;

 	/**
 	 * Used when the beaninfo jar is within a plugin. In that case, the first segment
 	 * of the path is the plugin descriptor, and the rest is the path from the plugin
 	 * directory to the jar.
 	 */
 	public BeaninfoEntry(IPath pluginPath, SearchpathEntry[] searchpaths, boolean isExported) {
 		this(searchpaths, isExported);
 		this.pluginPath = pluginPath;
 	}

 	/**
 	 * Used when the beaninfo jar/folder is either an external jar/folder or is somewhere else
 	 * in the workspace. In that case the entry is the RAW classpath entry to that code.
 	 */
 	public BeaninfoEntry(IClasspathEntry entry, SearchpathEntry[] searchpaths, boolean isExported) {
 		this(searchpaths, isExported);
 		this.entry = entry;
 	}

 	protected BeaninfoEntry(SearchpathEntry[] searchpaths, boolean isExported) {
 		this.isExported = isExported;
 		this.searchpaths = searchpaths != null ? searchpaths : new SearchpathEntry[0];
 	}

 	public SearchpathEntry[] getSearchPaths() {
 		return searchpaths;
 	}

 	public void setSearchPaths(SearchpathEntry[] searchpaths) {
 		this.searchpaths = searchpaths;
 	}

 	public boolean isExported() {
 		return isExported;
 	}

 	public void setIsExported(boolean isExported) {
 		this.isExported = isExported;
 	}

 	public Node writeEntry(Document doc, IProject project) {

 		Element element = doc.createElement(sBeaninfo);
 		IPath path = null;
 		if (entry != null) {
 			element.setAttribute(BeaninfosDoc.sKind, kindToString(entry.getEntryKind()));
 			path = entry.getPath();
 			if (entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE && entry.getEntryKind() != IClasspathEntry.CPE_CONTAINER) {
 				// translate to project relative from absolute (unless a device path)
 				if (path.isAbsolute()) {
 					if (path.segment(0).equals(project.getFullPath().segment(0))) {
 						path = path.removeFirstSegments(1);
 						path = path.makeRelative();
 					} else {
 						path = path.makeAbsolute();
 					}
 				}
 			}
 		} else {
 			element.setAttribute(BeaninfosDoc.sKind, kindToString(BIE_PLUGIN));
 			path = pluginPath;
 		}

 		element.setAttribute(BeaninfosDoc.sPath, path.toString()); //$NON-NLS-1$
 		if (isExported()) {
 			element.setAttribute(BeaninfosDoc.sExported, "true"); //$NON-NLS-1$
 		}

 		for (int i = 0; i < searchpaths.length; i++) {
 			SearchpathEntry spe = searchpaths[i];
 			element.appendChild(spe.writeEntry(doc, project));
 		}

 		return element;
 	}

 	/**
 	 * If this is not a plugin info, then return the classpath entry.
 	 */
 	public IClasspathEntry getClasspathEntry() {
 		return entry;
 	}

 	/**
 	 * Return the resolved classpaths. Each entry in the array will be either:
 	 * 1) IProject - If it is a project type entry. Want the whole project
 	 * 2) String - an absolute external path to a jar
 	 * 3) IPath - a path to a plugin jar. The first segment is the plugin id, the rest is the path relative to that plugin.
 	 *
 	 *
 	 * @param javaProject
 	 * @return The array of paths, or <code>null</code> if no paths.
 	 *
 	 * @since 1.0.0
 	 */
 	public Object[] getClasspath(IJavaProject javaProject) {
 		if (entry != null) {
 			// It is a standard CPE Entry.
 			IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 			List paths = new ArrayList(1);
 			IClasspathEntry resolvedEntry = JavaCore.getResolvedClasspathEntry(entry);
 			resolveEntry(root, paths, resolvedEntry, javaProject);
 			return paths.toArray();
 		} else if (pluginPath != null)
 			return new Object[] {pluginPath};

 		return null;

 	}

 	private void resolveEntry(IWorkspaceRoot root, List paths, IClasspathEntry entry, IJavaProject javaProject) {
 		switch (entry.getEntryKind()) {
 			case IClasspathEntry.CPE_PROJECT :
 				IProject reqProject = (IProject) root.findMember(entry.getPath().lastSegment());
 				// Project entries only have one segment.
 				if (reqProject != null && reqProject.isOpen())
 					paths.add(reqProject);
 				break;

 			case IClasspathEntry.CPE_SOURCE :
 				reqProject = (IProject) root.findMember(entry.getPath().segment(0));
 				// Find project from the first segment.
 				IJavaProject jProject = JavaCore.create(reqProject);
 				if (jProject != null) {
 					try {
 						IPath outputLocation = jProject.getOutputLocation();
 						IResource resource = root.findMember(outputLocation);
 						if (resource != null) {
 							paths.add(resource.getLocation().toString());
 						}
 					} catch(JavaModelException e) {
 					}
 				}
 				break;

 			case IClasspathEntry.CPE_LIBRARY :
 				IResource library = root.findMember(entry.getPath());
 				// can be external or in workspace
 				paths.add((library != null) ? library.getLocation().toString() : entry.getPath().toString());
 				break;

 			case IClasspathEntry.CPE_CONTAINER:
 				try {
 					IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
 					if (container != null) {
 						IClasspathEntry[] entries = container.getClasspathEntries();
 						for (int i = 0; i < entries.length; i++) {
 							resolveEntry(root, paths, entries[i], javaProject);
 						}
 					}
 				} catch (JavaModelException e) {
 					BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
 				}
 		}
 	}

 	public int getKind() {
 		return entry != null ? entry.getEntryKind() : BIE_PLUGIN;
 	}

 	public IPath getPath() {
 		return entry != null ? entry.getPath() : pluginPath;
 	}

 	public boolean equals(Object other) {
 		if (this == other)
 			return true;

 		if (!(other instanceof BeaninfoEntry))
 			return false;

 		// Return equal if the classpath entry is the same classpath entry or plugin path entry.
 		// The search path doesn't have any affect on the semantic equality.
 		BeaninfoEntry otherEntry = (BeaninfoEntry) other;
 		if (isExported != otherEntry.isExported)
 			return false;
 		if (entry != null)
 			return entry.equals(otherEntry.entry);

 		return pluginPath.equals(otherEntry.pluginPath);
 	}

 	public int hashCode() {
 		if (entry != null)
 			return entry.hashCode() ^ (isExported ? Boolean.TRUE : Boolean.FALSE).hashCode();
 		else
 			return pluginPath.hashCode() ^ (isExported ? Boolean.TRUE : Boolean.FALSE).hashCode();
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2001, 2006 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
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jem.internal.beaninfo.core;
	/*


	*/

	import java.util.ArrayList;
	import java.util.List;
	import java.util.logging.Level;

	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;
	import org.eclipse.jdt.core.*;
	import org.w3c.dom.*;

	import org.eclipse.jem.internal.beaninfo.adapters.*;

	/**
	* Beaninfo entry. Location of the beaninfos. Much like a standard classpath entry.
	* The BeanInfos are either in a jar or another project. They can be supplied as
	* a local file in the project, or as an external jar, or as external jar through a
	* variable, or an external jar through a plugin.
	* <p>
	* An external jar through containers is not valid because container are attached to
	* projects. they aren't standalone.
	*
	* @version 1.0
	* @author
	*/
	public class BeaninfoEntry implements IBeaninfosDocEntry {

	final static String sBeaninfo = "beaninfo"; // Beaninfo entry, shared with BeaninfosDoc. //$NON-NLS-1$

	public static final int BIE_PLUGIN = 100; // Beaninfo jar can be found in a plugin.

	static int kindFromString(String kindStr) {
	if (kindStr == null \|\| kindStr.length() == 0)
	return BIE_PLUGIN; // Default to plugin. If coming from beaninfoconfig, there should always be kind. But if coming from plugin.xml there shouldn't be one.
	if (kindStr.equalsIgnoreCase("con")) //$NON-NLS-1$
	return IClasspathEntry.CPE_CONTAINER;
	if (kindStr.equalsIgnoreCase("var")) //$NON-NLS-1$
	return IClasspathEntry.CPE_VARIABLE;
	if (kindStr.equalsIgnoreCase("src")) //$NON-NLS-1$
	return IClasspathEntry.CPE_SOURCE;
	if (kindStr.equalsIgnoreCase("lib")) //$NON-NLS-1$
	return IClasspathEntry.CPE_LIBRARY;
	if (kindStr.equalsIgnoreCase("plugin")) //$NON-NLS-1$
	return BIE_PLUGIN;
	return -1;
	}

	static String kindToString(int kind) {

	switch (kind) {
	case IClasspathEntry.CPE_PROJECT :
	return "src"; // backward compatibility //$NON-NLS-1$
	case IClasspathEntry.CPE_SOURCE :
	return "src"; //$NON-NLS-1$
	case IClasspathEntry.CPE_LIBRARY :
	return "lib"; //$NON-NLS-1$
	case IClasspathEntry.CPE_VARIABLE :
	return "var"; //$NON-NLS-1$
	case IClasspathEntry.CPE_CONTAINER:
	return "con"; //$NON-NLS-1$
	case BIE_PLUGIN:
	return "plugin"; //$NON-NLS-1$
	default :
	return "unknown"; //$NON-NLS-1$
	}
	}

	/**
	* Return the appropriate kind of entry when we know it is a classpath entry.
	*/
	public static IClasspathEntry createEntry(int kind, IPath path, IProject project, boolean isExported) {
	switch (kind) {

	case IClasspathEntry.CPE_LIBRARY :
	if (path.isAbsolute())
	return JavaCore.newLibraryEntry(path, null, null, isExported);
	break;

	case IClasspathEntry.CPE_SOURCE :
	if (path.isAbsolute()) {
	// must be an entry in this project or specify another project
	String projSegment = path.segment(0);
	if (project != null && projSegment != null && projSegment.equals(project.getName())) {
	// this project
	return JavaCore.newSourceEntry(path);
	} else {
	// another project
	return JavaCore.newProjectEntry(path, isExported);
	}
	}
	break;

	case IClasspathEntry.CPE_VARIABLE :
	return JavaCore.newVariableEntry(path, null, null, isExported);

	case IClasspathEntry.CPE_CONTAINER:
	return JavaCore.newContainerEntry(path, isExported);

	}

	return null;
	}
	/**
	* Read the entry in from the element.
	*/
	public static BeaninfoEntry readEntry(IReader reader, Object element, IProject project) {
	String elementKind = reader.getAttribute(element, BeaninfosDoc.sKind);
	String pathStr = reader.getAttribute(element, BeaninfosDoc.sPath);
	// ensure path is absolute
	IPath path = new Path(pathStr);
	int kind = kindFromString(elementKind);
	if (kind != IClasspathEntry.CPE_VARIABLE && kind != IClasspathEntry.CPE_CONTAINER && kind != BIE_PLUGIN && !path.isAbsolute()) {
	path = project != null ? project.getFullPath().append(path) : path.makeAbsolute(); // Some folder/jar within this project
	}

	// exported flag
	String exportedString = reader.getAttribute(element, BeaninfosDoc.sExported);
	boolean isExported = "true".equalsIgnoreCase(exportedString); //$NON-NLS-1$
	//$NON-NLS-1$

	// recreate the entry
	IClasspathEntry cpEntry = null;
	IPath pluginPath = null;
	if (kind != BIE_PLUGIN) {
	cpEntry = createEntry(kind, path, project, isExported);
	} else {
	if (path.isAbsolute())
	pluginPath = path;
	else {
	// Kludge This should only be a plugin type if from configuration element. So we will cast to that
	// and get the plugin id to create an absolute plugin path.
	if (element instanceof IConfigurationElement) {
	pluginPath = new Path('/'+((IConfigurationElement) element).getDeclaringExtension().getContributor().getName()).append(path);
	} else
	return null; // Not valid because can't have plugin from .beaninfoconfig file.
	}
	}

	ArrayList searchpaths = new ArrayList();
	Object children = reader.getChildren(element);
	int childrenLength = reader.getLength(children);
	for (int i = 0; i < childrenLength; i++) {
	Object child = reader.getItem(children, i);
	if (reader.isNodeTypeElement(child)) {
	Object entry = null;
	if (reader.getNodeName(child).equalsIgnoreCase(SearchpathEntry.sSearchpath)) {
	entry = SearchpathEntry.readEntry(reader, child, project, true);
	}
	if (entry != null)
	searchpaths.add(entry);
	}
	}

	if (cpEntry != null)
	return new BeaninfoEntry(
	cpEntry,
	(SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]),
	isExported);
	else return new BeaninfoEntry(
	pluginPath,
	(SearchpathEntry[]) searchpaths.toArray(new SearchpathEntry[searchpaths.size()]),
	isExported);
	}

	protected IClasspathEntry entry; // Store it as a classpath entry for convienence. It is the RAW classpath entry. This is only used when pointing to something other than a plugin.
	protected IPath pluginPath; // When stored in a plugin, this will be set instead.
	protected boolean isExported;
	protected SearchpathEntry[] searchpaths;

	/**
	* Used when the beaninfo jar is within a plugin. In that case, the first segment
	* of the path is the plugin descriptor, and the rest is the path from the plugin
	* directory to the jar.
	*/
	public BeaninfoEntry(IPath pluginPath, SearchpathEntry[] searchpaths, boolean isExported) {
	this(searchpaths, isExported);
	this.pluginPath = pluginPath;
	}

	/**
	* Used when the beaninfo jar/folder is either an external jar/folder or is somewhere else
	* in the workspace. In that case the entry is the RAW classpath entry to that code.
	*/
	public BeaninfoEntry(IClasspathEntry entry, SearchpathEntry[] searchpaths, boolean isExported) {
	this(searchpaths, isExported);
	this.entry = entry;
	}

	protected BeaninfoEntry(SearchpathEntry[] searchpaths, boolean isExported) {
	this.isExported = isExported;
	this.searchpaths = searchpaths != null ? searchpaths : new SearchpathEntry[0];
	}

	public SearchpathEntry[] getSearchPaths() {
	return searchpaths;
	}

	public void setSearchPaths(SearchpathEntry[] searchpaths) {
	this.searchpaths = searchpaths;
	}

	public boolean isExported() {
	return isExported;
	}

	public void setIsExported(boolean isExported) {
	this.isExported = isExported;
	}

	public Node writeEntry(Document doc, IProject project) {

	Element element = doc.createElement(sBeaninfo);
	IPath path = null;
	if (entry != null) {
	element.setAttribute(BeaninfosDoc.sKind, kindToString(entry.getEntryKind()));
	path = entry.getPath();
	if (entry.getEntryKind() != IClasspathEntry.CPE_VARIABLE && entry.getEntryKind() != IClasspathEntry.CPE_CONTAINER) {
	// translate to project relative from absolute (unless a device path)
	if (path.isAbsolute()) {
	if (path.segment(0).equals(project.getFullPath().segment(0))) {
	path = path.removeFirstSegments(1);
	path = path.makeRelative();
	} else {
	path = path.makeAbsolute();
	}
	}
	}
	} else {
	element.setAttribute(BeaninfosDoc.sKind, kindToString(BIE_PLUGIN));
	path = pluginPath;
	}

	element.setAttribute(BeaninfosDoc.sPath, path.toString()); //$NON-NLS-1$
	if (isExported()) {
	element.setAttribute(BeaninfosDoc.sExported, "true"); //$NON-NLS-1$
	}

	for (int i = 0; i < searchpaths.length; i++) {
	SearchpathEntry spe = searchpaths[i];
	element.appendChild(spe.writeEntry(doc, project));
	}

	return element;
	}

	/**
	* If this is not a plugin info, then return the classpath entry.
	*/
	public IClasspathEntry getClasspathEntry() {
	return entry;
	}

	/**
	* Return the resolved classpaths. Each entry in the array will be either:
	* 1) IProject - If it is a project type entry. Want the whole project
	* 2) String - an absolute external path to a jar
	* 3) IPath - a path to a plugin jar. The first segment is the plugin id, the rest is the path relative to that plugin.
	*
	*
	* @param javaProject
	* @return The array of paths, or <code>null</code> if no paths.
	*
	* @since 1.0.0
	*/
	public Object[] getClasspath(IJavaProject javaProject) {
	if (entry != null) {
	// It is a standard CPE Entry.
	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
	List paths = new ArrayList(1);
	IClasspathEntry resolvedEntry = JavaCore.getResolvedClasspathEntry(entry);
	resolveEntry(root, paths, resolvedEntry, javaProject);
	return paths.toArray();
	} else if (pluginPath != null)
	return new Object[] {pluginPath};

	return null;

	}

	private void resolveEntry(IWorkspaceRoot root, List paths, IClasspathEntry entry, IJavaProject javaProject) {
	switch (entry.getEntryKind()) {
	case IClasspathEntry.CPE_PROJECT :
	IProject reqProject = (IProject) root.findMember(entry.getPath().lastSegment());
	// Project entries only have one segment.
	if (reqProject != null && reqProject.isOpen())
	paths.add(reqProject);
	break;

	case IClasspathEntry.CPE_SOURCE :
	reqProject = (IProject) root.findMember(entry.getPath().segment(0));
	// Find project from the first segment.
	IJavaProject jProject = JavaCore.create(reqProject);
	if (jProject != null) {
	try {
	IPath outputLocation = jProject.getOutputLocation();
	IResource resource = root.findMember(outputLocation);
	if (resource != null) {
	paths.add(resource.getLocation().toString());
	}
	} catch(JavaModelException e) {
	}
	}
	break;

	case IClasspathEntry.CPE_LIBRARY :
	IResource library = root.findMember(entry.getPath());
	// can be external or in workspace
	paths.add((library != null) ? library.getLocation().toString() : entry.getPath().toString());
	break;

	case IClasspathEntry.CPE_CONTAINER:
	try {
	IClasspathContainer container = JavaCore.getClasspathContainer(entry.getPath(), javaProject);
	if (container != null) {
	IClasspathEntry[] entries = container.getClasspathEntries();
	for (int i = 0; i < entries.length; i++) {
	resolveEntry(root, paths, entries[i], javaProject);
	}
	}
	} catch (JavaModelException e) {
	BeaninfoPlugin.getPlugin().getLogger().log(e, Level.WARNING);
	}
	}
	}

	public int getKind() {
	return entry != null ? entry.getEntryKind() : BIE_PLUGIN;
	}

	public IPath getPath() {
	return entry != null ? entry.getPath() : pluginPath;
	}

	public boolean equals(Object other) {
	if (this == other)
	return true;

	if (!(other instanceof BeaninfoEntry))
	return false;

	// Return equal if the classpath entry is the same classpath entry or plugin path entry.
	// The search path doesn't have any affect on the semantic equality.
	BeaninfoEntry otherEntry = (BeaninfoEntry) other;
	if (isExported != otherEntry.isExported)
	return false;
	if (entry != null)
	return entry.equals(otherEntry.entry);

	return pluginPath.equals(otherEntry.pluginPath);
	}

	public int hashCode() {
	if (entry != null)
	return entry.hashCode() ^ (isExported ? Boolean.TRUE : Boolean.FALSE).hashCode();
	else
	return pluginPath.hashCode() ^ (isExported ? Boolean.TRUE : Boolean.FALSE).hashCode();
	}

	}