| /******************************************************************************* |
| * 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 |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jst.j2ee.internal.project; |
| |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jdt.core.JavaModelException; |
| import org.eclipse.jem.internal.plugin.JavaProjectInfo; |
| import org.eclipse.wst.server.core.IRuntime; |
| |
| /** |
| * This class stores the info required for creating a new J2EE project; not all info will apply to |
| * all kinds of projects |
| */ |
| public class J2EEJavaProjectInfo extends JavaProjectInfo { |
| protected static final String SRCROOT_VAR = "JRE_SRCROOT"; //$NON-NLS-1$ |
| protected IProject project; |
| protected String jdkRTJarPath; |
| protected String projectName; |
| protected IPath projectLocation; |
| protected String javaOutputPath; |
| protected IClasspathEntry[] classpathEntries; |
| protected boolean shouldInitializeDefaultClasspath = true; |
| protected String natureId; |
| protected IRuntime serverTarget; |
| protected int moduleVersion; |
| |
| /** |
| * EJBProjectInfo constructor comment. |
| */ |
| public J2EEJavaProjectInfo() { |
| super(); |
| } |
| |
| /** |
| * EJBProjectInfo constructor comment. |
| */ |
| public J2EEJavaProjectInfo(IProject project) { |
| super(); |
| setProject(project); |
| } |
| |
| public IClasspathEntry[] calculateServerClasspathEntries() throws JavaModelException { |
| IJavaProject javaProject = getJavaProject(); |
| if (javaProject == null) |
| return null; |
| if (getProject().exists()) { |
| //We don't need to remove a server target anyomre as it need to be there |
| //ServerTargetManager.removeServerTarget(getProject(),null); |
| IClasspathEntry[] ces = javaProject.getRawClasspath(); |
| if (ces.length > 0) |
| addToClasspathEntries(ces); |
| } |
| addServerJdkRuntimeToClasspathEntries(); |
| addServerJarsToClasspathEntries(); |
| return classpathEntries; |
| } |
| |
| /** |
| * Sets up the default classpath for this project |
| */ |
| protected void addDefaultToClasspathEntries() { |
| addToClasspathEntries(computeDefaultJavaClasspath()); |
| } |
| |
| /** |
| * Set the corresponding jsp and servlet levels. Creation date: (11/09/00 10:05:24 AM) |
| */ |
| public void setJ2EEVersion(int newVersion) { |
| } |
| |
| |
| /** |
| * add the source folder to classpath dir (IClasspathEntry.CPE_SOURCE) |
| */ |
| public void addJavaSourceToClasspathEntries() { |
| IPath sourceClassPath = new Path(getFullSourcePath()); |
| addToClasspathEntries(new IClasspathEntry[]{JavaCore.newSourceEntry(sourceClassPath)}); |
| } |
| |
| public boolean addJdkJarToClasspathEntries(String jdkJarFullPathName) { |
| |
| IJavaProject javaProject = getJavaProject(); |
| if (javaProject == null) |
| return false; |
| |
| IClasspathEntry[] entry = new IClasspathEntry[1]; |
| Path path = new Path(jdkJarFullPathName); |
| if (!path.toFile().exists()) { |
| org.eclipse.jem.util.logger.proxy.Logger.getLogger().logError(J2EECreationResourceHandler.getString(J2EECreationResourceHandler.JdkJarFileDoesNotExist_UI, new Object[]{jdkJarFullPathName})); |
| return false; |
| } |
| |
| entry[0] = JavaCore.newLibraryEntry(path, null, null); |
| addToClasspathEntries(entry); |
| |
| return true; |
| } |
| |
| /** |
| * add rt.jar form the server.jdk plugin |
| */ |
| public void addServerJdkRuntimeToClasspathEntries() { |
| addToClasspathEntries(getServerJDKClasspathEntries()); |
| } |
| |
| public IClasspathEntry[] getServerJDKClasspathEntries() { |
| List list = new ArrayList(4); |
| //TODO This class should be deleted. |
| // if (isJ2EE13() |
| // || !org.eclipse.jst.j2ee.internal.internal.plugin.J2EEPlugin.hasDevelopmentRole()) { |
| // list.add(JavaCore.newVariableEntry(new |
| // Path(IEJBNatureConstants.SERVERJDK_50_PLUGINDIR_VARIABLE + "/jre/lib/rt.jar"), |
| // //$NON-NLS-1$ |
| // new Path(IEJBNatureConstants.SERVERJDK_50_PLUGINDIR_VARIABLE + "/src.jar"), //$NON-NLS-1$ |
| // new Path(IEJBNatureConstants.SERVERJDK_SRCROOT_VARIABLE))); //$NON-NLS-1$ |
| // } else { |
| // list.add(JavaCore.newVariableEntry(new |
| // Path(IEJBNatureConstants.SERVERJDK_PLUGINDIR_VARIABLE + "/jre/lib/rt.jar"), //$NON-NLS-1$ |
| // new Path(IEJBNatureConstants.SERVERJDK_PLUGINDIR_VARIABLE + "/src.jar"), //$NON-NLS-1$ |
| // new Path(IEJBNatureConstants.SERVERJDK_SRCROOT_VARIABLE))); //$NON-NLS-1$ |
| // } |
| return (IClasspathEntry[]) list.toArray(new IClasspathEntry[list.size()]); |
| } |
| |
| /** |
| * Adds entries to the class path for this project |
| */ |
| public void addToClasspathEntries(IClasspathEntry[] entries) { |
| |
| java.util.List list = new ArrayList(10); |
| // add the existing ones if any |
| if (classpathEntries != null) |
| list.addAll(Arrays.asList(classpathEntries)); |
| |
| // add the new ones |
| list.addAll(Arrays.asList(entries)); |
| |
| // convert |
| classpathEntries = new IClasspathEntry[list.size()]; |
| classpathEntries = (IClasspathEntry[]) list.toArray(classpathEntries); |
| |
| } |
| |
| public boolean addVariableJarToClasspathEntries(String fullPath) { |
| |
| IJavaProject javaProject = getJavaProject(); |
| if (javaProject == null) |
| return false; |
| |
| IClasspathEntry[] entry = new IClasspathEntry[1]; |
| entry[0] = JavaCore.newVariableEntry(new Path(fullPath), null, null); |
| addToClasspathEntries(entry); |
| return true; |
| } |
| |
| public boolean addVariableJarToClasspathEntriesWithAttachments(String fullPath, String srcPath, String srcRoot) { |
| |
| IJavaProject javaProject = getJavaProject(); |
| if (javaProject == null) |
| return false; |
| |
| IClasspathEntry[] entry = new IClasspathEntry[1]; |
| entry[0] = JavaCore.newVariableEntry(new Path(fullPath), new Path(srcPath), new Path(srcRoot)); |
| addToClasspathEntries(entry); |
| return true; |
| } |
| |
| /** |
| * Return the default classpath for projects of this kind; subclasses should override for |
| * setting up new projects |
| */ |
| protected IClasspathEntry[] computeDefaultJavaClasspath() { |
| IJavaProject javaProject = getJavaProject(); |
| if (javaProject == null) |
| return null; |
| addJavaSourceToClasspathEntries(); |
| if (serverTarget == null) { |
| addServerJdkRuntimeToClasspathEntries(); |
| addServerJarsToClasspathEntries(); |
| } |
| return classpathEntries; |
| } |
| |
| /** |
| * Sublcasses have to overide this method to set the server jars |
| */ |
| public void addServerJarsToClasspathEntries() { |
| |
| } |
| |
| /** |
| * Creates a project handle with a specified path. The project resource should <b>not </b> be |
| * created concretely here; |
| */ |
| public IProject createProjectHandle(IPath projectPath) { |
| return getWorkspace().getRoot().getProject(projectPath.segment(0)); |
| } |
| |
| public IClasspathEntry[] getClasspathEntries() { |
| if (classpathEntries == null) |
| initializeClasspathEntries(); |
| return classpathEntries; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (11/09/00 10:05:24 AM) |
| * |
| * @return java.lang.String |
| */ |
| public java.lang.String getDefaultContextRoot() { |
| return null; |
| } |
| |
| /** |
| * Subclasses should override as necessary |
| */ |
| protected String getDefaultJavaOutputPath() { |
| return DEFAULT_JAVA_OUTPUT_PATH; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (11/09/00 10:05:24 AM) |
| * |
| * @return java.lang.String |
| */ |
| public java.lang.String getDefaultUri() { |
| return projectName.replace(' ', '_') + ".jar"; //$NON-NLS-1$ |
| } |
| |
| /** |
| * Get the java output folder for the receiver, in the form of /project/ <output folder> |
| * |
| * @return java.lang.String |
| */ |
| public String getFullJavaOutputPath() { |
| return Path.ROOT.append(getProjectPath()).append(getJavaOutputPath()).toString(); |
| } |
| |
| /** |
| * Get the module path folder for the receiver in the form of /project/modulepath |
| * |
| * @return java.lang.String |
| */ |
| protected String getFullSourcePath() { |
| return Path.ROOT.append(getProjectPath()).append(getSourcePath()).toString(); |
| } |
| |
| /** |
| * Returns the project relative path of the java build destination |
| */ |
| public java.lang.String getJavaOutputPath() { |
| if (javaOutputPath == null) |
| javaOutputPath = getDefaultJavaOutputPath(); |
| return javaOutputPath; |
| } |
| |
| /** |
| * @param i |
| */ |
| public void setModuleVersion(int version) { |
| moduleVersion = version; |
| } |
| |
| public IJavaProject getJavaProject() { |
| // needed to get an IJavaProject to create classpaths from. |
| IProject aProject = getProject(); |
| if (aProject == null) |
| aProject = getWorkspace().getRoot().getProject(getProjectName()); |
| |
| return JavaCore.create(aProject); |
| } |
| |
| /** |
| * Return the absolute path of the default jdk rt.jar to use for this project |
| */ |
| public java.lang.String getJdkRTJarPath() { |
| return jdkRTJarPath; |
| } |
| |
| /** |
| * Return the project being created; checks the workspace for an existing project |
| */ |
| public IProject getProject() { |
| if (project == null) { |
| IProject aProject = getWorkspace().getRoot().getProject(getProjectName()); |
| if (aProject.exists()) |
| project = aProject; |
| } |
| return project; |
| } |
| |
| /** |
| * Return the location of the project in the file system. |
| * |
| * @return org.eclipse.core.runtime.IPath |
| */ |
| public IPath getProjectLocation() { |
| return projectLocation; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (11/09/00 10:05:24 AM) |
| * |
| * @return java.lang.String |
| */ |
| public java.lang.String getProjectName() { |
| if (projectName == null && project != null) |
| projectName = project.getName(); |
| return projectName; |
| } |
| |
| public IPath getProjectPath() { |
| return new Path(getProjectName()); |
| } |
| |
| public IWorkspace getWorkspace() { |
| return org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.getWorkspace(); |
| } |
| |
| /** |
| * Lazy initialization - useGetClasspathEntries |
| */ |
| protected void initializeClasspathEntries() { |
| if (shouldInitializeDefaultClasspath()) |
| computeDefaultJavaClasspath(); |
| else |
| classpathEntries = new IClasspathEntry[0]; |
| } |
| |
| /** |
| * Answer false by default |
| * |
| * @deprecated - Use getModuleVersion() with J2EEVersionConstants |
| */ |
| protected boolean isJ2EE13() { |
| return false; |
| } |
| |
| public IProject primGetProject() { |
| return project; |
| } |
| |
| public void removeClasspathEntry(IClasspathEntry entry) { |
| if (entry == null) |
| return; |
| |
| List list = new ArrayList(Arrays.asList(getClasspathEntries())); |
| list.remove(entry); |
| classpathEntries = (IClasspathEntry[]) list.toArray(new IClasspathEntry[list.size()]); |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (11/10/00 10:09:58 AM) |
| * |
| * @param newClassPathEntries |
| * org.eclipse.jdt.core.api.IClasspathEntry |
| */ |
| public void setClasspathEntries(IClasspathEntry[] newClasspathEntries) { |
| classpathEntries = newClasspathEntries; |
| } |
| |
| public void setJavaOutputPath(String path) { |
| javaOutputPath = path; |
| } |
| |
| public void setJdkRTJarPath(String path) { |
| jdkRTJarPath = path; |
| } |
| |
| public void setProject(IProject aProject) { |
| project = aProject; |
| } |
| |
| /** |
| * Set the location in the file system that the project is to be created. |
| * |
| * @param newProjectLocation |
| * IPath |
| */ |
| public void setProjectLocation(IPath newProjectLocation) { |
| projectLocation = newProjectLocation; |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (11/09/00 10:05:24 AM) |
| * |
| * @param newProjectName |
| * java.lang.String |
| */ |
| public void setProjectName(java.lang.String newProjectName) { |
| if (projectName != newProjectName) |
| setClasspathEntries(null); |
| projectName = newProjectName; |
| } |
| |
| public void setShouldInitializeDefaultClasspath(boolean value) { |
| shouldInitializeDefaultClasspath = value; |
| } |
| |
| public boolean shouldInitializeDefaultClasspath() { |
| return shouldInitializeDefaultClasspath; |
| } |
| |
| /** |
| * Gets the natureId. |
| * |
| * @return Returns a String |
| */ |
| public String getNatureId() { |
| if (natureId == null) |
| return getDefaultNatureId(); |
| return natureId; |
| } |
| |
| /** |
| * returns the correct nature id string based on the J2EE spec level being used |
| */ |
| public String getDefaultNatureId() { |
| return null; |
| } |
| |
| /** |
| * Sets the natureId. |
| * |
| * @param natureId |
| * The natureId to set |
| */ |
| public void setNatureId(String natureId) { |
| this.natureId = natureId; |
| } |
| |
| /** |
| * Get the correct WAS classpath variable based on the J2EE version. |
| */ |
| protected String getWASPluginVariable() { |
| //TODO This class needs to be deleted. |
| // if (isJ2EE13() |
| // || !org.eclipse.jst.j2ee.internal.internal.plugin.J2EEPlugin.hasDevelopmentRole()) |
| // return IEJBNatureConstants.WAS_50_PLUGINDIR_VARIABLE; |
| // else |
| // return IEJBNatureConstants.WAS_PLUGINDIR_VARIABLE; |
| return ""; //$NON-NLS-1$ |
| } |
| |
| public int getModuleVersion() { |
| return moduleVersion; |
| } |
| |
| /** |
| * @return |
| */ |
| public IRuntime getServerTarget() { |
| return serverTarget; |
| } |
| |
| /** |
| * @param target |
| */ |
| public void setServerTarget(IRuntime target) { |
| serverTarget = target; |
| } |
| } |