X-Git-Url: http://git.phpeclipse.com diff --git a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/IJavaProject.java b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/IJavaProject.java index 31ef9a2..4819bc7 100644 --- a/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/IJavaProject.java +++ b/net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/core/IJavaProject.java @@ -21,34 +21,33 @@ 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. + * 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. *
- * 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.
+ * 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)
.
+ * 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
+ * classpath-relative path, or null
if no such
* IJavaElement
is found. The result is one of an
* ICompilationUnit
, IClassFile
, or
- * IPackageFragment
.
+ * 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
+ *
+ *
+ * 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
+ * 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
+ * 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
+ * whose path matches the given (absolute) path, or
+ * null
if none exist
*/
-// IPackageFragment findPackageFragment(IPath path) throws JavaModelException;
-
+ // 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
+ * 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
+ * whose path matches the given (absolute) path, or
+ * null
if one does not exist
*/
IPackageFragmentRoot findPackageFragmentRoot(IPath path)
- throws JavaModelException;
+ 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.
+ * 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).
+ * 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
+ * @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".
+ * 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
+ * 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
+ * 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;
+ // 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".
+ * 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
+ * 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
+ * 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;
-
+ // 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
+ * 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;
+ 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.
+ * 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 + * 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 + * @exception JavaModelException + * if this element does not exist or if an exception occurs + * while accessing its corresponding resource */ -// Object[] getNonJavaResources() throws JavaModelException; - + // 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.
+ * 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
.
+ * For a complete description of the configurable options, see
+ * JavaCore#getDefaultOptions
.
*
JavaCore
.
+ * 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 JavaCore
.
*
- * For a complete description of the configurable options, see JavaCore#getDefaultOptions
.
+ * For a complete description of the configurable options, see
+ * JavaCore#getDefaultOptions
.
*
String
; value type: String
)
+ * @param inheritJavaCoreOptions -
+ * boolean indicating whether JavaCore options should be
+ * inherited as well
+ * @return table of current settings of all options (key type:
+ * String
; value type: String
)
* @see JavaCore#getDefaultOptions
* @since 2.1
*/
- Map getOptions(boolean inheritJavaCoreOptions);
+ Map getOptions(boolean inheritJavaCoreOptions);
/**
* Returns the default output location for this project as a workspace-
@@ -248,72 +273,79 @@ public interface IJavaProject extends IParent, IJavaElement, IOpenable {
* 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).
+ * 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
+ * @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.
+ * 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
+ * @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);
-
+ // 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
+ * 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
+ * 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.
+ * 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).
+ * 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
+ * @param entry
+ * the given entry
* @return the existing package fragment roots identified by the given entry
* @see IClasspathContainer
* @deprecated Use IJavaProject#findPackageFragmentRoots instead
@@ -321,44 +353,52 @@ public interface IJavaProject extends IParent, IJavaElement, IOpenable {
IPackageFragmentRoot[] getPackageFragmentRoots(IClasspathEntry entry);
/**
- * Returns all package fragments in all package fragment roots contained
- * in this project. This is a convenience method.
- *
+ * 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
+ *
+ * @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.
+ * Returns the IProject
on which this
+ * IJavaProject
was created. This is handle-only method.
*
- * @return the IProject
on which this IJavaProject
- * was created
+ * @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
.
+ * 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. + * 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 + * @exception JavaModelException + * if this element does not exist or if an exception occurs + * while accessing its corresponding resource * @see IClasspathEntry */ IClasspathEntry[] getRawClasspath() throws JavaModelException; @@ -368,20 +408,21 @@ public interface IJavaProject extends IParent, IJavaElement, IOpenable { * 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 + * 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. + * 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 @@ -389,122 +430,145 @@ public interface IJavaProject extends IParent, IJavaElement, IOpenable { * 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
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
+ * this project, false
otherwise
* @see IClasspathEntry#getExclusionPatterns
* @since 2.0
*/
-// boolean isOnClasspath(IJavaElement element);
+ // 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
+ * @param element
+ * the given element
* @return true
if the given resource is on the classpath of
- * this project, false
otherwise
+ * this project, false
otherwise
* @see IClasspathEntry#getExclusionPatterns
* @since 2.1
*/
-// boolean isOnClasspath(IResource resource);
-
+ // boolean isOnClasspath(IResource resource);
/**
* Creates a new evaluation context.
+ *
* @return a new evaluation context.
*/
-// IEvaluationContext newEvaluationContext();
-
+ // 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
+ * 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;
-
+ // 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
+ * @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 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
+ * @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;
-
+ // 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.
+ * 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
.
+ * 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).
+ * @param newOptions
+ * the new options (key type: 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
*/
@@ -525,62 +589,80 @@ public interface IJavaProject extends IParent, IJavaElement, IOpenable {
* 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
)
- * PATH_OUTSIDE_PROJECT
)
+ * RELATIVE_PATH
)
+ * INVALID_PATH
)
+ * JavaCore#getClasspathVariable
),
- * or the full classpath can be resolved at once using the helper method getResolvedClasspath
.
+ * 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. + * 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.
+ * 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
- * 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
+ * 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 @@ -590,35 +672,45 @@ public interface IJavaProject extends IParent, IJavaElement, IOpenable { * 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.
+ * 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.
+ * hasClasspathCycle(IClasspathEntry[] entries)
before
+ * setting the classpath.
*
CPE_PROJECT
refers to this project (INVALID_PATH)
- * PATH_OUTSIDE_PROJECT
)
- * RELATIVE_PATH
)
- * INVALID_PATH
)
- * CPE_PROJECT
refers to
+ * this project (INVALID_PATH)
+ * PATH_OUTSIDE_PROJECT
)
+ * RELATIVE_PATH
)
+ * INVALID_PATH
)
+ *