JavaProject.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.phpdt.internal.core |
 |
 |
PHPeclipse |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| LINE_COMMENT | Number of line comments |  |
| EXEC_COMMENTS | Comments in executable code | |
| COMMENTS | Comment lines | |
| DECL_COMMENTS | Comments in declarations | |
| SIZE | Size of the file in bytes | |
| CYCLOMATIC | Cyclomatic complexity | |
| LINES | Number of lines in the source file | |
| RETURNS | Number of return points from functions | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| BLOCKS | Number of blocks | |
| ELOC | Effective lines of code | |
| EXITS | Procedure exits | |
| LOC | Lines of code | |
| OPERATORS | Number of operators | |
| PROGRAM_LENGTH | Halstead program length | |
| COMPARISONS | Number of comparison operators | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
| OPERANDS | Number of operands | |
| LOGICAL_LINES | Number of statements | |
| LOOPS | Number of loops | |
| PARAMS | Number of formal parameter declarations | |
| UNIQUE_OPERANDS | Number of unique operands | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| FUNCTIONS | Number of function declarations | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0115 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| DOC_COMMENT | Number of javadoc comment lines | |
| WHITESPACE | Number of whitespace lines | |
| JAVA0177 | JAVA0177 Variable declaration missing initializer | |
| JAVA0270 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0049 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0031 | JAVA0031 Case statement not properly closed | |
| JAVA0160 | JAVA0160 Method does not throw specified exception | |
| JAVA0179 | JAVA0179 Local variable hides visible field | |
| JAVA0266 | JAVA0266 Use of System.out | |
| JAVA0254 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0032 | JAVA0032 Switch statement missing default | |
| JAVA0285 | JAVA0285 Dereference of potentially null variable | |
| JAVA0144 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0171 | JAVA0171 Unused local variable | |
| JAVA0259 | JAVA0259 Return of collection/array field | |
| JAVA0071 | JAVA0071 Strings compared with == | |
| UNIQUE_OPERATORS | Number of unique operators | |
| JAVA0174 | JAVA0174 Assigned local variable never used | |
| JAVA0138 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| NEST_DEPTH | Maximum nesting depth | |
| JAVA0075 | JAVA0075 Method parameter hides field | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| BLOCK_COMMENT | Number of block comment lines | |
| JAVA0130 | JAVA0130 Non-static method does not use instance fields | |
/*******************************************************************************
* Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package net.sourceforge.phpdt.internal.core;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import net.sourceforge.phpdt.core.IClasspathEntry;
import net.sourceforge.phpdt.core.ICompilationUnit;
import net.sourceforge.phpdt.core.IJavaElement;
import net.sourceforge.phpdt.core.IJavaModelMarker;
import net.sourceforge.phpdt.core.IJavaModelStatus;
import net.sourceforge.phpdt.core.IJavaModelStatusConstants;
import net.sourceforge.phpdt.core.IJavaProject;
import net.sourceforge.phpdt.core.IPackageFragment;
import net.sourceforge.phpdt.core.IPackageFragmentRoot;
import net.sourceforge.phpdt.core.JavaCore;
import net.sourceforge.phpdt.core.JavaModelException;
import net.sourceforge.phpdt.core.WorkingCopyOwner;
import net.sourceforge.phpdt.internal.codeassist.ISearchableNameEnvironment;
import net.sourceforge.phpdt.internal.compiler.util.ObjectVector;
import net.sourceforge.phpdt.internal.core.util.MementoTokenizer;
import net.sourceforge.phpdt.internal.core.util.Util;
import net.sourceforge.phpdt.internal.corext.Assert;
import net.sourceforge.phpeclipse.LoadPathEntry;
import net.sourceforge.phpeclipse.PHPeclipsePlugin;
import org.eclipse.core.resources.ICommand;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IProjectNature;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Preferences;
import org.eclipse.core.runtime.QualifiedName;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
/**
* Handle for a Java Project.
*
* <p>
* A Java Project internally maintains a devpath that corresponds to the
* project's classpath. The classpath may include source folders from the
* current project; jars in the current project, other projects, and the local
* file system; and binary folders (output location) of other projects. The Java
* Model presents source elements corresponding to output .class files in other
* projects, and thus uses the devpath rather than the classpath (which is
* really a compilation path). The devpath mimics the classpath, except has
* source folder entries in place of output locations in external projects.
*
* <p>
* Each JavaProject has a NameLookup facility that locates elements on by name,
* based on the devpath.
*
* @see IJavaProject
*/
public class JavaProject extends Openable implements IJavaProject,
IProjectNature {
/**
* Whether the underlying file system is case sensitive.
*/
protected static final boolean IS_CASE_SENSITIVE = !new File("Temp").equals(new File("temp")); //$NON-NLS-1$ //$NON-NLS-2$
/**
* An empty array of strings indicating that a project doesn't have any
* prerequesite projects.
*/
protected static final String[] NO_PREREQUISITES = new String[0];
/**
* The platform project this <code>IJavaProject</code> is based on
*/
protected IProject project;
protected List fLoadPathEntries;
protected boolean fScratched;
/**
* Name of file containing project classpath
*/
public static final String CLASSPATH_FILENAME = ".classpath"; //$NON-NLS-1$
/**
* Name of file containing custom project preferences
*/
public static final String PREF_FILENAME = ".jprefs"; //$NON-NLS-1$
/**
* Value of the project's raw classpath if the .classpath file contains
* invalid entries.
*/
public static final IClasspathEntry[] INVALID_CLASSPATH = new IClasspathEntry[0];
private static final String CUSTOM_DEFAULT_OPTION_VALUE = "#\r\n\r#custom-non-empty-default-value#\r\n\r#"; //$NON-NLS-1$
/*
* Value of project's resolved classpath while it is being resolved
*/
private static final IClasspathEntry[] RESOLUTION_IN_PROGRESS = new IClasspathEntry[0];
/**
* Returns a canonicalized path from the given external path. Note that the
* return path contains the same number of segments and it contains a device
* only if the given path contained one.
*
* @see java.io.File for the definition of a canonicalized path
*/
public static IPath canonicalizedPath(IPath externalPath) {
if (externalPath == null)
return null;
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonicalizing " + externalPath.toString()); //$NON-NLS-1$
}
if (IS_CASE_SENSITIVE) {
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonical path is original path (file system is case sensitive)"); //$NON-NLS-1$
}
return externalPath;
}
// if not external path, return original path
IWorkspace workspace = ResourcesPlugin.getWorkspace();
if (workspace == null)
return externalPath; // protection during shutdown (30487)
if (workspace.getRoot().findMember(externalPath) != null) {
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonical path is original path (member of workspace)"); //$NON-NLS-1$
}
return externalPath;
}
IPath canonicalPath = null;
try {
canonicalPath = new Path(new File(externalPath.toOSString())
.getCanonicalPath());
} catch (IOException e) {
// default to original path
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonical path is original path (IOException)"); //$NON-NLS-1$
}
return externalPath;
}
IPath result;
int canonicalLength = canonicalPath.segmentCount();
if (canonicalLength == 0) {
// the java.io.File canonicalization failed
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonical path is original path (canonical path is empty)"); //$NON-NLS-1$
}
return externalPath;
} else if (externalPath.isAbsolute()) {
result = canonicalPath;
} else {
// if path is relative, remove the first segments that were added by
// the java.io.File canonicalization
// e.g. 'lib/classes.zip' was converted to
// 'd:/myfolder/lib/classes.zip'
int externalLength = externalPath.segmentCount();
if (canonicalLength >= externalLength) {
result = canonicalPath.removeFirstSegments(canonicalLength
- externalLength);
} else {
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonical path is original path (canonical path is " + canonicalPath.toString() + ")"); //$NON-NLS-1$ //$NON-NLS-2$
}
return externalPath;
}
}
// keep device only if it was specified (this is because
// File.getCanonicalPath() converts '/lib/classed.zip' to
// 'd:/lib/classes/zip')
if (externalPath.getDevice() == null) {
result = result.setDevice(null);
}
if (JavaModelManager.VERBOSE) {
System.out
.println("JAVA MODEL - Canonical path is " + result.toString()); //$NON-NLS-1$
}
return result;
}
/**
* Constructor needed for <code>IProject.getNature()</code> and
* <code>IProject.addNature()</code>.
*
* @see #setProject(IProject)
*/
public JavaProject() {
super(null, null);
}
public JavaProject(IProject project, JavaElement parent) {
super(parent, project.getName());
this.project = project;
}
public void addLoadPathEntry(IProject anotherPHPProject) {
fScratched = true;
LoadPathEntry newEntry = new LoadPathEntry(anotherPHPProject);
getLoadPathEntries().add(newEntry);
}
public void configure() throws CoreException {
// get project description and then the associated build commands
IProjectDescription desc = project.getDescription();
ICommand[] commands = desc.getBuildSpec();
// determine if builder already associated
boolean found = false;
for (int i = 0; i < commands.length; ++i) {
if (commands[i].getBuilderName().equals(
PHPeclipsePlugin.BUILDER_PARSER_ID)) {
found = true;
break;
}
}
// add builder if not already in project
if (!found) {
ICommand command = desc.newCommand();
command.setBuilderName(PHPeclipsePlugin.BUILDER_PARSER_ID);
ICommand[] newCommands = new ICommand[commands.length + 1];
// Add it before other builders.
System.arraycopy(commands, 0, newCommands, 1, commands.length);
newCommands[0] = command;
desc.setBuildSpec(newCommands);
project.setDescription(desc, null);
}
}
protected void loadLoadPathEntries() {
fLoadPathEntries = new ArrayList();
IFile loadPathsFile = getLoadPathEntriesFile();
XMLReader reader = null;
try {
reader = SAXParserFactory.newInstance().newSAXParser()
.getXMLReader();
reader.setContentHandler(getLoadPathEntriesContentHandler());
reader.parse(new InputSource(loadPathsFile.getContents()));
} catch (Exception e) {
// the file is nonextant or unreadable
}
}
public List getLoadPathEntries() {
if (fLoadPathEntries == null) {
loadLoadPathEntries();
}
return fLoadPathEntries;
}
protected ContentHandler getLoadPathEntriesContentHandler() {
return new ContentHandler() {
public void characters(char[] arg0, int arg1, int arg2)
throws SAXException {
}
public void endDocument() throws SAXException {
}
public void endElement(String arg0, String arg1, String arg2)
throws SAXException {
}
public void endPrefixMapping(String arg0) throws SAXException {
}
public void ignorableWhitespace(char[] arg0, int arg1, int arg2)
throws SAXException {
}
public void processingInstruction(String arg0, String arg1)
throws SAXException {
}
public void setDocumentLocator(Locator arg0) {
}
public void skippedEntity(String arg0) throws SAXException {
}
public void startDocument() throws SAXException {
}
public void startElement(String namespaceURI, String localName,
String qName, Attributes atts) throws SAXException {
if ("pathentry".equals(qName))
if ("project".equals(atts.getValue("type"))) {
IPath referencedProjectPath = new Path(atts
.getValue("path"));
IProject referencedProject = getProject(referencedProjectPath
.lastSegment());
fLoadPathEntries.add(new LoadPathEntry(
referencedProject));
}
}
public void startPrefixMapping(String arg0, String arg1)
throws SAXException {
}
};
}
protected IFile getLoadPathEntriesFile() {
return project.getFile(".loadpath");
}
protected String getLoadPathXML() {
StringBuffer buffer = new StringBuffer();
buffer.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?><loadpath>");
Iterator pathEntriesIterator = fLoadPathEntries.iterator();
while (pathEntriesIterator.hasNext()) {
LoadPathEntry entry = (LoadPathEntry) pathEntriesIterator.next();
buffer.append(entry.toXML());
}
buffer.append("</loadpath>");
return buffer.toString();
}
/**
* Adds a builder to the build spec for the given project.
*/
protected void addToBuildSpec(String builderID) throws CoreException {
IProjectDescription description = getProject().getDescription();
ICommand javaCommand = getJavaCommand(description);
if (javaCommand == null) {
// Add a Java command to the build spec
ICommand command = description.newCommand();
command.setBuilderName(builderID);
setJavaCommand(description, command);
}
}
/**
* @see Openable
*/
protected boolean buildStructure(OpenableElementInfo info,
IProgressMonitor pm, Map newElements, IResource underlyingResource)
throws JavaModelException {
// check whether the java project can be opened
if (!underlyingResource.isAccessible()) {
throw newNotPresentException();
}
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IWorkspaceRoot wRoot = workspace.getRoot();
// cannot refresh cp markers on opening (emulate cp check on startup)
// since can create deadlocks (see bug 37274)
// IClasspathEntry[] resolvedClasspath =
// getResolvedClasspath(true/*ignoreUnresolvedEntry*/, false/*don't
// generateMarkerOnError*/, false/*don't returnResolutionInProgress*/);
// // compute the pkg fragment roots
// info.setChildren(computePackageFragmentRoots(resolvedClasspath,
// false));
//
// // remember the timestamps of external libraries the first time they
// are looked up
// for (int i = 0, length = resolvedClasspath.length; i < length; i++) {
// IClasspathEntry entry = resolvedClasspath[i];
// if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
// IPath path = entry.getPath();
// Object target = JavaModel.getTarget(wRoot, path, true);
// if (target instanceof java.io.File) {
// Map externalTimeStamps =
// JavaModelManager.getJavaModelManager().deltaState.externalTimeStamps;
// if (externalTimeStamps.get(path) == null) {
// long timestamp = DeltaProcessor.getTimeStamp((java.io.File)target);
// externalTimeStamps.put(path, new Long(timestamp));
// }
// }
// }
// }
return true;
}
protected void closing(Object info) {
// // forget source attachment recommendations
// Object[] children = ((JavaElementInfo)info).children;
// for (int i = 0, length = children.length; i < length; i++) {
// Object child = children[i];
// if (child instanceof JarPackageFragmentRoot){
// ((JarPackageFragmentRoot)child).setSourceAttachmentProperty(null);
// }
// }
super.closing(info);
}
// protected void closing(Object info) throws JavaModelException {
//
// // forget source attachment recommendations
// IPackageFragmentRoot[] roots = this.getPackageFragmentRoots();
// // for (int i = 0; i < roots.length; i++) {
// // if (roots[i] instanceof JarPackageFragmentRoot){
// // ((JarPackageFragmentRoot) roots[i]).setSourceAttachmentProperty(null);
// // }
// // }
//
// super.closing(info);
// }
/**
* Internal computation of an expanded classpath. It will eliminate
* duplicates, and produce copies of exported classpath entries to avoid
* possible side-effects ever after.
*/
private void computeExpandedClasspath(JavaProject initialProject,
boolean ignoreUnresolvedVariable, boolean generateMarkerOnError,
HashSet rootIDs, ObjectVector accumulatedEntries,
Map preferredClasspaths, Map preferredOutputs)
throws JavaModelException {
String projectRootId = this.rootID();
if (rootIDs.contains(projectRootId)) {
return; // break cycles if any
}
rootIDs.add(projectRootId);
IClasspathEntry[] preferredClasspath = preferredClasspaths != null ? (IClasspathEntry[]) preferredClasspaths
.get(this)
: null;
IPath preferredOutput = preferredOutputs != null ? (IPath) preferredOutputs
.get(this)
: null;
IClasspathEntry[] immediateClasspath = preferredClasspath != null ? getResolvedClasspath(
preferredClasspath, preferredOutput, ignoreUnresolvedVariable,
generateMarkerOnError, null)
: getResolvedClasspath(ignoreUnresolvedVariable,
generateMarkerOnError, false/*
* don't
* returnResolutionInProgress
*/);
IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
boolean isInitialProject = this.equals(initialProject);
for (int i = 0, length = immediateClasspath.length; i < length; i++) {
ClasspathEntry entry = (ClasspathEntry) immediateClasspath[i];
if (isInitialProject || entry.isExported()) {
String rootID = entry.rootID();
if (rootIDs.contains(rootID)) {
continue;
}
accumulatedEntries.add(entry);
// recurse in project to get all its indirect exports (only
// consider exported entries from there on)
if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
IResource member = workspaceRoot
.findMember(entry.getPath());
if (member != null && member.getType() == IResource.PROJECT) { // double
// check
// if
// bound
// to
// project
// (23977)
IProject projRsc = (IProject) member;
if (JavaProject.hasJavaNature(projRsc)) {
JavaProject javaProject = (JavaProject) JavaCore
.create(projRsc);
javaProject
.computeExpandedClasspath(
initialProject,
ignoreUnresolvedVariable,
false /*
* no marker when recursing
* in prereq
*/,
rootIDs, accumulatedEntries,
preferredClasspaths,
preferredOutputs);
}
}
} else {
rootIDs.add(rootID);
}
}
}
}
/**
* Internal computation of an expanded classpath. It will eliminate
* duplicates, and produce copies of exported classpath entries to avoid
* possible side-effects ever after.
*/
// private void computeExpandedClasspath(
// JavaProject initialProject,
// boolean ignoreUnresolvedVariable,
// boolean generateMarkerOnError,
// HashSet visitedProjects,
// ObjectVector accumulatedEntries) throws JavaModelException {
//
// if (visitedProjects.contains(this)){
// return; // break cycles if any
// }
// visitedProjects.add(this);
//
// if (generateMarkerOnError && !this.equals(initialProject)){
// generateMarkerOnError = false;
// }
// IClasspathEntry[] immediateClasspath =
// getResolvedClasspath(ignoreUnresolvedVariable, generateMarkerOnError);
//
// IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
// for (int i = 0, length = immediateClasspath.length; i < length; i++){
// IClasspathEntry entry = immediateClasspath[i];
//
// boolean isInitialProject = this.equals(initialProject);
// if (isInitialProject || entry.isExported()){
//
// accumulatedEntries.add(entry);
//
// // recurse in project to get all its indirect exports (only consider
// exported entries from there on)
// if (entry.getEntryKind() == ClasspathEntry.CPE_PROJECT) {
// IResource member = workspaceRoot.findMember(entry.getPath());
// if (member != null && member.getType() == IResource.PROJECT){ // double
// check if bound to project (23977)
// IProject projRsc = (IProject) member;
// if (JavaProject.hasJavaNature(projRsc)) {
// JavaProject project = (JavaProject) JavaCore.create(projRsc);
// project.computeExpandedClasspath(
// initialProject,
// ignoreUnresolvedVariable,
// generateMarkerOnError,
// visitedProjects,
// accumulatedEntries);
// }
// }
// }
// }
// }
// }
/**
* Returns (local/all) the package fragment roots identified by the given
* project's classpath. Note: this follows project classpath references to
* find required project contributions, eliminating duplicates silently.
* Only works with resolved entries
*/
public IPackageFragmentRoot[] computePackageFragmentRoots(
IClasspathEntry[] resolvedClasspath, boolean retrieveExportedRoots)
throws JavaModelException {
ObjectVector accumulatedRoots = new ObjectVector();
computePackageFragmentRoots(resolvedClasspath, accumulatedRoots,
new HashSet(5), // rootIDs
true, // inside original project
true, // check existency
retrieveExportedRoots);
IPackageFragmentRoot[] rootArray = new IPackageFragmentRoot[accumulatedRoots
.size()];
accumulatedRoots.copyInto(rootArray);
return rootArray;
}
/**
* Computes the package fragment roots identified by the given entry. Only
* works with resolved entry
*/
public IPackageFragmentRoot[] computePackageFragmentRoots(
IClasspathEntry resolvedEntry) {
try {
return computePackageFragmentRoots(
new IClasspathEntry[] { resolvedEntry }, false // don't
// retrieve
// exported
// roots
);
} catch (JavaModelException e) {
return new IPackageFragmentRoot[] {};
}
}
/**
* Returns the package fragment roots identified by the given entry. In case
* it refers to a project, it will follow its classpath so as to find
* exported roots as well. Only works with resolved entry
*/
public void computePackageFragmentRoots(IClasspathEntry resolvedEntry,
ObjectVector accumulatedRoots, HashSet rootIDs,
boolean insideOriginalProject, boolean checkExistency,
boolean retrieveExportedRoots) throws JavaModelException {
String rootID = ((ClasspathEntry) resolvedEntry).rootID();
if (rootIDs.contains(rootID))
return;
IPath projectPath = getProject().getFullPath();
IPath entryPath = resolvedEntry.getPath();
IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
switch (resolvedEntry.getEntryKind()) {
// source folder
case IClasspathEntry.CPE_SOURCE:
if (projectPath.isPrefixOf(entryPath)) {
if (checkExistency) {
Object target = JavaModel.getTarget(workspaceRoot,
entryPath, checkExistency);
if (target == null)
return;
if (target instanceof IFolder || target instanceof IProject) {
accumulatedRoots
.add(getPackageFragmentRoot((IResource) target));
rootIDs.add(rootID);
}
} else {
IPackageFragmentRoot root = getFolderPackageFragmentRoot(entryPath);
if (root != null) {
accumulatedRoots.add(root);
rootIDs.add(rootID);
}
}
}
break;
// internal/external JAR or folder
case IClasspathEntry.CPE_LIBRARY:
if (!insideOriginalProject && !resolvedEntry.isExported())
return;
if (checkExistency) {
Object target = JavaModel.getTarget(workspaceRoot, entryPath,
checkExistency);
if (target == null)
return;
if (target instanceof IResource) {
// internal target
IResource resource = (IResource) target;
IPackageFragmentRoot root = getPackageFragmentRoot(resource);
if (root != null) {
accumulatedRoots.add(root);
rootIDs.add(rootID);
}
} else {
// external target - only JARs allowed
// if (((java.io.File)target).isFile() &&
// (ProjectPrefUtil.isArchiveFileName(entryPath.lastSegment())))
// {
// accumulatedRoots.add(
// new JarPackageFragmentRoot(entryPath, this));
// rootIDs.add(rootID);
// }
}
} else {
IPackageFragmentRoot root = getPackageFragmentRoot(entryPath);
if (root != null) {
accumulatedRoots.add(root);
rootIDs.add(rootID);
}
}
break;
// recurse into required project
case IClasspathEntry.CPE_PROJECT:
if (!retrieveExportedRoots)
return;
if (!insideOriginalProject && !resolvedEntry.isExported())
return;
IResource member = workspaceRoot.findMember(entryPath);
if (member != null && member.getType() == IResource.PROJECT) {// double
// check
// if
// bound
// to
// project
// (23977)
IProject requiredProjectRsc = (IProject) member;
if (JavaProject.hasJavaNature(requiredProjectRsc)) { // special
// builder
// binary
// output
rootIDs.add(rootID);
JavaProject requiredProject = (JavaProject) JavaCore
.create(requiredProjectRsc);
requiredProject.computePackageFragmentRoots(requiredProject
.getResolvedClasspath(true), accumulatedRoots,
rootIDs, false, checkExistency,
retrieveExportedRoots);
}
break;
}
}
}
/**
* Returns (local/all) the package fragment roots identified by the given
* project's classpath. Note: this follows project classpath references to
* find required project contributions, eliminating duplicates silently.
* Only works with resolved entries
*/
public void computePackageFragmentRoots(
IClasspathEntry[] resolvedClasspath, ObjectVector accumulatedRoots,
HashSet rootIDs, boolean insideOriginalProject,
boolean checkExistency, boolean retrieveExportedRoots)
throws JavaModelException {
if (insideOriginalProject) {
rootIDs.add(rootID());
}
for (int i = 0, length = resolvedClasspath.length; i < length; i++) {
computePackageFragmentRoots(resolvedClasspath[i], accumulatedRoots,
rootIDs, insideOriginalProject, checkExistency,
retrieveExportedRoots);
}
}
/**
* Compute the file name to use for a given shared property
*/
public String computeSharedPropertyFileName(QualifiedName qName) {
return '.' + qName.getLocalName();
}
/*
* Returns whether the given resource is accessible through the children or
* the non-Java resources of this project. Returns true if the resource is
* not in the project. Assumes that the resource is a folder or a file.
*/
public boolean contains(IResource resource) {
IClasspathEntry[] classpath;
IPath output;
try {
classpath = getResolvedClasspath(true);
output = getOutputLocation();
} catch (JavaModelException e) {
return false;
}
IPath fullPath = resource.getFullPath();
IPath innerMostOutput = output.isPrefixOf(fullPath) ? output : null;
IClasspathEntry innerMostEntry = null;
for (int j = 0, cpLength = classpath.length; j < cpLength; j++) {
IClasspathEntry entry = classpath[j];
IPath entryPath = entry.getPath();
if ((innerMostEntry == null || innerMostEntry.getPath().isPrefixOf(
entryPath))
&& entryPath.isPrefixOf(fullPath)) {
innerMostEntry = entry;
}
IPath entryOutput = classpath[j].getOutputLocation();
if (entryOutput != null && entryOutput.isPrefixOf(fullPath)) {
innerMostOutput = entryOutput;
}
}
if (innerMostEntry != null) {
// special case prj==src and nested output location
if (innerMostOutput != null && innerMostOutput.segmentCount() > 1 // output
// isn't
// project
&& innerMostEntry.getPath().segmentCount() == 1) { // 1
// segment
// must
// be
// project
// name
return false;
}
if (resource instanceof IFolder) {
// folders are always included in src/lib entries
return true;
}
switch (innerMostEntry.getEntryKind()) {
case IClasspathEntry.CPE_SOURCE:
// .class files are not visible in source folders
return true; // !net.sourceforge.phpdt.internal.compiler.util.ProjectPrefUtil.isClassFileName(fullPath.lastSegment());
case IClasspathEntry.CPE_LIBRARY:
// .java files are not visible in library folders
return !net.sourceforge.phpdt.internal.compiler.util.Util
.isJavaFileName(fullPath.lastSegment());
}
}
if (innerMostOutput != null) {
return false;
}
return true;
}
/**
* Record a new marker denoting a classpath problem
*/
IMarker createClasspathProblemMarker(IJavaModelStatus status) {
IMarker marker = null;
int severity;
String[] arguments = new String[0];
boolean isCycleProblem = false, isClasspathFileFormatProblem = false;
switch (status.getCode()) {
case IJavaModelStatusConstants.CLASSPATH_CYCLE:
isCycleProblem = true;
if (JavaCore.ERROR.equals(getOption(
JavaCore.CORE_CIRCULAR_CLASSPATH, true))) {
severity = IMarker.SEVERITY_ERROR;
} else {
severity = IMarker.SEVERITY_WARNING;
}
break;
case IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT:
isClasspathFileFormatProblem = true;
severity = IMarker.SEVERITY_ERROR;
break;
default:
IPath path = status.getPath();
if (path != null)
arguments = new String[] { path.toString() };
if (JavaCore.ERROR.equals(getOption(
JavaCore.CORE_INCOMPLETE_CLASSPATH, true))) {
severity = IMarker.SEVERITY_ERROR;
} else {
severity = IMarker.SEVERITY_WARNING;
}
break;
}
try {
marker = getProject().createMarker(
IJavaModelMarker.BUILDPATH_PROBLEM_MARKER);
marker.setAttributes(new String[] { IMarker.MESSAGE,
IMarker.SEVERITY, IMarker.LOCATION,
IJavaModelMarker.CYCLE_DETECTED,
IJavaModelMarker.CLASSPATH_FILE_FORMAT,
IJavaModelMarker.ID, IJavaModelMarker.ARGUMENTS, },
new Object[] { status.getMessage(),
new Integer(severity),
Util.bind("classpath.buildPath"),//$NON-NLS-1$
isCycleProblem ? "true" : "false",//$NON-NLS-1$ //$NON-NLS-2$
isClasspathFileFormatProblem ? "true" : "false",//$NON-NLS-1$ //$NON-NLS-2$
new Integer(status.getCode()),
Util.getProblemArgumentsForMarker(arguments), });
} catch (CoreException e) {
}
return marker;
}
/**
* Returns a new element info for this element.
*/
protected Object createElementInfo() {
return new JavaProjectElementInfo();
}
/*
* Returns a new search name environment for this project. This name
* environment first looks in the given working copies.
*/
// public ISearchableNameEnvironment
// newSearchableNameEnvironment(ICompilationUnit[] workingCopies) throws
// JavaModelException {
// return new SearchableEnvironment(this, workingCopies);
// }
/*
* Returns a new search name environment for this project. This name
* environment first looks in the working copies of the given owner.
*/
public ISearchableNameEnvironment newSearchableNameEnvironment(
WorkingCopyOwner owner) throws JavaModelException {
return new SearchableEnvironment(this, owner);
}
/**
* Reads and decode an XML classpath string
*/
protected IClasspathEntry[] decodeClasspath(String xmlClasspath,
boolean createMarker, boolean logProblems) {
ArrayList paths = new ArrayList();
IClasspathEntry defaultOutput = null;
try {
if (xmlClasspath == null)
return null;
StringReader reader = new StringReader(xmlClasspath);
Element cpElement;
try {
DocumentBuilder parser = DocumentBuilderFactory.newInstance()
.newDocumentBuilder();
cpElement = parser.parse(new InputSource(reader))
.getDocumentElement();
} catch (SAXException e) {
throw new IOException(Util.bind("file.badFormat")); //$NON-NLS-1$
} catch (ParserConfigurationException e) {
throw new IOException(Util.bind("file.badFormat")); //$NON-NLS-1$
} finally {
reader.close();
}
if (!cpElement.getNodeName().equalsIgnoreCase("classpath")) { //$NON-NLS-1$
throw new IOException(Util.bind("file.badFormat")); //$NON-NLS-1$
}
NodeList list = cpElement.getElementsByTagName("classpathentry"); //$NON-NLS-1$
int length = list.getLength();
for (int i = 0; i < length; ++i) {
Node node = list.item(i);
if (node.getNodeType() == Node.ELEMENT_NODE) {
IClasspathEntry entry = ClasspathEntry.elementDecode(
(Element) node, this);
if (entry != null) {
if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
defaultOutput = entry; // separate output
} else {
paths.add(entry);
}
}
}
}
} catch (IOException e) {
// bad format
if (createMarker && this.getProject().isAccessible()) {
this
.createClasspathProblemMarker(new JavaModelStatus(
IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
Util
.bind(
"classpath.xmlFormatError", this.getElementName(), e.getMessage()))); //$NON-NLS-1$
}
if (logProblems) {
Util.log(e, "Exception while retrieving " + this.getPath() //$NON-NLS-1$
+ "/.classpath, will mark classpath as invalid"); //$NON-NLS-1$
}
return INVALID_CLASSPATH;
} catch (Assert.AssertionFailedException e) {
// failed creating CP entries from file
if (createMarker && this.getProject().isAccessible()) {
this
.createClasspathProblemMarker(new JavaModelStatus(
IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
Util
.bind(
"classpath.illegalEntryInClasspathFile", this.getElementName(), e.getMessage()))); //$NON-NLS-1$
}
if (logProblems) {
Util.log(e, "Exception while retrieving " + this.getPath() //$NON-NLS-1$
+ "/.classpath, will mark classpath as invalid"); //$NON-NLS-1$
}
return INVALID_CLASSPATH;
}
int pathSize = paths.size();
if (pathSize > 0 || defaultOutput != null) {
IClasspathEntry[] entries = new IClasspathEntry[pathSize
+ (defaultOutput == null ? 0 : 1)];
paths.toArray(entries);
if (defaultOutput != null)
entries[pathSize] = defaultOutput; // ensure output is last
// item
return entries;
} else {
return null;
}
}
/**
* /** Removes the Java nature from the project.
*/
public void deconfigure() throws CoreException {
// deregister Java builder
removeFromBuildSpec(PHPeclipsePlugin.BUILDER_PARSER_ID);
}
/**
* Returns a default class path. This is the root of the project
*/
protected IClasspathEntry[] defaultClasspath() throws JavaModelException {
return new IClasspathEntry[] { JavaCore.newSourceEntry(getProject()
.getFullPath()) };
}
/**
* Returns a default output location. This is the project bin folder
*/
protected IPath defaultOutputLocation() throws JavaModelException {
return null; // getProject().getFullPath().append("bin");
// //$NON-NLS-1$
}
/**
* Returns the XML String encoding of the class path.
*/
protected String encodeClasspath(IClasspathEntry[] classpath,
IPath outputLocation, boolean indent) throws JavaModelException {
try {
ByteArrayOutputStream s = new ByteArrayOutputStream();
OutputStreamWriter writer = new OutputStreamWriter(s, "UTF8"); //$NON-NLS-1$
XMLWriter xmlWriter = new XMLWriter(writer);
xmlWriter.startTag("classpath", indent); //$NON-NLS-1$
for (int i = 0; i < classpath.length; ++i) {
((ClasspathEntry) classpath[i]).elementEncode(xmlWriter,
this.project.getFullPath(), indent, true);
}
if (outputLocation != null) {
outputLocation = outputLocation.removeFirstSegments(1);
outputLocation = outputLocation.makeRelative();
HashMap parameters = new HashMap();
parameters
.put(
"kind", ClasspathEntry.kindToString(ClasspathEntry.K_OUTPUT));//$NON-NLS-1$
parameters.put("path", String.valueOf(outputLocation));//$NON-NLS-1$
xmlWriter.printTag(
"classpathentry", parameters, indent, true, true);//$NON-NLS-1$
}
xmlWriter.endTag("classpath", indent);//$NON-NLS-1$
writer.flush();
writer.close();
return s.toString("UTF8");//$NON-NLS-1$
} catch (IOException e) {
throw new JavaModelException(e,
IJavaModelStatusConstants.IO_EXCEPTION);
}
}
/**
* Returns the XML String encoding of the class path.
*/
// protected String encodeClasspath(IClasspathEntry[] classpath, IPath
// outputLocation, boolean useLineSeparator) throws JavaModelException {
//
// Document document = new DocumentImpl();
// Element cpElement = document.createElement("classpath"); //$NON-NLS-1$
// document.appendChild(cpElement);
//
// for (int i = 0; i < classpath.length; ++i) {
// cpElement.appendChild(((ClasspathEntry)classpath[i]).elementEncode(document,
// getProject().getFullPath()));
// }
//
// if (outputLocation != null) {
// outputLocation = outputLocation.removeFirstSegments(1);
// outputLocation = outputLocation.makeRelative();
// Element oElement = document.createElement("classpathentry");
// //$NON-NLS-1$
// oElement.setAttribute("kind",
// ClasspathEntry.kindToString(ClasspathEntry.K_OUTPUT)); //$NON-NLS-1$
// oElement.setAttribute("path", outputLocation.toString()); //$NON-NLS-1$
// cpElement.appendChild(oElement);
// }
//
// // produce a String output
// try {
// ByteArrayOutputStream s = new ByteArrayOutputStream();
// OutputFormat format = new OutputFormat();
// if (useLineSeparator) {
// format.setIndenting(true);
// format.setLineSeparator(System.getProperty("line.separator"));
// //$NON-NLS-1$
// } else {
// format.setPreserveSpace(true);
// }
// Serializer serializer =
// SerializerFactory.getSerializerFactory(Method.XML).makeSerializer(
// new OutputStreamWriter(s, "UTF8"), //$NON-NLS-1$
// format);
// serializer.asDOMSerializer().serialize(document);
// return s.toString("UTF8"); //$NON-NLS-1$
// } catch (IOException e) {
// throw new JavaModelException(e, IJavaModelStatusConstants.IO_EXCEPTION);
// }
// }
/**
* Returns true if this handle represents the same Java project as the given
* handle. Two handles represent the same project if they are identical or
* if they represent a project with the same underlying resource and
* occurrence counts.
*
* @see JavaElement#equals
*/
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof JavaProject))
return false;
JavaProject other = (JavaProject) o;
return getProject().equals(other.getProject())
&& occurrenceCount == other.occurrenceCount;
}
public boolean exists() {
if (!hasJavaNature(project))
return false;
return super.exists();
}
/**
* @see IJavaProject
*/
public IJavaElement findElement(IPath path) throws JavaModelException {
if (path == null || path.isAbsolute()) {
throw new JavaModelException(new JavaModelStatus(
IJavaModelStatusConstants.INVALID_PATH, path));
}
// try {
String extension = path.getFileExtension();
if (extension == null) {
String packageName = path.toString().replace(IPath.SEPARATOR, '.');
// IPackageFragment[] pkgFragments =
// getNameLookup().findPackageFragments(packageName, false);
// if (pkgFragments == null) {
return null;
// } else {
// // try to return one that is a child of this project
// for (int i = 0, length = pkgFragments.length; i < length; i++) {
//
// IPackageFragment pkgFragment = pkgFragments[i];
// if (this.equals(pkgFragment.getParent().getParent())) {
// return pkgFragment;
// }
// }
// // default to the first one
// return pkgFragments[0];
// }
} else if (extension.equalsIgnoreCase("java") //$NON-NLS-1$
|| extension.equalsIgnoreCase("class")) { //$NON-NLS-1$
IPath packagePath = path.removeLastSegments(1);
String packageName = packagePath.toString().replace(
IPath.SEPARATOR, '.');
String typeName = path.lastSegment();
typeName = typeName.substring(0, typeName.length()
- extension.length() - 1);
String qualifiedName = null;
if (packageName.length() > 0) {
qualifiedName = packageName + "." + typeName; //$NON-NLS-1$
} else {
qualifiedName = typeName;
}
// IType type =
// getNameLookup().findType(
// qualifiedName,
// false,
// NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES);
// if (type != null) {
// return type.getParent();
// } else {
return null;
// }
} else {
// unsupported extension
return null;
}
// } catch (JavaModelException e) {
// if (e.getStatus().getCode()
// == IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST) {
// return null;
// } else {
// throw e;
// }
// }
}
/**
* @see IJavaProject
*/
// public IPackageFragment findPackageFragment(IPath path)
// throws JavaModelException {
//
// return findPackageFragment0(JavaProject.canonicalizedPath(path));
// }
//
// /**
// * non path canonicalizing version
// */
// public IPackageFragment findPackageFragment0(IPath path)
// throws JavaModelException {
//
// return getNameLookup().findPackageFragment(path);
// }
/**
* @see IJavaProject
*/
public IPackageFragmentRoot findPackageFragmentRoot(IPath path)
throws JavaModelException {
return findPackageFragmentRoot0(JavaProject.canonicalizedPath(path));
}
/**
* no path canonicalization
*/
public IPackageFragmentRoot findPackageFragmentRoot0(IPath path)
throws JavaModelException {
IPackageFragmentRoot[] allRoots = this.getAllPackageFragmentRoots();
if (!path.isAbsolute()) {
throw new IllegalArgumentException(Util.bind("path.mustBeAbsolute")); //$NON-NLS-1$
}
for (int i = 0; i < allRoots.length; i++) {
IPackageFragmentRoot classpathRoot = allRoots[i];
if (classpathRoot.getPath().equals(path)) {
return classpathRoot;
}
}
return null;
}
/**
* @see IJavaProject
*/
public IPackageFragmentRoot[] findPackageFragmentRoots(IClasspathEntry entry) {
try {
IClasspathEntry[] classpath = this.getRawClasspath();
for (int i = 0, length = classpath.length; i < length; i++) {
if (classpath[i].equals(entry)) { // entry may need to be
// resolved
return computePackageFragmentRoots(getResolvedClasspath(
new IClasspathEntry[] { entry }, null, true, false,
null/* no reverse map */), false); // don't
// retrieve
// exported
// roots
}
}
} catch (JavaModelException e) {
}
return new IPackageFragmentRoot[] {};
}
/**
* @see IJavaProject#findType(String)
*/
// public IType findType(String fullyQualifiedName) throws
// JavaModelException {
// IType type =
// this.getNameLookup().findType(
// fullyQualifiedName,
// false,
// NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES);
// if (type == null) {
// // try to find enclosing type
// int lastDot = fullyQualifiedName.lastIndexOf('.');
// if (lastDot == -1) return null;
// type = this.findType(fullyQualifiedName.substring(0, lastDot));
// if (type != null) {
// type = type.getType(fullyQualifiedName.substring(lastDot+1));
// if (!type.exists()) {
// return null;
// }
// }
// }
// return type;
// }
/**
* @see IJavaProject#findType(String, String)
*/
// public IType findType(String packageName, String typeQualifiedName)
// throws JavaModelException {
// return
// this.getNameLookup().findType(
// typeQualifiedName,
// packageName,
// false,
// NameLookup.ACCEPT_CLASSES | NameLookup.ACCEPT_INTERFACES);
// }
//
/**
* Remove all markers denoting classpath problems
*/
protected void flushClasspathProblemMarkers(boolean flushCycleMarkers,
boolean flushClasspathFormatMarkers) {
try {
IProject project = getProject();
if (project.exists()) {
IMarker[] markers = project.findMarkers(
IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, false,
IResource.DEPTH_ZERO);
for (int i = 0, length = markers.length; i < length; i++) {
IMarker marker = markers[i];
if (flushCycleMarkers && flushClasspathFormatMarkers) {
marker.delete();
} else {
String cycleAttr = (String) marker
.getAttribute(IJavaModelMarker.CYCLE_DETECTED);
String classpathFileFormatAttr = (String) marker
.getAttribute(IJavaModelMarker.CLASSPATH_FILE_FORMAT);
if ((flushCycleMarkers == (cycleAttr != null && cycleAttr
.equals("true"))) //$NON-NLS-1$
&& (flushClasspathFormatMarkers == (classpathFileFormatAttr != null && classpathFileFormatAttr
.equals("true")))) { //$NON-NLS-1$
marker.delete();
}
}
}
}
} catch (CoreException e) {
}
}
// /**
// * @see Openable
// */
// protected boolean generateInfos(
// OpenableElementInfo info,
// IProgressMonitor pm,
// Map newElements,
// IResource underlyingResource) throws JavaModelException {
//
// boolean validInfo = false;
// try {
// if (getProject().isOpen()) {
// // put the info now, because computing the roots requires it
// JavaModelManager.getJavaModelManager().putInfo(this, info);
//
// // compute the pkg fragment roots
// updatePackageFragmentRoots();
//
// // remember the timestamps of external libraries the first time they are
// looked up
// IClasspathEntry[] resolvedClasspath = getResolvedClasspath(true/*ignore
// unresolved variable*/);
// for (int i = 0, length = resolvedClasspath.length; i < length; i++) {
// IClasspathEntry entry = resolvedClasspath[i];
// if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
// IPath path = entry.getPath();
// Object target =
// JavaModel.getTarget(ResourcesPlugin.getWorkspace().getRoot(), path,
// true);
// if (target instanceof java.io.File) {
// Map externalTimeStamps =
// JavaModelManager.getJavaModelManager().deltaProcessor.externalTimeStamps;
// if (externalTimeStamps.get(path) == null) {
// long timestamp = DeltaProcessor.getTimeStamp((java.io.File)target);
// externalTimeStamps.put(path, new Long(timestamp));
// }
// }
// }
// }
//
// // only valid if reaches here
// validInfo = true;
// }
// } finally {
// if (!validInfo)
// JavaModelManager.getJavaModelManager().removeInfo(this);
// }
// return validInfo;
// }
/**
* @see IJavaProject
*/
public IPackageFragmentRoot[] getAllPackageFragmentRoots()
throws JavaModelException {
return computePackageFragmentRoots(getResolvedClasspath(true), true);
}
/**
* Returns the classpath entry that refers to the given path or
* <code>null</code> if there is no reference to the path.
*/
public IClasspathEntry getClasspathEntryFor(IPath path)
throws JavaModelException {
IClasspathEntry[] entries = getExpandedClasspath(true);
for (int i = 0; i < entries.length; i++) {
if (entries[i].getPath().equals(path)) {
return entries[i];
}
}
return null;
}
/*
* Returns the cycle marker associated with this project or null if none.
*/
public IMarker getCycleMarker() {
try {
IProject project = getProject();
if (project.exists()) {
IMarker[] markers = project.findMarkers(
IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, false,
IResource.DEPTH_ZERO);
for (int i = 0, length = markers.length; i < length; i++) {
IMarker marker = markers[i];
String cycleAttr = (String) marker
.getAttribute(IJavaModelMarker.CYCLE_DETECTED);
if (cycleAttr != null && cycleAttr.equals("true")) { //$NON-NLS-1$
return marker;
}
}
}
} catch (CoreException e) {
}
return null;
}
/**
* @see IJavaElement
*/
public int getElementType() {
return JAVA_PROJECT;
}
/**
* This is a helper method returning the expanded classpath for the project,
* as a list of classpath entries, where all classpath variable entries have
* been resolved and substituted with their final target entries. All
* project exports have been appended to project entries.
*
* @param ignoreUnresolvedVariable
* boolean
* @return IClasspathEntry[]
* @throws JavaModelException
*/
public IClasspathEntry[] getExpandedClasspath(
boolean ignoreUnresolvedVariable) throws JavaModelException {
return getExpandedClasspath(ignoreUnresolvedVariable,
false/* don't create markers */, null, null);
}
/*
* @see JavaElement
*/
public IJavaElement getHandleFromMemento(String token,
MementoTokenizer memento, WorkingCopyOwner owner) {
switch (token.charAt(0)) {
case JEM_COUNT:
return getHandleUpdatingCountFromMemento(memento, owner);
case JEM_PACKAGEFRAGMENTROOT:
String rootPath = IPackageFragmentRoot.DEFAULT_PACKAGEROOT_PATH;
token = null;
while (memento.hasMoreTokens()) {
token = memento.nextToken();
char firstChar = token.charAt(0);
if (firstChar != JEM_PACKAGEFRAGMENT && firstChar != JEM_COUNT) {
rootPath += token;
} else {
break;
}
}
JavaElement root = (JavaElement) getPackageFragmentRoot(new Path(
rootPath));
if (token != null && token.charAt(0) == JEM_PACKAGEFRAGMENT) {
return root.getHandleFromMemento(token, memento, owner);
} else {
return root.getHandleFromMemento(memento, owner);
}
}
return null;
}
/**
* Returns the <code>char</code> that marks the start of this handles
* contribution to a memento.
*/
protected char getHandleMementoDelimiter() {
return JEM_JAVAPROJECT;
}
/**
* Internal variant which can create marker on project for invalid entries,
* it will also perform classpath expansion in presence of project
* prerequisites exporting their entries.
*
* @param ignoreUnresolvedVariable
* boolean
* @param generateMarkerOnError
* boolean
* @param preferredClasspaths
* Map
* @param preferredOutputs
* Map
* @return IClasspathEntry[]
* @throws JavaModelException
*/
public IClasspathEntry[] getExpandedClasspath(
boolean ignoreUnresolvedVariable, boolean generateMarkerOnError,
Map preferredClasspaths, Map preferredOutputs)
throws JavaModelException {
ObjectVector accumulatedEntries = new ObjectVector();
computeExpandedClasspath(this, ignoreUnresolvedVariable,
generateMarkerOnError, new HashSet(5), accumulatedEntries,
preferredClasspaths, preferredOutputs);
IClasspathEntry[] expandedPath = new IClasspathEntry[accumulatedEntries
.size()];
accumulatedEntries.copyInto(expandedPath);
return expandedPath;
}
// /**
// * Internal variant which can create marker on project for invalid
// entries,
// * it will also perform classpath expansion in presence of project
// prerequisites
// * exporting their entries.
// */
// public IClasspathEntry[] getExpandedClasspath(
// boolean ignoreUnresolvedVariable,
// boolean generateMarkerOnError) throws JavaModelException {
//
// ObjectVector accumulatedEntries = new ObjectVector();
// computeExpandedClasspath(this, ignoreUnresolvedVariable,
// generateMarkerOnError, new HashSet(5), accumulatedEntries);
//
// IClasspathEntry[] expandedPath = new
// IClasspathEntry[accumulatedEntries.size()];
// accumulatedEntries.copyInto(expandedPath);
//
// return expandedPath;
// }
/**
* Find the specific Java command amongst the build spec of a given
* description
*/
private ICommand getJavaCommand(IProjectDescription description)
throws CoreException {
ICommand[] commands = description.getBuildSpec();
for (int i = 0; i < commands.length; ++i) {
if (commands[i].getBuilderName().equals(
PHPeclipsePlugin.BUILDER_PARSER_ID)) {
return commands[i];
}
}
return null;
}
/**
* Convenience method that returns the specific type of info for a Java
* project.
*/
protected JavaProjectElementInfo getJavaProjectElementInfo()
throws JavaModelException {
return (JavaProjectElementInfo) getElementInfo();
}
/**
* @see IJavaProject
*/
public NameLookup getNameLookup() throws JavaModelException {
JavaProjectElementInfo info = getJavaProjectElementInfo();
// lock on the project info to avoid race condition
synchronized (info) {
NameLookup nameLookup;
if ((nameLookup = info.getNameLookup()) == null) {
info.setNameLookup(nameLookup = new NameLookup(this));
}
return nameLookup;
}
}
/*
* Returns a new name lookup. This name lookup first looks in the given
* working copies.
*/
public NameLookup newNameLookup(ICompilationUnit[] workingCopies)
throws JavaModelException {
JavaProjectElementInfo info = getJavaProjectElementInfo();
// lock on the project info to avoid race condition while computing the
// pkg fragment roots and package fragment caches
// synchronized(info){
// return new NameLookup(info.getAllPackageFragmentRoots(this),
// info.getAllPackageFragments(this), workingCopies);
// }
return null;
}
/*
* Returns a new name lookup. This name lookup first looks in the working
* copies of the given owner.
*/
public NameLookup newNameLookup(WorkingCopyOwner owner)
throws JavaModelException {
JavaModelManager manager = JavaModelManager.getJavaModelManager();
ICompilationUnit[] workingCopies = owner == null ? null : manager
.getWorkingCopies(owner, true/* add primary WCs */);
return newNameLookup(workingCopies);
}
//
// /**
// * Returns an array of non-java resources contained in the receiver.
// */
// public Object[] getNonJavaResources() throws JavaModelException {
//
// return ((JavaProjectElementInfo)
// getElementInfo()).getNonJavaResources(this);
// }
/**
* @see net.sourceforge.phpdt.core.IJavaProject#getOption(String, boolean)
*/
public String getOption(String optionName, boolean inheritJavaCoreOptions) {
if (JavaModelManager.OptionNames.contains(optionName)) {
Preferences preferences = getPreferences();
if (preferences == null || preferences.isDefault(optionName)) {
return inheritJavaCoreOptions ? JavaCore.getOption(optionName)
: null;
}
return preferences.getString(optionName).trim();
}
return null;
}
/**
* @see net.sourceforge.phpdt.core.IJavaProject#getOptions(boolean)
*/
public Map getOptions(boolean inheritJavaCoreOptions) {
// initialize to the defaults from JavaCore options pool
Map options = inheritJavaCoreOptions ? JavaCore.getOptions()
: new Hashtable(5);
Preferences preferences = getPreferences();
if (preferences == null)
return options; // cannot do better (non-Java project)
HashSet optionNames = JavaModelManager.OptionNames;
// get preferences set to their default
if (inheritJavaCoreOptions) {
String[] defaultPropertyNames = preferences.defaultPropertyNames();
for (int i = 0; i < defaultPropertyNames.length; i++) {
String propertyName = defaultPropertyNames[i];
if (optionNames.contains(propertyName)) {
options.put(propertyName, preferences.getDefaultString(
propertyName).trim());
}
}
}
// get custom preferences not set to their default
String[] propertyNames = preferences.propertyNames();
for (int i = 0; i < propertyNames.length; i++) {
String propertyName = propertyNames[i];
if (optionNames.contains(propertyName)) {
options.put(propertyName, preferences.getString(propertyName)
.trim());
}
}
return options;
}
/**
* @see IJavaProject
*/
// public IPath getOutputLocation() throws JavaModelException {
//
// JavaModelManager.PerProjectInfo perProjectInfo =
// JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project);
// IPath outputLocation = perProjectInfo.outputLocation;
// if (outputLocation != null) return outputLocation;
//
// // force to read classpath - will position output location as well
// this.getRawClasspath();
// outputLocation = perProjectInfo.outputLocation;
// if (outputLocation == null) {
// return defaultOutputLocation();
// }
// return outputLocation;
// }
/**
* @see IJavaProject
*/
public IPath getOutputLocation() throws JavaModelException {
// Do not create marker but log problems while getting output location
return this.getOutputLocation(false, true);
}
/**
* @param createMarkers
* boolean
* @param logProblems
* boolean
* @return IPath
* @throws JavaModelException
*/
public IPath getOutputLocation(boolean createMarkers, boolean logProblems)
throws JavaModelException {
JavaModelManager.PerProjectInfo perProjectInfo = getPerProjectInfo();
IPath outputLocation = perProjectInfo.outputLocation;
if (outputLocation != null)
return outputLocation;
// force to read classpath - will position output location as well
this.getRawClasspath(createMarkers, logProblems);
outputLocation = perProjectInfo.outputLocation;
if (outputLocation == null) {
return defaultOutputLocation();
}
return outputLocation;
}
/**
* @return A handle to the package fragment root identified by the given
* path. This method is handle-only and the element may or may not
* exist. Returns <code>null</code> if unable to generate a handle
* from the path (for example, an absolute path that has less than 1
* segment. The path may be relative or absolute.
*/
public IPackageFragmentRoot getPackageFragmentRoot(IPath path) {
if (!path.isAbsolute()) {
path = getPath().append(path);
}
int segmentCount = path.segmentCount();
switch (segmentCount) {
case 0:
return null;
case 1:
// default root
return getPackageFragmentRoot(getProject());
default:
// a path ending with .jar/.zip is still ambiguous and could still
// resolve to a source/lib folder
// thus will try to guess based on existing resource
// if (ProjectPrefUtil.isArchiveFileName(path.lastSegment())) {
// IResource resource =
// getProject().getWorkspace().getRoot().findMember(path);
// if (resource != null && resource.getType() == IResource.FOLDER){
// return getPackageFragmentRoot(resource);
// }
// return getPackageFragmentRoot0(path);
// } else {
return getPackageFragmentRoot(getProject().getWorkspace().getRoot()
.getFolder(path));
// }
}
}
/**
* The path is known to match a source/library folder entry.
*/
public IPackageFragmentRoot getFolderPackageFragmentRoot(IPath path) {
if (path.segmentCount() == 1) { // default project root
return getPackageFragmentRoot(getProject());
}
return getPackageFragmentRoot(getProject().getWorkspace().getRoot()
.getFolder(path));
}
/**
* @see IJavaProject
*/
public IPackageFragmentRoot getPackageFragmentRoot(IResource resource) {
switch (resource.getType()) {
case IResource.FILE:
// if (ProjectPrefUtil.isArchiveFileName(resource.getName())) {
// return new JarPackageFragmentRoot(resource, this);
// } else {
return null;
// }
case IResource.FOLDER:
return new PackageFragmentRoot(resource, this, resource.getName());
case IResource.PROJECT:
return new PackageFragmentRoot(resource, this, ""); //$NON-NLS-1$
default:
return null;
}
}
/**
* @see IJavaProject
*/
// public IPackageFragmentRoot getPackageFragmentRoot(String jarPath) {
//
// return getPackageFragmentRoot0(JavaProject.canonicalizedPath(new
// Path(jarPath)));
// }
//
// /**
// * no path canonicalization
// */
// public IPackageFragmentRoot getPackageFragmentRoot0(IPath jarPath) {
//
// return new JarPackageFragmentRoot(jarPath, this);
// }
/**
* @see IJavaProject
*/
public IPackageFragmentRoot[] getPackageFragmentRoots()
throws JavaModelException {
Object[] children;
int length;
IPackageFragmentRoot[] roots;
System.arraycopy(children = getChildren(), 0,
roots = new IPackageFragmentRoot[length = children.length], 0,
length);
return roots;
}
/**
* @see IJavaProject
* @deprecated
*/
public IPackageFragmentRoot[] getPackageFragmentRoots(IClasspathEntry entry) {
return findPackageFragmentRoots(entry);
}
/**
* Returns the package fragment root prefixed by the given path, or an empty
* collection if there are no such elements in the model.
*/
protected IPackageFragmentRoot[] getPackageFragmentRoots(IPath path)
throws JavaModelException {
IPackageFragmentRoot[] roots = getAllPackageFragmentRoots();
ArrayList matches = new ArrayList();
for (int i = 0; i < roots.length; ++i) {
if (path.isPrefixOf(roots[i].getPath())) {
matches.add(roots[i]);
}
}
IPackageFragmentRoot[] copy = new IPackageFragmentRoot[matches.size()];
matches.toArray(copy);
return copy;
}
/**
* @see IJavaProject
*/
public IPackageFragment[] getPackageFragments() throws JavaModelException {
IPackageFragmentRoot[] roots = getPackageFragmentRoots();
return getPackageFragmentsInRoots(roots);
}
/**
* Returns all the package fragments found in the specified package fragment
* roots.
*/
public IPackageFragment[] getPackageFragmentsInRoots(
IPackageFragmentRoot[] roots) {
ArrayList frags = new ArrayList();
for (int i = 0; i < roots.length; i++) {
IPackageFragmentRoot root = roots[i];
try {
IJavaElement[] rootFragments = root.getChildren();
for (int j = 0; j < rootFragments.length; j++) {
frags.add(rootFragments[j]);
}
} catch (JavaModelException e) {
// do nothing
}
}
IPackageFragment[] fragments = new IPackageFragment[frags.size()];
frags.toArray(fragments);
return fragments;
}
/*
* @see IJavaElement
*/
public IPath getPath() {
return this.getProject().getFullPath();
}
public JavaModelManager.PerProjectInfo getPerProjectInfo()
throws JavaModelException {
return JavaModelManager.getJavaModelManager()
.getPerProjectInfoCheckExistence(this.project);
}
/**
* @see IJavaProject
*/
public IProject getProject() {
return project;
}
/**
* Sets the underlying kernel project of this Java project, and fills in its
* parent and name. Called by IProject.getNature().
*
* @see IProjectNature#setProject(IProject)
*/
public void setProject(IProject project) {
this.project = project;
this.parent = JavaModelManager.getJavaModelManager().getJavaModel();
this.name = project.getName();
}
protected IProject getProject(String name) {
return PHPeclipsePlugin.getWorkspace().getRoot().getProject(name);
}
public List getReferencedProjects() {
List referencedProjects = new ArrayList();
Iterator iterator = getLoadPathEntries().iterator();
while (iterator.hasNext()) {
LoadPathEntry pathEntry = (LoadPathEntry) iterator.next();
if (pathEntry.getType() == LoadPathEntry.TYPE_PROJECT)
referencedProjects.add(pathEntry.getProject());
}
return referencedProjects;
}
/**
* Returns the project custom preference pool. Project preferences may
* include custom encoding.
*/
public Preferences getPreferences() {
IProject project = getProject();
if (!JavaProject.hasJavaNature(project))
return null;
JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager
.getJavaModelManager().getPerProjectInfo(project, true);
Preferences preferences = perProjectInfo.preferences;
if (preferences != null)
return preferences;
preferences = loadPreferences();
if (preferences == null)
preferences = new Preferences();
perProjectInfo.preferences = preferences;
return preferences;
}
/**
* @see IJavaProject
*/
// public IClasspathEntry[] getRawClasspath() throws JavaModelException {
//
// JavaModelManager.PerProjectInfo perProjectInfo =
// JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project);
// IClasspathEntry[] classpath = perProjectInfo.classpath;
// if (classpath != null) return classpath;
// classpath = this.readClasspathFile(false/*don't create markers*/,
// true/*log problems*/);
//
// // extract out the output location
// IPath outputLocation = null;
// if (classpath != null && classpath.length > 0) {
// IClasspathEntry entry = classpath[classpath.length - 1];
// if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
// outputLocation = entry.getPath();
// IClasspathEntry[] copy = new IClasspathEntry[classpath.length - 1];
// System.arraycopy(classpath, 0, copy, 0, copy.length);
// classpath = copy;
// }
// }
// if (classpath == null) {
// return defaultClasspath();
// }
// /* Disable validate: classpath can contain CP variables and container
// that need to be resolved
// if (classpath != INVALID_CLASSPATH
// && !JavaConventions.validateClasspath(this, classpath,
// outputLocation).isOK()) {
// classpath = INVALID_CLASSPATH;
// }
// */
// perProjectInfo.classpath = classpath;
// perProjectInfo.outputLocation = outputLocation;
// return classpath;
// }
/**
* @see IJavaProject
*/
public IClasspathEntry[] getRawClasspath() throws JavaModelException {
// Do not create marker but log problems while getting raw classpath
return getRawClasspath(false, true);
}
/*
* Internal variant allowing to parameterize problem creation/logging
*/
public IClasspathEntry[] getRawClasspath(boolean createMarkers,
boolean logProblems) throws JavaModelException {
JavaModelManager.PerProjectInfo perProjectInfo = null;
IClasspathEntry[] classpath;
if (createMarkers) {
this.flushClasspathProblemMarkers(false/* cycle */, true/* format */);
classpath = this.readClasspathFile(createMarkers, logProblems);
} else {
perProjectInfo = getPerProjectInfo();
classpath = perProjectInfo.rawClasspath;
if (classpath != null)
return classpath;
classpath = this.readClasspathFile(createMarkers, logProblems);
}
// extract out the output location
IPath outputLocation = null;
if (classpath != null && classpath.length > 0) {
IClasspathEntry entry = classpath[classpath.length - 1];
if (entry.getContentKind() == ClasspathEntry.K_OUTPUT) {
outputLocation = entry.getPath();
IClasspathEntry[] copy = new IClasspathEntry[classpath.length - 1];
System.arraycopy(classpath, 0, copy, 0, copy.length);
classpath = copy;
}
}
if (classpath == null) {
return defaultClasspath();
}
/*
* Disable validate: classpath can contain CP variables and container
* that need to be resolved if (classpath != INVALID_CLASSPATH &&
* !JavaConventions.validateClasspath(this, classpath,
* outputLocation).isOK()) { classpath = INVALID_CLASSPATH; }
*/
if (!createMarkers) {
perProjectInfo.rawClasspath = classpath;
perProjectInfo.outputLocation = outputLocation;
}
return classpath;
}
/**
* @see IJavaProject#getRequiredProjectNames
*/
public String[] getRequiredProjectNames() throws JavaModelException {
return this.projectPrerequisites(getResolvedClasspath(true));
}
/**
* @see IJavaProject
*/
public IClasspathEntry[] getResolvedClasspath(boolean ignoreUnresolvedEntry)
throws JavaModelException {
return this.getResolvedClasspath(ignoreUnresolvedEntry, false); // generateMarkerOnError
}
/**
* Internal variant which can create marker on project for invalid entries
* and caches the resolved classpath on perProjectInfo
*/
public IClasspathEntry[] getResolvedClasspath(
boolean ignoreUnresolvedEntry, boolean generateMarkerOnError)
throws JavaModelException {
return getResolvedClasspath(ignoreUnresolvedEntry,
generateMarkerOnError, true // returnResolutionInProgress
);
// JavaModelManager manager = JavaModelManager.getJavaModelManager();
// JavaModelManager.PerProjectInfo perProjectInfo =
// manager.getPerProjectInfoCheckExistence(project);
//
// // reuse cache if not needing to refresh markers or checking bound
// variables
// if (ignoreUnresolvedEntry && !generateMarkerOnError && perProjectInfo
// != null){
// // resolved path is cached on its info
// IClasspathEntry[] infoPath = perProjectInfo.lastResolvedClasspath;
// if (infoPath != null) return infoPath;
// }
// Map reverseMap = perProjectInfo == null ? null : new HashMap(5);
// IClasspathEntry[] resolvedPath = getResolvedClasspath(
// getRawClasspath(),
// generateMarkerOnError ? getOutputLocation() : null,
// ignoreUnresolvedEntry,
// generateMarkerOnError,
// reverseMap);
//
// if (perProjectInfo != null){
// if (perProjectInfo.classpath == null // .classpath file could not be
// read
// && generateMarkerOnError
// && JavaProject.hasJavaNature(project)) {
// this.createClasspathProblemMarker(new JavaModelStatus(
// IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
// Util.bind("classpath.cannotReadClasspathFile",
// this.getElementName()))); //$NON-NLS-1$
// }
//
// perProjectInfo.lastResolvedClasspath = resolvedPath;
// perProjectInfo.resolvedPathToRawEntries = reverseMap;
// }
// return resolvedPath;
}
/*
* Internal variant which can create marker on project for invalid entries
* and caches the resolved classpath on perProjectInfo. If requested, return
* a special classpath (RESOLUTION_IN_PROGRESS) if the classpath is being
* resolved.
*/
public IClasspathEntry[] getResolvedClasspath(
boolean ignoreUnresolvedEntry, boolean generateMarkerOnError,
boolean returnResolutionInProgress) throws JavaModelException {
JavaModelManager manager = JavaModelManager.getJavaModelManager();
JavaModelManager.PerProjectInfo perProjectInfo = null;
if (ignoreUnresolvedEntry && !generateMarkerOnError) {
perProjectInfo = getPerProjectInfo();
if (perProjectInfo != null) {
// resolved path is cached on its info
IClasspathEntry[] infoPath = perProjectInfo.resolvedClasspath;
if (infoPath != null) {
return infoPath;
} else if (returnResolutionInProgress
&& manager.isClasspathBeingResolved(this)) {
if (JavaModelManager.CP_RESOLVE_VERBOSE) {
Util
.verbose("CPResolution: reentering raw classpath resolution, will use empty classpath instead" + //$NON-NLS-1$
" project: " + getElementName() + '\n' + //$NON-NLS-1$
" invocation stack trace:"); //$NON-NLS-1$
new Exception("<Fake exception>").printStackTrace(System.out); //$NON-NLS-1$
}
return RESOLUTION_IN_PROGRESS;
}
}
}
Map reverseMap = perProjectInfo == null ? null : new HashMap(5);
IClasspathEntry[] resolvedPath = null;
boolean nullOldResolvedCP = perProjectInfo != null
&& perProjectInfo.resolvedClasspath == null;
try {
// protect against misbehaving clients (see
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=61040)
if (nullOldResolvedCP)
manager.setClasspathBeingResolved(this, true);
resolvedPath = getResolvedClasspath(getRawClasspath(
generateMarkerOnError, !generateMarkerOnError),
generateMarkerOnError ? getOutputLocation() : null,
ignoreUnresolvedEntry, generateMarkerOnError, reverseMap);
} finally {
if (nullOldResolvedCP)
perProjectInfo.resolvedClasspath = null;
}
if (perProjectInfo != null) {
if (perProjectInfo.rawClasspath == null // .classpath file could not
// be read
&& generateMarkerOnError
&& JavaProject.hasJavaNature(this.project)) {
// flush .classpath format markers (bug 39877), but only when
// file cannot be read (bug 42366)
this.flushClasspathProblemMarkers(false, true);
this
.createClasspathProblemMarker(new JavaModelStatus(
IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
Util
.bind(
"classpath.cannotReadClasspathFile", this.getElementName()))); //$NON-NLS-1$
}
perProjectInfo.resolvedClasspath = resolvedPath;
perProjectInfo.resolvedPathToRawEntries = reverseMap;
manager.setClasspathBeingResolved(this, false);
}
return resolvedPath;
}
/**
* Internal variant which can process any arbitrary classpath
*/
public IClasspathEntry[] getResolvedClasspath(
IClasspathEntry[] classpathEntries, IPath projectOutputLocation, // only
// set
// if
// needing
// full
// classpath
// validation
// (and
// markers)
boolean ignoreUnresolvedEntry, // if unresolved entries are met,
// should it trigger initializations
boolean generateMarkerOnError, Map reverseMap) // can be null if
// not interested in
// reverse mapping
throws JavaModelException {
IJavaModelStatus status;
if (generateMarkerOnError) {
flushClasspathProblemMarkers(false, false);
}
int length = classpathEntries.length;
ArrayList resolvedEntries = new ArrayList();
for (int i = 0; i < length; i++) {
IClasspathEntry rawEntry = classpathEntries[i];
IPath resolvedPath;
status = null;
/* validation if needed */
// if (generateMarkerOnError || !ignoreUnresolvedEntry) {
// status = JavaConventions.validateClasspathEntry(this, rawEntry,
// false);
// if (generateMarkerOnError && !status.isOK())
// createClasspathProblemMarker(status);
// }
switch (rawEntry.getEntryKind()) {
case IClasspathEntry.CPE_VARIABLE:
IClasspathEntry resolvedEntry = JavaCore
.getResolvedClasspathEntry(rawEntry);
if (resolvedEntry == null) {
if (!ignoreUnresolvedEntry)
throw new JavaModelException(status);
} else {
if (reverseMap != null
&& reverseMap.get(resolvedPath = resolvedEntry
.getPath()) == null)
reverseMap.put(resolvedPath, rawEntry);
resolvedEntries.add(resolvedEntry);
}
break;
// case IClasspathEntry.CPE_CONTAINER :
//
// IClasspathContainer container =
// PHPCore.getClasspathContainer(rawEntry.getPath(), this);
// if (container == null){
// if (!ignoreUnresolvedEntry) throw new JavaModelException(status);
// break;
// }
//
// IClasspathEntry[] containerEntries =
// container.getClasspathEntries();
// if (containerEntries == null) break;
//
// // container was bound
// for (int j = 0, containerLength = containerEntries.length; j <
// containerLength; j++){
// IClasspathEntry cEntry = containerEntries[j];
//
// if (generateMarkerOnError) {
// IJavaModelStatus containerStatus =
// JavaConventions.validateClasspathEntry(this, cEntry, false);
// if (!containerStatus.isOK())
// createClasspathProblemMarker(containerStatus);
// }
// // if container is exported, then its nested entries must in turn
// be exported (21749)
// if (rawEntry.isExported()){
// cEntry = new ClasspathEntry(cEntry.getContentKind(),
// cEntry.getEntryKind(), cEntry.getPath(),
// cEntry.getExclusionPatterns(), cEntry.getSourceAttachmentPath(),
// cEntry.getSourceAttachmentRootPath(), cEntry.getOutputLocation(),
// true); // duplicate container entry for tagging it as exported
// }
// if (reverseMap != null && reverseMap.get(resolvedPath =
// cEntry.getPath()) == null) reverseMap.put(resolvedPath,
// rawEntry);
// resolvedEntries.add(cEntry);
// }
// break;
default:
if (reverseMap != null
&& reverseMap.get(resolvedPath = rawEntry.getPath()) == null)
reverseMap.put(resolvedPath, rawEntry);
resolvedEntries.add(rawEntry);
}
}
IClasspathEntry[] resolvedPath = new IClasspathEntry[resolvedEntries
.size()];
resolvedEntries.toArray(resolvedPath);
// if (generateMarkerOnError && projectOutputLocation != null) {
// status = JavaConventions.validateClasspath(this, resolvedPath,
// projectOutputLocation);
// if (!status.isOK()) createClasspathProblemMarker(status);
// }
return resolvedPath;
}
/*
* @see IJavaElement
*/
public IResource getResource() {
return this.getProject();
}
/**
* @see IJavaProject
*/
public ISearchableNameEnvironment getSearchableNameEnvironment()
throws JavaModelException {
// JavaProjectElementInfo info = getJavaProjectElementInfo();
// if (info.getSearchableEnvironment() == null) {
// info.setSearchableEnvironment(new SearchableEnvironment(this));
// }
// return info.getSearchableEnvironment();
return null;
}
/**
* Retrieve a shared property on a project. If the property is not defined,
* answers null. Note that it is orthogonal to IResource persistent
* properties, and client code has to decide which form of storage to use
* appropriately. Shared properties produce real resource files which can be
* shared through a VCM onto a server. Persistent properties are not
* shareable.
*
* @see JavaProject#setSharedProperty(String, String)
*/
public String getSharedProperty(String key) throws CoreException {
String property = null;
IFile rscFile = getProject().getFile(key);
if (rscFile.exists()) {
property = new String(Util.getResourceContentsAsByteArray(rscFile));
}
return property;
}
/**
* @see JavaElement
*/
// public SourceMapper getSourceMapper() {
//
// return null;
// }
/**
* @see IJavaElement
*/
public IResource getUnderlyingResource() throws JavaModelException {
if (!exists())
throw newNotPresentException();
return getProject();
}
/**
* @see IJavaProject
*/
public boolean hasBuildState() {
return JavaModelManager.getJavaModelManager().getLastBuiltState(
this.getProject(), null) != null;
}
/**
* @see IJavaProject
*/
public boolean hasClasspathCycle(IClasspathEntry[] preferredClasspath) {
HashSet cycleParticipants = new HashSet();
updateCycleParticipants(preferredClasspath, new ArrayList(2),
cycleParticipants, ResourcesPlugin.getWorkspace().getRoot(),
new HashSet(2));
return !cycleParticipants.isEmpty();
}
public boolean hasCycleMarker() {
return this.getCycleMarker() != null;
}
public int hashCode() {
return project.hashCode();
}
/**
* Returns true if the given project is accessible and it has a java nature,
* otherwise false.
*/
public static boolean hasJavaNature(IProject project) {
try {
return project.hasNature(PHPeclipsePlugin.PHP_NATURE_ID);
} catch (CoreException e) {
// project does not exist or is not open
}
return false;
}
/**
* Answers true if the project potentially contains any source. A project
* which has no source is immutable.
*/
public boolean hasSource() {
// look if any source folder on the classpath
// no need for resolved path given source folder cannot be abstracted
IClasspathEntry[] entries;
try {
entries = this.getRawClasspath();
} catch (JavaModelException e) {
return true; // unsure
}
for (int i = 0, max = entries.length; i < max; i++) {
if (entries[i].getEntryKind() == IClasspathEntry.CPE_SOURCE) {
return true;
}
}
return false;
}
/**
* Compare current classpath with given one to see if any different. Note
* that the argument classpath contains its binary output.
*/
public boolean isClasspathEqualsTo(IClasspathEntry[] newClasspath,
IPath newOutputLocation, IClasspathEntry[] otherClasspathWithOutput)
throws JavaModelException {
if (otherClasspathWithOutput != null
&& otherClasspathWithOutput.length > 0) {
int length = otherClasspathWithOutput.length;
if (length == newClasspath.length + 1) {
// output is amongst file entries (last one)
// compare classpath entries
for (int i = 0; i < length - 1; i++) {
if (!otherClasspathWithOutput[i].equals(newClasspath[i]))
return false;
}
// compare binary outputs
IClasspathEntry output = otherClasspathWithOutput[length - 1];
if (output.getContentKind() == ClasspathEntry.K_OUTPUT
&& output.getPath().equals(newOutputLocation))
return true;
}
}
return false;
}
/*
* @see IJavaProject
*/
public boolean isOnClasspath(IJavaElement element) {
IPath path = element.getPath();
switch (element.getElementType()) {
case IJavaElement.PACKAGE_FRAGMENT_ROOT:
if (!((IPackageFragmentRoot) element).isArchive()) {
// ensure that folders are only excluded if all of their
// children are excluded
path = path.append("*"); //$NON-NLS-1$
}
break;
case IJavaElement.PACKAGE_FRAGMENT:
if (!((IPackageFragmentRoot) element.getParent()).isArchive()) {
// ensure that folders are only excluded if all of their
// children are excluded
path = path.append("*"); //$NON-NLS-1$
}
break;
}
return this.isOnClasspath(path);
}
private boolean isOnClasspath(IPath path) {
IClasspathEntry[] classpath;
try {
classpath = this
.getResolvedClasspath(true/* ignore unresolved variable */);
} catch (JavaModelException e) {
return false; // not a Java project
}
for (int i = 0; i < classpath.length; i++) {
IClasspathEntry entry = classpath[i];
if (entry.getPath().isPrefixOf(path)
&& !Util.isExcluded(path, null, ((ClasspathEntry) entry)
.fullExclusionPatternChars(), true)) {
return true;
}
}
return false;
}
/*
* @see IJavaProject
*/
public boolean isOnClasspath(IResource resource) {
IPath path = resource.getFullPath();
// ensure that folders are only excluded if all of their children are
// excluded
if (resource.getType() == IResource.FOLDER) {
path = path.append("*"); //$NON-NLS-1$
}
return this.isOnClasspath(path);
}
private IPath getPluginWorkingLocation() {
return this.project.getWorkingLocation(JavaCore.PLUGIN_ID);
}
/*
* load preferences from a shareable format (VCM-wise)
*/
public Preferences loadPreferences() {
Preferences preferences = new Preferences();
// File prefFile =
// getProject().getLocation().append(PREF_FILENAME).toFile();
IPath projectMetaLocation = getPluginWorkingLocation();
if (projectMetaLocation != null) {
File prefFile = projectMetaLocation.append(PREF_FILENAME).toFile();
if (prefFile.exists()) { // load preferences from file
InputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(prefFile));
preferences.load(in);
return preferences;
} catch (IOException e) { // problems loading preference store
// - quietly ignore
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) { // ignore problems with
// close
}
}
}
}
}
return null;
}
/**
* @see IJavaProject#newEvaluationContext
*/
// public IEvaluationContext newEvaluationContext() {
//
// return new EvaluationContextWrapper(new EvaluationContext(), this);
// }
/**
* @see IJavaProject
*/
// public ITypeHierarchy newTypeHierarchy(
// IRegion region,
// IProgressMonitor monitor)
// throws JavaModelException {
//
// if (region == null) {
// throw new
// IllegalArgumentException(ProjectPrefUtil.bind("hierarchy.nullRegion"));//$NON-NLS-1$
// }
// CreateTypeHierarchyOperation op =
// new CreateTypeHierarchyOperation(null, region, this, true);
// runOperation(op, monitor);
// return op.getResult();
// }
/**
* @see IJavaProject
*/
// public ITypeHierarchy newTypeHierarchy(
// IType type,
// IRegion region,
// IProgressMonitor monitor)
// throws JavaModelException {
//
// if (type == null) {
// throw new
// IllegalArgumentException(ProjectPrefUtil.bind("hierarchy.nullFocusType"));//$NON-NLS-1$
// }
// if (region == null) {
// throw new
// IllegalArgumentException(ProjectPrefUtil.bind("hierarchy.nullRegion"));//$NON-NLS-1$
// }
// CreateTypeHierarchyOperation op =
// new CreateTypeHierarchyOperation(type, region, this, true);
// runOperation(op, monitor);
// return op.getResult();
// }
// /**
// * Open project if resource isn't closed
// */
// protected void openWhenClosed(IProgressMonitor pm) throws
// JavaModelException {
//
// if (!this.fProject.isOpen()) {
// throw newNotPresentException();
// } else {
// super.openWhenClosed(pm);
// }
// }
public String[] projectPrerequisites(IClasspathEntry[] entries)
throws JavaModelException {
ArrayList prerequisites = new ArrayList();
// need resolution
entries = getResolvedClasspath(entries, null, true, false, null/*
* no
* reverse
* map
*/);
for (int i = 0, length = entries.length; i < length; i++) {
IClasspathEntry entry = entries[i];
if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
prerequisites.add(entry.getPath().lastSegment());
}
}
int size = prerequisites.size();
if (size == 0) {
return NO_PREREQUISITES;
} else {
String[] result = new String[size];
prerequisites.toArray(result);
return result;
}
}
/**
* Reads the .classpath file from disk and returns the list of entries it
* contains (including output location entry) Returns null if .classfile is
* not present. Returns INVALID_CLASSPATH if it has a format problem.
*/
protected IClasspathEntry[] readClasspathFile(boolean createMarker,
boolean logProblems) {
try {
String xmlClasspath = getSharedProperty(CLASSPATH_FILENAME);
if (xmlClasspath == null)
return null;
return decodeClasspath(xmlClasspath, createMarker, logProblems);
} catch (CoreException e) {
// file does not exist (or not accessible)
if (createMarker && this.getProject().isAccessible()) {
this
.createClasspathProblemMarker(new JavaModelStatus(
IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT,
Util
.bind(
"classpath.cannotReadClasspathFile", this.getElementName()))); //$NON-NLS-1$
}
if (logProblems) {
Util.log(e, "Exception while retrieving " + this.getPath() //$NON-NLS-1$
+ "/.classpath, will revert to default classpath"); //$NON-NLS-1$
}
}
return null;
}
/**
* Removes the given builder from the build spec for the given project.
*/
protected void removeFromBuildSpec(String builderID) throws CoreException {
IProjectDescription description = getProject().getDescription();
ICommand[] commands = description.getBuildSpec();
for (int i = 0; i < commands.length; ++i) {
if (commands[i].getBuilderName().equals(builderID)) {
ICommand[] newCommands = new ICommand[commands.length - 1];
System.arraycopy(commands, 0, newCommands, 0, i);
System.arraycopy(commands, i + 1, newCommands, i,
commands.length - i - 1);
description.setBuildSpec(newCommands);
getProject().setDescription(description, null);
return;
}
}
}
/**
* @see JavaElement#rootedAt(IJavaProject)
*/
public IJavaElement rootedAt(IJavaProject project) {
return project;
}
/**
* Answers an ID which is used to distinguish project/entries during package
* fragment root computations
*/
public String rootID() {
return "[PRJ]" + this.getProject().getFullPath(); //$NON-NLS-1$
}
/**
* Saves the classpath in a shareable format (VCM-wise) only when necessary,
* that is, if it is semantically different from the existing one in file.
* Will never write an identical one.
*
* @return Return whether the .classpath file was modified.
*/
public boolean saveClasspath(IClasspathEntry[] newClasspath,
IPath newOutputLocation) throws JavaModelException {
if (!getProject().exists())
return false;
IClasspathEntry[] fileEntries = readClasspathFile(
false /* don't create markers */, false/* don't log problems */);
if (fileEntries != null
&& isClasspathEqualsTo(newClasspath, newOutputLocation,
fileEntries)) {
// no need to save it, it is the same
return false;
}
// actual file saving
try {
setSharedProperty(CLASSPATH_FILENAME, encodeClasspath(newClasspath,
newOutputLocation, true));
return true;
} catch (CoreException e) {
throw new JavaModelException(e);
}
}
/**
* Save project custom preferences to shareable file (.jprefs)
*/
private void savePreferences(Preferences preferences) {
if (!JavaProject.hasJavaNature(this.project))
return; // ignore
if (preferences == null
|| (!preferences.needsSaving() && preferences.propertyNames().length != 0)) {
// nothing to save
return;
}
// preferences need to be saved
// the preferences file is located in the plug-in's state area
// at a well-known name (.jprefs)
// File prefFile =
// this.project.getLocation().append(PREF_FILENAME).toFile();
File prefFile = getPluginWorkingLocation().append(PREF_FILENAME)
.toFile();
if (preferences.propertyNames().length == 0) {
// there are no preference settings
// rather than write an empty file, just delete any existing file
if (prefFile.exists()) {
prefFile.delete(); // don't worry if delete unsuccessful
}
return;
}
// write file, overwriting an existing one
OutputStream out = null;
try {
// do it as carefully as we know how so that we don't lose/mangle
// the setting in times of stress
out = new BufferedOutputStream(new FileOutputStream(prefFile));
preferences.store(out, null);
} catch (IOException e) { // problems saving preference store -
// quietly ignore
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) { // ignore problems with close
}
}
}
}
/**
* Update the Java command in the build spec (replace existing one if
* present, add one first if none).
*/
private void setJavaCommand(IProjectDescription description,
ICommand newCommand) throws CoreException {
ICommand[] oldCommands = description.getBuildSpec();
ICommand oldJavaCommand = getJavaCommand(description);
ICommand[] newCommands;
if (oldJavaCommand == null) {
// Add a Java build spec before other builders (1FWJK7I)
newCommands = new ICommand[oldCommands.length + 1];
System
.arraycopy(oldCommands, 0, newCommands, 1,
oldCommands.length);
newCommands[0] = newCommand;
} else {
for (int i = 0, max = oldCommands.length; i < max; i++) {
if (oldCommands[i] == oldJavaCommand) {
oldCommands[i] = newCommand;
break;
}
}
newCommands = oldCommands;
}
// Commit the spec change into the project
description.setBuildSpec(newCommands);
getProject().setDescription(description, null);
}
/**
* @see net.sourceforge.phpdt.core.IJavaProject#setOptions(Map)
*/
public void setOptions(Map newOptions) {
Preferences preferences;
setPreferences(preferences = new Preferences()); // always reset
// (26255)
if (newOptions != null) {
Iterator keys = newOptions.keySet().iterator();
while (keys.hasNext()) {
String key = (String) keys.next();
if (!JavaModelManager.OptionNames.contains(key))
continue; // unrecognized option
// no filtering for encoding (custom encoding for project is
// allowed)
String value = (String) newOptions.get(key);
preferences.setDefault(key, CUSTOM_DEFAULT_OPTION_VALUE); // empty
// string
// isn't
// the
// default
// (26251)
preferences.setValue(key, value);
}
}
// persist options
savePreferences(preferences);
}
/**
* @see IJavaProject
*/
public void setOutputLocation(IPath path, IProgressMonitor monitor)
throws JavaModelException {
if (path == null) {
throw new IllegalArgumentException(Util.bind("path.nullpath")); //$NON-NLS-1$
}
if (path.equals(getOutputLocation())) {
return;
}
this.setRawClasspath(SetClasspathOperation.ReuseClasspath, path,
monitor);
}
/*
* Set cached preferences, no preference file is saved, only info is updated
*/
public void setPreferences(Preferences preferences) {
IProject project = getProject();
if (!JavaProject.hasJavaNature(project))
return; // ignore
JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager
.getJavaModelManager().getPerProjectInfo(project, true);
perProjectInfo.preferences = preferences;
}
/**
* @see IJavaProject
*/
public void setRawClasspath(IClasspathEntry[] entries,
IPath outputLocation, IProgressMonitor monitor)
throws JavaModelException {
setRawClasspath(entries, outputLocation, monitor, true, // canChangeResource
// (as per API
// contract)
getResolvedClasspath(true), // ignoreUnresolvedVariable
true, // needValidation
true); // need to save
}
public void setRawClasspath(IClasspathEntry[] newEntries,
IPath newOutputLocation, IProgressMonitor monitor,
boolean canChangeResource, IClasspathEntry[] oldResolvedPath,
boolean needValidation, boolean needSave) throws JavaModelException {
JavaModelManager manager = (JavaModelManager) JavaModelManager
.getJavaModelManager();
try {
IClasspathEntry[] newRawPath = newEntries;
if (newRawPath == null) { // are we already with the default
// classpath
newRawPath = defaultClasspath();
}
SetClasspathOperation op = new SetClasspathOperation(this,
oldResolvedPath, newRawPath, newOutputLocation,
canChangeResource, needValidation, needSave);
runOperation(op, monitor);
} catch (JavaModelException e) {
manager.flush();
throw e;
}
}
/**
* @see IJavaProject
*/
public void setRawClasspath(IClasspathEntry[] entries,
IProgressMonitor monitor) throws JavaModelException {
setRawClasspath(entries, SetClasspathOperation.ReuseOutputLocation,
monitor, true, // canChangeResource (as per API contract)
getResolvedClasspath(true), // ignoreUnresolvedVariable
true, // needValidation
true); // need to save
}
/**
* NOTE: <code>null</code> specifies default classpath, and an empty array
* specifies an empty classpath.
*
* @exception NotPresentException
* if this project does not exist.
*/
// protected void setRawClasspath0(IClasspathEntry[] rawEntries)
// throws JavaModelException {
//
// JavaModelManager.PerProjectInfo info =
// JavaModelManager.getJavaModelManager().getPerProjectInfoCheckExistence(project);
//
// synchronized (info) {
// if (rawEntries != null) {
// info.classpath = rawEntries;
// }
//
// // clear cache of resolved classpath
// info.lastResolvedClasspath = null;
// info.resolvedPathToRawEntries = null;
// }
// }
/**
* Record a shared persistent property onto a project. Note that it is
* orthogonal to IResource persistent properties, and client code has to
* decide which form of storage to use appropriately. Shared properties
* produce real resource files which can be shared through a VCM onto a
* server. Persistent properties are not shareable.
*
* shared properties end up in resource files, and thus cannot be modified
* during delta notifications (a CoreException would then be thrown).
*
* @see JavaProject#getSharedProperty(String key)
*/
public void setSharedProperty(String key, String value)
throws CoreException {
IFile rscFile = getProject().getFile(key);
InputStream inputStream = new ByteArrayInputStream(value.getBytes());
// update the resource content
if (rscFile.exists()) {
if (rscFile.isReadOnly()) {
// provide opportunity to checkout read-only .classpath file
// (23984)
ResourcesPlugin.getWorkspace().validateEdit(
new IFile[] { rscFile }, null);
}
rscFile.setContents(inputStream, IResource.FORCE, null);
} else {
rscFile.create(inputStream, IResource.FORCE, null);
}
}
/**
* Update cycle markers for all java projects
*/
public static void updateAllCycleMarkers() throws JavaModelException {
// long start = System.currentTimeMillis();
JavaModelManager manager = JavaModelManager.getJavaModelManager();
IJavaProject[] projects = manager.getJavaModel().getJavaProjects();
IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot();
HashSet cycleParticipants = new HashSet();
HashSet traversed = new HashSet();
int length = projects.length;
// compute cycle participants
ArrayList prereqChain = new ArrayList();
for (int i = 0; i < length; i++) {
JavaProject project = (JavaProject) projects[i];
if (!traversed.contains(project.getPath())) {
prereqChain.clear();
project.updateCycleParticipants(null, prereqChain,
cycleParticipants, workspaceRoot, traversed);
}
}
// System.out.println("updateAllCycleMarkers: " +
// (System.currentTimeMillis() - start) + " ms");
for (int i = 0; i < length; i++) {
JavaProject project = (JavaProject) projects[i];
if (cycleParticipants.contains(project.getPath())) {
IMarker cycleMarker = project.getCycleMarker();
String circularCPOption = project.getOption(
JavaCore.CORE_CIRCULAR_CLASSPATH, true);
int circularCPSeverity = JavaCore.ERROR
.equals(circularCPOption) ? IMarker.SEVERITY_ERROR
: IMarker.SEVERITY_WARNING;
if (cycleMarker != null) {
// update existing cycle marker if needed
try {
int existingSeverity = ((Integer) cycleMarker
.getAttribute(IMarker.SEVERITY)).intValue();
if (existingSeverity != circularCPSeverity) {
cycleMarker.setAttribute(IMarker.SEVERITY,
circularCPSeverity);
}
} catch (CoreException e) {
throw new JavaModelException(e);
}
} else {
// create new marker
project
.createClasspathProblemMarker(new JavaModelStatus(
IJavaModelStatusConstants.CLASSPATH_CYCLE,
project));
}
} else {
project.flushClasspathProblemMarkers(true, false);
}
}
}
/**
* If a cycle is detected, then cycleParticipants contains all the paths of
* projects involved in this cycle (directly and indirectly), no cycle if
* the set is empty (and started empty)
*/
public void updateCycleParticipants(IClasspathEntry[] preferredClasspath,
ArrayList prereqChain, HashSet cycleParticipants,
IWorkspaceRoot workspaceRoot, HashSet traversed) {
IPath path = this.getPath();
prereqChain.add(path);
traversed.add(path);
try {
IClasspathEntry[] classpath = preferredClasspath == null ? getResolvedClasspath(true)
: preferredClasspath;
for (int i = 0, length = classpath.length; i < length; i++) {
IClasspathEntry entry = classpath[i];
if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) {
IPath prereqProjectPath = entry.getPath();
int index = cycleParticipants.contains(prereqProjectPath) ? 0
: prereqChain.indexOf(prereqProjectPath);
if (index >= 0) { // refer to cycle, or in cycle itself
for (int size = prereqChain.size(); index < size; index++) {
cycleParticipants.add(prereqChain.get(index));
}
} else {
if (!traversed.contains(prereqProjectPath)) {
IResource member = workspaceRoot
.findMember(prereqProjectPath);
if (member != null
&& member.getType() == IResource.PROJECT) {
JavaProject project = (JavaProject) JavaCore
.create((IProject) member);
project.updateCycleParticipants(null,
prereqChain, cycleParticipants,
workspaceRoot, traversed);
}
}
}
}
}
} catch (JavaModelException e) {
}
prereqChain.remove(path);
}
/**
* Reset the collection of package fragment roots (local ones) - only if
* opened. Need to check *all* package fragment roots in order to reset
* NameLookup
*/
public void updatePackageFragmentRoots() {
if (this.isOpen()) {
try {
JavaProjectElementInfo info = getJavaProjectElementInfo();
IClasspathEntry[] classpath = getResolvedClasspath(true);
// NameLookup lookup = info.getNameLookup();
// if (lookup != null){
// IPackageFragmentRoot[] oldRoots =
// lookup.fPackageFragmentRoots;
// IPackageFragmentRoot[] newRoots =
// computePackageFragmentRoots(classpath, true);
// checkIdentical: { // compare all pkg fragment root lists
// if (oldRoots.length == newRoots.length){
// for (int i = 0, length = oldRoots.length; i < length; i++){
// if (!oldRoots[i].equals(newRoots[i])){
// break checkIdentical;
// }
// }
// return; // no need to update
// }
// }
// info.setNameLookup(null); // discard name lookup (hold onto
// roots)
// }
info.setNonJavaResources(null);
info.setChildren(computePackageFragmentRoots(classpath, false));
} catch (JavaModelException e) {
try {
close(); // could not do better
} catch (JavaModelException ex) {
}
}
}
}
public void removeLoadPathEntry(IProject anotherPHPProject) {
Iterator entries = getLoadPathEntries().iterator();
while (entries.hasNext()) {
LoadPathEntry entry = (LoadPathEntry) entries.next();
if (entry.getType() == LoadPathEntry.TYPE_PROJECT
&& entry.getProject().getName().equals(
anotherPHPProject.getName())) {
getLoadPathEntries().remove(entry);
fScratched = true;
break;
}
}
}
public void save() throws CoreException {
if (fScratched) {
InputStream xmlPath = new ByteArrayInputStream(getLoadPathXML()
.getBytes());
IFile loadPathsFile = getLoadPathEntriesFile();
if (!loadPathsFile.exists())
loadPathsFile.create(xmlPath, true, null);
else
loadPathsFile.setContents(xmlPath, true, false, null);
fScratched = false;
}
}
}
The table below shows all metrics for JavaProject.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 371.00 | Number of blocks | |
| BLOCK_COMMENT | 64.00 | Number of block comment lines | |
| COMMENTS | 1194.00 | Comment lines | |
| COMMENT_DENSITY | 0.85 | Comment density | |
| COMPARISONS | 238.00 | Number of comparison operators | |
| CYCLOMATIC | 430.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 133.00 | Comments in declarations | |
| DOC_COMMENT | 415.00 | Number of javadoc comment lines | |
| ELOC | 1407.00 | Effective lines of code | |
| EXEC_COMMENTS | 108.00 | Comments in executable code | |
| EXITS | 260.00 | Procedure exits | |
| FUNCTIONS | 121.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 109.41 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 413.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 0.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 1.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 3.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 4.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 37.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 9.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 1.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 2.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 2.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 1.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 0.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 1.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 0.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 70.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 52.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 1.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 40.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 25.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 1.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 4.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 4.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 7921.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 5.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 1.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 3.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 2.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 2.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 16.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 5.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 4.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 5.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 8.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 11.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 3.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 3231.00 | Number of lines in the source file | |
| LINE_COMMENT | 715.00 | Number of line comments | |
| LOC | 1729.00 | Lines of code | |
| LOGICAL_LINES | 744.00 | Number of statements | |
| LOOPS | 33.00 | Number of loops | |
| NEST_DEPTH | 7.00 | Maximum nesting depth | |
| OPERANDS | 3580.00 | Number of operands | |
| OPERATORS | 7185.00 | Number of operators | |
| PARAMS | 150.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 10765.00 | Halstead program length | |
| PROGRAM_VOCAB | 1059.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 263.00 | Number of return points from functions | |
| SIZE | 100477.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 998.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 61.00 | Number of unique operators | |
| WHITESPACE | 308.00 | Number of whitespace lines | |