* 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 .class
* 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.
*
* This interface is not intended to be implemented by clients. An instance of
* one of these handles can be created via JavaCore.create(project).
*
IJavaElement corresponding to the given
* classpath-relative path, or null if no such
* IJavaElement is found. The result is one of an
* ICompilationUnit, IClassFile, or
* IPackageFragment.
* * When looking for a package fragment, there might be several potential * matches; only one of them is returned. * *
* For example, the path "java/lang/Object.java", would result in the
* ICompilationUnit or IClassFile
* corresponding to "java.lang.Object". The path "java/lang" would result in
* the IPackageFragment for "java.lang".
*
* @param path
* the given classpath-relative path
* @exception JavaModelException
* if the given path is null or absolute
* @return the IJavaElement corresponding to the given
* classpath-relative path, or null if no such
* IJavaElement 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 null 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
* null 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 null 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
* null 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.
*
* If the classpath entry denotes a variable, it will be resolved and return * the roots of the target entry (empty if not resolvable). *
* 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 null 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 SearchEngine.
*
* @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 null 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 null 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 SearchEngine.
*
* @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 null
* 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.
*
* 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) *
* * @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 *(String)this.getOptions(inheritJavaCoreOptions).get(optionName)
* Note that it may answer null if this option does not
* exist, or if there is no custom value for it.
*
* For a complete description of the configurable options, see
* JavaCore#getDefaultOptions.
*
JavaCore.
*
* For a complete description of the configurable options, see
* JavaCore#getDefaultOptions.
*
String; value type: String)
* @see JavaCore#getDefaultOptions
* @since 2.1
*/
Map getOptions(boolean inheritJavaCoreOptions);
/**
* Returns the default output location for this project as a workspace-
* relative absolute path.
* * 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). *
* * @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 *java.io.File 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
* .jar or .zip 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
* .jar or .zip 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.
*
*
* NOTE: This is equivalent to getChildren().
*
* @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.
*
* If the classpath entry denotes a variable, it will be resolved and return * the roots of the target entry (empty if not resolvable). *
* 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 IProject on which this
* IJavaProject was created. This is handle-only method.
*
* @return the IProject on which this
* IJavaProject 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 setRawClasspath, in particular such a classpath may
* contain classpath variable entries. Classpath variable entries can be
* resolved individually (see JavaCore#getClasspathVariable),
* or the full classpath can be resolved at once using the helper method
* getResolvedClasspath.
*
* 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. *
* Note that in case the project isn't yet opened, the classpath will * directly be read from the associated .classpath file. *
* * @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. *
* 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. *
* 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. *
* * @param ignoreUnresolvedEntry * indicates how to handle unresolvable variables and containers; *true 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; false
* indicates that a JavaModelException 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:
* ignoreUnresolvedEntry is
* false.true if the given element is on the classpath of
* this project, false 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 true if the given resource is on the classpath of
* this project, false 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 null
* @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 null
* @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.
*
* For a complete description of the configurable options, see
* JavaCore#getDefaultOptions.
*
String; value type:
* String), or null 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.
* * 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). *
* * @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: *PATH_OUTSIDE_PROJECT)
* RELATIVE_PATH)
* INVALID_PATH)
* JavaCore#getClasspathVariable), or the full classpath can
* be resolved at once using the helper method
* getResolvedClasspath.
* * 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. *
* Setting the classpath to null specifies a default
* classpath (the project root). Setting the classpath to an empty array
* specifies an empty classpath.
*
* 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
* hasClasspathCycle(IClasspathEntry[] entries) 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:
*
JavaConventions#validateClasspath
* JavaCore#getClasspathVariable), or the full classpath can
* be resolved at once using the helper method
* getResolvedClasspath.
* * 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. *
*
* Setting the classpath to null specifies a default
* classpath (the project root). Setting the classpath to an empty array
* specifies an empty classpath.
*
* 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
* hasClasspathCycle(IClasspathEntry[] entries) before
* setting the classpath.
*
CPE_PROJECT refers to
* this project (INVALID_PATH)
* PATH_OUTSIDE_PROJECT)
* RELATIVE_PATH)
* INVALID_PATH)
*