Java tutorial
/******************************************************************************* * 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(); } }