IJavaProject.java
| Index Score | ||
|---|---|---|
 |
 |
net.sourceforge.phpdt.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 | |
|---|---|---|
| DOC_COMMENT | Number of javadoc comment lines |  |
| COMMENTS | Comment lines | |
| COMMENT_DENSITY | Comment density | |
| DECL_COMMENTS | Comments in declarations | |
| SIZE | Size of the file in bytes | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| LINES | Number of lines in the source file | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| CYCLOMATIC | Cyclomatic complexity | |
| EXEC_COMMENTS | Comments in executable code | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| LINE_COMMENT | Number of line comments | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| COMPARISONS | Number of comparison operators | |
| ELOC | Effective lines of code | |
| LOGICAL_LINES | Number of statements | |
| LOC | Lines of code | |
| OPERATORS | Number of operators | |
| PROGRAM_LENGTH | Halstead program length | |
| BLOCKS | Number of blocks | |
| OPERANDS | Number of operands | |
| RETURNS | Number of return points from functions | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| LOOPS | Number of loops | |
| WHITESPACE | Number of whitespace lines | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| EXITS | Procedure exits | |
| UNIQUE_OPERATORS | Number of unique operators | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
/*******************************************************************************
* 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
* IBM Corporation - added getOption(String, boolean), getOptions(boolean) and setOptions(Map)
* IBM Corporation - deprecated getPackageFragmentRoots(IClasspathEntry) and
* added findPackageFragmentRoots(IClasspathEntry)
* IBM Corporation - added isOnClasspath(IResource)
*******************************************************************************/
package net.sourceforge.phpdt.core;
import java.util.Map;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
/**
* A Java project represents a view of a project resource in terms of Java
* elements such as package fragments, types, methods and fields. A project may
* contain several package roots, which contain package fragments. A package
* root corresponds to an underlying folder or JAR.
* <p>
* Each Java project has a classpath, defining which folders contain source code
* and where required libraries are located. Each Java project also has an
* output location, defining where the builder writes <code>.class</code>
* files. A project that references packages in another project can access the
* packages by including the required project in a classpath entry. The Java
* model will present the source elements in the required project; when
* building, the compiler will use the corresponding generated class files from
* the required project's output location(s)). The classpath format is a
* sequence of classpath entries describing the location and contents of package
* fragment roots.
* </p>
* Java project elements need to be opened before they can be navigated or
* manipulated. The children of a Java project are the package fragment roots
* that are defined by the classpath and contained in this project (in other
* words, it does not include package fragment roots for other projects).
* </p>
* <p>
* This interface is not intended to be implemented by clients. An instance of
* one of these handles can be created via <code>JavaCore.create(project)</code>.
* </p>
*
* @see JavaCore#create(org.eclipse.core.resources.IProject)
* @see IClasspathEntry
*/
public interface IJavaProject extends IParent, IJavaElement, IOpenable {
/**
* Returns the <code>IJavaElement</code> corresponding to the given
* classpath-relative path, or <code>null</code> if no such
* <code>IJavaElement</code> is found. The result is one of an
* <code>ICompilationUnit</code>, <code>IClassFile</code>, or
* <code>IPackageFragment</code>.
* <p>
* When looking for a package fragment, there might be several potential
* matches; only one of them is returned.
*
* <p>
* For example, the path "java/lang/Object.java", would result in the
* <code>ICompilationUnit</code> or <code>IClassFile</code>
* corresponding to "java.lang.Object". The path "java/lang" would result in
* the <code>IPackageFragment</code> for "java.lang".
*
* @param path
* the given classpath-relative path
* @exception JavaModelException
* if the given path is <code>null</code> or absolute
* @return the <code>IJavaElement</code> corresponding to the given
* classpath-relative path, or <code>null</code> if no such
* <code>IJavaElement</code> is found
*/
IJavaElement findElement(IPath path) throws JavaModelException;
/**
* Returns the first existing package fragment on this project's classpath
* whose path matches the given (absolute) path, or <code>null</code> if
* none exist. The path can be: - internal to the workbench: "/Project/src" -
* external to the workbench: "c:/jdk/classes.zip/java/lang"
*
* @param path
* the given absolute path
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
* @return the first existing package fragment on this project's classpath
* whose path matches the given (absolute) path, or
* <code>null</code> if none exist
*/
// IPackageFragment findPackageFragment(IPath path) throws
// JavaModelException;
/**
* Returns the existing package fragment root on this project's classpath
* whose path matches the given (absolute) path, or <code>null</code> if
* one does not exist. The path can be: - internal to the workbench:
* "/Compiler/src" - external to the workbench: "c:/jdk/classes.zip"
*
* @param path
* the given absolute path
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
* @return the existing package fragment root on this project's classpath
* whose path matches the given (absolute) path, or
* <code>null</code> if one does not exist
*/
IPackageFragmentRoot findPackageFragmentRoot(IPath path)
throws JavaModelException;
/**
* Returns the existing package fragment roots identified by the given
* entry. Note that a classpath entry that refers to another project may
* have more than one root (if that project has more than on root containing
* source), and classpath entries within the current project identify a
* single root.
* <p>
* If the classpath entry denotes a variable, it will be resolved and return
* the roots of the target entry (empty if not resolvable).
* <p>
* If the classpath entry denotes a container, it will be resolved and
* return the roots corresponding to the set of container entries (empty if
* not resolvable).
*
* @param entry
* the given entry
* @return the existing package fragment roots identified by the given entry
* @see IClasspathContainer
* @since 2.1
*/
IPackageFragmentRoot[] findPackageFragmentRoots(IClasspathEntry entry);
/**
* Returns the first type found following this project's classpath with the
* given fully qualified name or <code>null</code> if none is found. The
* fully qualified name is a dot-separated name. For example, a class B
* defined as a member type of a class A in package x.y should have a the
* fully qualified name "x.y.A.B".
*
* Note that in order to be found, a type name (or its toplevel enclosing
* type name) must match its corresponding compilation unit name. As a
* consequence, secondary types cannot be found using this functionality.
* Secondary types can however be explicitely accessed through their
* enclosing unit or found by the <code>SearchEngine</code>.
*
* @param fullyQualifiedName
* the given fully qualified name
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
* @return the first type found following this project's classpath with the
* given fully qualified name or <code>null</code> if none is
* found
* @see IType#getFullyQualifiedName(char)
* @since 2.0
*/
// IType findType(String fullyQualifiedName) throws JavaModelException;
/**
* Returns the first type found following this project's classpath with the
* given package name and type qualified name or <code>null</code> if none
* is found. The package name is a dot-separated name. The type qualified
* name is also a dot-separated name. For example, a class B defined as a
* member type of a class A should have the type qualified name "A.B".
*
* Note that in order to be found, a type name (or its toplevel enclosing
* type name) must match its corresponding compilation unit name. As a
* consequence, secondary types cannot be found using this functionality.
* Secondary types can however be explicitely accessed through their
* enclosing unit or found by the <code>SearchEngine</code>.
*
* @param packageName
* the given package name
* @param typeQualifiedName
* the given type qualified name
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
* @return the first type found following this project's classpath with the
* given package name and type qualified name or <code>null</code>
* if none is found
* @see IType#getTypeQualifiedName(char)
*
* @since 2.0
*/
// IType findType(String packageName, String typeQualifiedName) throws
// JavaModelException;
/**
* Returns all of the existing package fragment roots that exist on the
* classpath, in the order they are defined by the classpath.
*
* @return all of the existing package fragment roots that exist on the
* classpath
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
*/
IPackageFragmentRoot[] getAllPackageFragmentRoots()
throws JavaModelException;
/**
* Returns an array of non-Java resources directly contained in this
* project. It does not transitively answer non-Java resources contained in
* folders; these would have to be explicitly iterated over.
* <p>
* Non-Java resources includes other files and folders located in the
* project not accounted for by any of it source or binary package fragment
* roots. If the project is a source folder itself, resources excluded from
* the corresponding source classpath entry by one or more exclusion
* patterns are considered non-Java resources and will appear in the result
* (possibly in a folder)
* </p>
*
* @return an array of non-Java resources directly contained in this project
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
*/
// Object[] getNonJavaResources() throws JavaModelException;
/**
* Helper method for returning one option value only. Equivalent to
* <code>(String)this.getOptions(inheritJavaCoreOptions).get(optionName)</code>
* Note that it may answer <code>null</code> if this option does not
* exist, or if there is no custom value for it.
* <p>
* For a complete description of the configurable options, see
* <code>JavaCore#getDefaultOptions</code>.
* </p>
*
* @param optionName
* the name of an option
* @param inheritJavaCoreOptions -
* boolean indicating whether JavaCore options should be
* inherited as well
* @return the String value of a given option
* @see JavaCore#getDefaultOptions
* @since 2.1
*/
String getOption(String optionName, boolean inheritJavaCoreOptions);
/**
* Returns the table of the current custom options for this project.
* Projects remember their custom options, in other words, only the options
* different from the the JavaCore global options for the workspace. A
* boolean argument allows to directly merge the project options with global
* ones from <code>JavaCore</code>.
* <p>
* For a complete description of the configurable options, see
* <code>JavaCore#getDefaultOptions</code>.
* </p>
*
* @param inheritJavaCoreOptions -
* boolean indicating whether JavaCore options should be
* inherited as well
* @return table of current settings of all options (key type:
* <code>String</code>; value type: <code>String</code>)
* @see JavaCore#getDefaultOptions
* @since 2.1
*/
Map getOptions(boolean inheritJavaCoreOptions);
/**
* Returns the default output location for this project as a workspace-
* relative absolute path.
* <p>
* The default output location is where class files are ordinarily generated
* (and resource files, copied). Each source classpath entry can also
* specify an output location for the generated class files (and copied
* resource files) corresponding to compilation units under that source
* folder. This makes it possible to arrange generated class files for
* different source folders in different output folders, and not necessarily
* the default output folder. This means that the generated class files for
* the project may end up scattered across several folders, rather than all
* in the default output folder (which is more standard).
* </p>
*
* @return the workspace-relative absolute path of the default output folder
* @exception JavaModelException
* if this element does not exist
* @see #setOutputLocation
* @see IClasspathEntry#getOutputLocation
*/
IPath getOutputLocation() throws JavaModelException;
/**
* Returns a package fragment root for the JAR at the specified file system
* path. This is a handle-only method. The underlying
* <code>java.io.File</code> may or may not exist. No resource is
* associated with this local JAR package fragment root.
*
* @param jarPath
* the jars's file system path
* @return a package fragment root for the JAR at the specified file system
* path
*/
// IPackageFragmentRoot getPackageFragmentRoot(String jarPath);
/**
* Returns a package fragment root for the given resource, which must either
* be a folder representing the top of a package hierarchy, or a
* <code>.jar</code> or <code>.zip</code> file. This is a handle-only
* method. The underlying resource may or may not exist.
*
* @param resource
* the given resource
* @return a package fragment root for the given resource, which must either
* be a folder representing the top of a package hierarchy, or a
* <code>.jar</code> or <code>.zip</code> file
*/
IPackageFragmentRoot getPackageFragmentRoot(IResource resource);
/**
* Returns all of the package fragment roots contained in this project,
* identified on this project's resolved classpath. The result does not
* include package fragment roots in other projects referenced on this
* project's classpath.
*
* <p>
* NOTE: This is equivalent to <code>getChildren()</code>.
*
* @return all of the package fragment roots contained in this project,
* identified on this project's resolved classpath
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
*/
IPackageFragmentRoot[] getPackageFragmentRoots() throws JavaModelException;
/**
* Returns the existing package fragment roots identified by the given
* entry. Note that a classpath entry that refers to another project may
* have more than one root (if that project has more than on root containing
* source), and classpath entries within the current project identify a
* single root.
* <p>
* If the classpath entry denotes a variable, it will be resolved and return
* the roots of the target entry (empty if not resolvable).
* <p>
* If the classpath entry denotes a container, it will be resolved and
* return the roots corresponding to the set of container entries (empty if
* not resolvable).
*
* @param entry
* the given entry
* @return the existing package fragment roots identified by the given entry
* @see IClasspathContainer
* @deprecated Use IJavaProject#findPackageFragmentRoots instead
*/
IPackageFragmentRoot[] getPackageFragmentRoots(IClasspathEntry entry);
/**
* Returns all package fragments in all package fragment roots contained in
* this project. This is a convenience method.
*
* Note that the package fragment roots corresponds to the resolved
* classpath of the project.
*
* @return all package fragments in all package fragment roots contained in
* this project
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
*/
IPackageFragment[] getPackageFragments() throws JavaModelException;
/**
* Returns the <code>IProject</code> on which this
* <code>IJavaProject</code> was created. This is handle-only method.
*
* @return the <code>IProject</code> on which this
* <code>IJavaProject</code> was created
*/
IProject getProject();
/**
* Returns the raw classpath for the project, as a list of classpath
* entries. This corresponds to the exact set of entries which were assigned
* using <code>setRawClasspath</code>, in particular such a classpath may
* contain classpath variable entries. Classpath variable entries can be
* resolved individually (see <code>JavaCore#getClasspathVariable</code>),
* or the full classpath can be resolved at once using the helper method
* <code>getResolvedClasspath</code>.
* <p>
* A classpath variable provides an indirection level for better sharing a
* classpath. As an example, it allows a classpath to no longer refer
* directly to external JARs located in some user specific location. The
* classpath can simply refer to some variables defining the proper
* locations of these external JARs.
* <p>
* Note that in case the project isn't yet opened, the classpath will
* directly be read from the associated <tt>.classpath</tt> file.
* <p>
*
* @return the raw classpath for the project, as a list of classpath entries
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
* @see IClasspathEntry
*/
IClasspathEntry[] getRawClasspath() throws JavaModelException;
/**
* Returns the names of the projects that are directly required by this
* project. A project is required if it is in its classpath.
* <p>
* The project names are returned in the order they appear on the classpath.
*
* @return the names of the projects that are directly required by this
* project in classpath order
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
*/
String[] getRequiredProjectNames() throws JavaModelException;
/**
* This is a helper method returning the resolved classpath for the project
* as a list of simple (non-variable, non-container) classpath entries. All
* classpath variable and classpath container entries in the project's raw
* classpath will be replaced by the simple classpath entries they resolve
* to.
* <p>
* The resulting resolved classpath is accurate for the given point in time.
* If the project's raw classpath is later modified, or if classpath
* variables are changed, the resolved classpath can become out of date.
* Because of this, hanging on resolved classpath is not recommended.
* </p>
*
* @param ignoreUnresolvedEntry
* indicates how to handle unresolvable variables and containers;
* <code>true</code> indicates that missing variables and
* unresolvable classpath containers should be silently ignored,
* and that the resulting list should consist only of the entries
* that could be successfully resolved; <code>false</code>
* indicates that a <code>JavaModelException</code> should be
* thrown for the first unresolved variable or container
* @return the resolved classpath for the project as a list of simple
* classpath entries, where all classpath variable and container
* entries have been resolved and substituted with their final
* target entries
* @exception JavaModelException
* in one of the corresponding situation:
* <ul>
* <li>this element does not exist</li>
* <li>an exception occurs while accessing its corresponding
* resource</li>
* <li>a classpath variable or classpath container was not
* resolvable and <code>ignoreUnresolvedEntry</code> is
* <code>false</code>.</li>
* </ul>
* @see IClasspathEntry
*/
IClasspathEntry[] getResolvedClasspath(boolean ignoreUnresolvedEntry)
throws JavaModelException;
/**
* Returns whether this project has been built at least once and thus
* whether it has a build state.
*
* @return true if this project has been built at least once, false
* otherwise
*/
boolean hasBuildState();
/**
* Returns whether setting this project's classpath to the given classpath
* entries would result in a cycle.
*
* If the set of entries contains some variables, those are resolved in
* order to determine cycles.
*
* @param entries
* the given classpath entries
* @return true if the given classpath entries would result in a cycle,
* false otherwise
*/
boolean hasClasspathCycle(IClasspathEntry[] entries);
/**
* Returns whether the given element is on the classpath of this project,
* that is, referenced from a classpath entry and not explicitly excluded
* using an exclusion pattern.
*
* @param element
* the given element
* @return <code>true</code> if the given element is on the classpath of
* this project, <code>false</code> otherwise
* @see IClasspathEntry#getExclusionPatterns
* @since 2.0
*/
// boolean isOnClasspath(IJavaElement element);
/**
* Returns whether the given resource is on the classpath of this project,
* that is, referenced from a classpath entry and not explicitly excluded
* using an exclusion pattern.
*
* @param element
* the given element
* @return <code>true</code> if the given resource is on the classpath of
* this project, <code>false</code> otherwise
* @see IClasspathEntry#getExclusionPatterns
* @since 2.1
*/
// boolean isOnClasspath(IResource resource);
/**
* Creates a new evaluation context.
*
* @return a new evaluation context.
*/
// IEvaluationContext newEvaluationContext();
/**
* Creates and returns a type hierarchy for all types in the given region,
* considering subtypes within that region.
*
* @param monitor
* the given progress monitor
* @param region
* the given region
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
* @exception IllegalArgumentException
* if region is <code>null</code>
* @return a type hierarchy for all types in the given region, considering
* subtypes within that region
*/
// ITypeHierarchy newTypeHierarchy(IRegion region, IProgressMonitor monitor)
// throws JavaModelException;
/**
* Creates and returns a type hierarchy for the given type considering
* subtypes in the specified region.
*
* @param monitor
* the given monitor
* @param region
* the given region
* @param type
* the given type
*
* @exception JavaModelException
* if this element does not exist or if an exception occurs
* while accessing its corresponding resource
*
* @exception IllegalArgumentException
* if type or region is <code>null</code>
* @return a type hierarchy for the given type considering subtypes in the
* specified region
*/
// ITypeHierarchy newTypeHierarchy(
// IType type,
// IRegion region,
// IProgressMonitor monitor)
// throws JavaModelException;
/**
* Sets the project custom options. All and only the options explicitly
* included in the given table are remembered; all previous option settings
* are forgotten, including ones not explicitly mentioned.
* <p>
* For a complete description of the configurable options, see
* <code>JavaCore#getDefaultOptions</code>.
* </p>
*
* @param newOptions
* the new options (key type: <code>String</code>; value type:
* <code>String</code>), or <code>null</code> to flush all
* custom options (clients will automatically get the global
* JavaCore options).
* @see JavaCore#getDefaultOptions
* @since 2.1
*/
void setOptions(Map newOptions);
/**
* Sets the default output location of this project to the location
* described by the given workspace-relative absolute path.
* <p>
* The default output location is where class files are ordinarily generated
* (and resource files, copied). Each source classpath entries can also
* specify an output location for the generated class files (and copied
* resource files) corresponding to compilation units under that source
* folder. This makes it possible to arrange that generated class files for
* different source folders to end up in different output folders, and not
* necessarily the default output folder. This means that the generated
* class files for the project may end up scattered across several folders,
* rather than all in the default output folder (which is more standard).
* </p>
*
* @param path
* the workspace-relative absolute path of the default output
* folder
* @param monitor
* the progress monitor
*
* @exception JavaModelException
* if the classpath could not be set. Reasons include:
* <ul>
* <li> This Java element does not exist
* (ELEMENT_DOES_NOT_EXIST)</li>
* <li> The path refers to a location not contained in this
* project (<code>PATH_OUTSIDE_PROJECT</code>)
* <li> The path is not an absolute path (<code>RELATIVE_PATH</code>)
* <li> The path is nested inside a package fragment root of
* this project (<code>INVALID_PATH</code>)
* <li> The output location is being modified during resource
* change event notification (CORE_EXCEPTION)
* </ul>
* @see #getOutputLocation
* @see IClasspathEntry#getOutputLocation
*/
void setOutputLocation(IPath path, IProgressMonitor monitor)
throws JavaModelException;
/**
* Sets the classpath of this project using a list of classpath entries. In
* particular such a classpath may contain classpath variable entries.
* Classpath variable entries can be resolved individually (see
* <code>JavaCore#getClasspathVariable</code>), or the full classpath can
* be resolved at once using the helper method
* <code>getResolvedClasspath</code>.
* <p>
* A classpath variable provides an indirection level for better sharing a
* classpath. As an example, it allows a classpath to no longer refer
* directly to external JARs located in some user specific location. The
* classpath can simply refer to some variables defining the proper
* locations of these external JARs.
* <p>
* Setting the classpath to <code>null</code> specifies a default
* classpath (the project root). Setting the classpath to an empty array
* specifies an empty classpath.
* <p>
* If a cycle is detected while setting this classpath, an error marker will
* be added to the project closing the cycle. To avoid this problem, use
* <code>hasClasspathCycle(IClasspathEntry[] entries)</code> before
* setting the classpath.
*
* @param entries
* a list of classpath entries
* @param monitor
* the given progress monitor
* @exception JavaModelException
* if the classpath could not be set. Reasons include:
* <ul>
* <li> This Java element does not exist
* (ELEMENT_DOES_NOT_EXIST)</li>
* <li> The classpath is being modified during resource
* change event notification (CORE_EXCEPTION)
* <li> The classpath failed the validation check as defined
* by <code>JavaConventions#validateClasspath</code>
* </ul>
* @see IClasspathEntry
*/
void setRawClasspath(IClasspathEntry[] entries, IProgressMonitor monitor)
throws JavaModelException;
/**
* Sets the both the classpath of this project and its default output
* location at once. The classpath is defined using a list of classpath
* entries. In particular, such a classpath may contain classpath variable
* entries. Classpath variable entries can be resolved individually (see
* <code>JavaCore#getClasspathVariable</code>), or the full classpath can
* be resolved at once using the helper method
* <code>getResolvedClasspath</code>.
* <p>
* A classpath variable provides an indirection level for better sharing a
* classpath. As an example, it allows a classpath to no longer refer
* directly to external JARs located in some user specific location. The
* classpath can simply refer to some variables defining the proper
* locations of these external JARs.
* </p>
* <p>
* Setting the classpath to <code>null</code> specifies a default
* classpath (the project root). Setting the classpath to an empty array
* specifies an empty classpath.
* </p>
* <p>
* If a cycle is detected while setting this classpath, an error marker will
* be added to the project closing the cycle. To avoid this problem, use
* <code>hasClasspathCycle(IClasspathEntry[] entries)</code> before
* setting the classpath.
* </p>
*
* @param entries
* a list of classpath entries
* @param monitor
* the progress monitor
* @param outputLocation
* the default output location
* @exception JavaModelException
* if the classpath could not be set. Reasons include:
* <ul>
* <li> This Java element does not exist
* (ELEMENT_DOES_NOT_EXIST)</li>
* <li> Two or more entries specify source roots with the
* same or overlapping paths (NAME_COLLISION)
* <li> A entry of kind <code>CPE_PROJECT</code> refers to
* this project (INVALID_PATH)
* <li>This Java element does not exist
* (ELEMENT_DOES_NOT_EXIST)</li>
* <li>The output location path refers to a location not
* contained in this project (<code>PATH_OUTSIDE_PROJECT</code>)
* <li>The output location path is not an absolute path (<code>RELATIVE_PATH</code>)
* <li>The output location path is nested inside a package
* fragment root of this project (<code>INVALID_PATH</code>)
* <li> The classpath is being modified during resource
* change event notification (CORE_EXCEPTION)
* </ul>
* @see IClasspathEntry
* @since 2.0
*/
void setRawClasspath(IClasspathEntry[] entries, IPath outputLocation,
IProgressMonitor monitor) throws JavaModelException;
}
The table below shows all metrics for IJavaProject.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 0.00 | Number of blocks | |
| BLOCK_COMMENT | 0.00 | Number of block comment lines | |
| COMMENTS | 657.00 | Comment lines | |
| COMMENT_DENSITY | 18.77 | Comment density | |
| COMPARISONS | 0.00 | Number of comparison operators | |
| CYCLOMATIC | 21.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 43.00 | Comments in declarations | |
| DOC_COMMENT | 640.00 | Number of javadoc comment lines | |
| ELOC | 35.00 | Effective lines of code | |
| EXEC_COMMENTS | 0.00 | Comments in executable code | |
| EXITS | 0.00 | Procedure exits | |
| FUNCTIONS | 21.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 14.65 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 18.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 | 0.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 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 0.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 | 0.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 | 0.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 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.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 | 0.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 | 0.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 | 0.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 0.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 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 0.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 | 0.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 | 0.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 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 652.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 | 0.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 | 0.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 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 0.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.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 | 0.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.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 | 0.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 | 0.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 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 0.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 | 0.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 | 716.00 | Number of lines in the source file | |
| LINE_COMMENT | 17.00 | Number of line comments | |
| LOC | 35.00 | Lines of code | |
| LOGICAL_LINES | 27.00 | Number of statements | |
| LOOPS | 0.00 | Number of loops | |
| NEST_DEPTH | 0.00 | Maximum nesting depth | |
| OPERANDS | 112.00 | Number of operands | |
| OPERATORS | 151.00 | Number of operators | |
| PARAMS | 18.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 263.00 | Halstead program length | |
| PROGRAM_VOCAB | 82.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 0.00 | Number of return points from functions | |
| SIZE | 31536.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 65.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 17.00 | Number of unique operators | |
| WHITESPACE | 24.00 | Number of whitespace lines | |