.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, and when building, the compiler will
- * use the binaries from that project (that is, the output location of the
- * required project is used as a library). The classpath format is a sequence
- * of classpath entries describing the location and contents of package fragment
- * roots.
+ * 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.
*
* 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
@@ -49,454 +54,571 @@ import org.eclipse.core.runtime.IProgressMonitor;
*/
public interface IJavaProject extends IParent, IJavaElement, IOpenable {
- /**
- * Returns the 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 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 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)
- /**
- * 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 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".
- *
- * @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".
- *
- * @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;
+ * @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 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.
- * @return an array of non-Java resources directly contained in this project
- */
- Object[] getNonJavaResources() 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; - /** - * Returns the full path to the location where the builder writes - *.class files.
- *
- * @exception JavaModelException if this element does not exist or if an
- * exception occurs while accessing its corresponding resource
- * @return the full path to the location where the builder writes
- * .class files
- */
- IPath getOutputLocation() 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 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 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 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 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 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 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 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 - */ - // IPackageFragmentRoot[] getPackageFragmentRoots(IClasspathEntry entry); + /** + * 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 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 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 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 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;
- /**
- * This is a helper method returning the resolved 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.
- *
- * A resolved classpath corresponds to a particular instance of the raw classpath bound in the context of - * the current values of the referred variables, and thus should not be persisted. - *
- * 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. - *
- * The boolean argument ignoreUnresolvedVariable allows to specify how to handle unresolvable variables,
- * when set to true, missing variables are simply ignored, the resulting path is then only formed of the
- * resolvable entries, without any indication about which variable(s) was ignored. When set to false, a
- * JavaModelException will be thrown for the first unresolved variable (from left to right).
- *
- * @exception JavaModelException in one of the corresponding situation:
- *
ignoreUnresolvedVariable was set to false. 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 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. - * - * @return the names of the projects that are directly required by this - * project - * @exception JavaModelException if this element does not exist or if an - * exception occurs while accessing its corresponding resource - */ - String[] getRequiredProjectNames() 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 classpath entries, - * where all classpath variable entries have been resolved and substituted with their final target entries. - *
- * A resolved classpath corresponds to a particular instance of the raw classpath bound in the context of - * the current values of the referred variables, and thus should not be persisted. - *
- * 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. - *
- * The boolean argument ignoreUnresolvedVariable allows to specify how to handle unresolvable variables,
- * when set to true, missing variables are simply ignored, the resulting path is then only formed of the
- * resolvable entries, without any indication about which variable(s) was ignored. When set to false, a
- * JavaModelException will be thrown for the first unresolved variable (from left to right).
- *
- * @param ignoreUnresolvedVariable specify how to handle unresolvable variables
- * @return the resolved 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
- * @exception JavaModelException in one of the corresponding situation:
- *
ignoreUnresolvedVariable was set to false. + * 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 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 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;
+ /**
+ * 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 output location of this project to the location
- * described by the given absolute path.
- * - * - * @param path the given absolute path - * @param monitor the given progress monitor - * - * @exception JavaModelException if the classpath could not be set. Reasons include: - *
PATH_OUTSIDE_PROJECT)
- * RELATIVE_PATH)
- * INVALID_PATH)
- *
+ * 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 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 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
- * + * 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
- * @param outputLocation the given output location
- *
- * @exception JavaModelException if the classpath could not be set. Reasons include:
- *
CPE_PROJECT refers to this project (INVALID_PATH)
- * 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)
+ *