| /******************************************************************************* |
| * Copyright (c) 2005, 2007 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| |
| *******************************************************************************/ |
| package org.eclipse.dltk.core; |
| |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| |
| /** |
| * A script project represents a view of a project resource in terms of DLTK |
| * elements such as script folders, types, methods and fields. A project may |
| * contain several project fragments, which contain script folders. A project |
| * fragment corresponds to an underlying folder or an archive (like JAR). |
| * <p> |
| * Each script project has a buildpath, defining which folders contain source |
| * code and where required libraries are located. <s>Each script project also |
| * has an output location, defining where the builder writes output files.</s> A |
| * project that references folders in another project can access the folders by |
| * including the required project in a buildpath entry. The DLTK model will |
| * present the source elements in the required project; <s>when building, the |
| * compiler will use the corresponding generated class files from the required |
| * project's output location(s))</s>. The buildpath format is a sequence of |
| * buildpath entries describing the location and contents of project fragments . |
| * </p> |
| * Script project elements need to be opened before they can be navigated or |
| * manipulated. The children of a script project are the project fragments that |
| * are defined by the buildpath and contained in this project (in other words, |
| * it does not include project fragments for other projects). |
| * |
| * The children (i.e. the project fragments) appear in the order they are |
| * defined by the buildpath. </p> |
| * <p> |
| * An instance of one of these handles can be created via |
| * <code>DLTKCore.create(project)</code>. |
| * </p> |
| * |
| * @see DLTKCore#create(org.eclipse.core.resources.IProject) |
| * @see IBuildpathEntry |
| * @noimplement This interface is not intended to be implemented by clients. |
| */ |
| public interface IScriptProject extends IModelElement, IOpenable, IParent { |
| |
| /** |
| * Returns the <code>IProject</code> on which this |
| * <code>IScriptProject</code> was created. This is handle-only method. |
| * |
| * @return the <code>IProject</code> on which this |
| * <code>IScriptProject</code> was created |
| */ |
| IProject getProject(); |
| |
| /** |
| * Returns all of the project fragments contained in this project, |
| * identified on this project's resolved buildpath. The result does not |
| * include project fragments in other projects referenced on this project's |
| * buildpath. |
| * |
| * <p> |
| * NOTE: This is equivalent to <code>getChildren()</code>. |
| * |
| * @return all of the project fragments contained in this project, |
| * identified on this project's resolved buildpath |
| * @exception ModelException |
| * if this element does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| */ |
| IProjectFragment[] getProjectFragments() throws ModelException; |
| |
| /** |
| * Helper method for returning one option value only. Equivalent to |
| * <code>(String)this.getOptions(inheritDLTKCoreOptions).get(optionName)</code> |
| * Note that it may answer <code>null</code> if this option does not exist, |
| * or if there is no custom value for it. |
| * <p> |
| * For a complete description of the configurable options, see |
| * <code>DLTKCore#getDefaultOptions</code>. |
| * </p> |
| * |
| * @param optionName |
| * the name of an option |
| * @param inheritDLTKCoreOptions |
| * - boolean indicating whether DLTKCore options should be |
| * inherited as well |
| * @return the String value of a given option |
| * @see DLTKCore#getDefaultOptions() |
| */ |
| String getOption(String optionName, boolean inheritDLTKCoreOptions); |
| |
| /** |
| * 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 DLTKCore global options for the workspace. A |
| * boolean argument allows to directly merge the project options with global |
| * ones from <code>DLTKCore</code>. |
| * <p> |
| * For a complete description of the configurable options, see |
| * <code>DLTKCore#getDefaultOptions</code>. |
| * </p> |
| * |
| * @param inheritDLTKCoreOptions |
| * - boolean indicating whether DLTKCore options should be |
| * inherited as well |
| * @return table of current settings of all options (key type: |
| * <code>String</code>; value type: <code>String</code>) |
| * @see DLTKCore#getDefaultOptions() |
| * |
| */ |
| Map<String, String> getOptions(boolean inheritDLTKCoreOptions); |
| |
| /** |
| * Helper method for setting one option value only. Equivalent to |
| * |
| * <code>Map options = this.getOptions(false); map.put(optionName, optionValue); this.setOptions(map)</code> |
| * <p> |
| * For a complete description of the configurable options, see |
| * <code>DLTKCore#getDefaultOptions</code>. |
| * </p> |
| * |
| * @param optionName |
| * the name of an option |
| * @param optionValue |
| * the value of the option to set |
| * @see DLTKCore#getDefaultOptions() |
| * |
| */ |
| void setOption(String optionName, String optionValue); |
| |
| /** |
| * Sets the project custom options. All and only the options explicitly |
| * included in the given table are remembered; all previous option settings |
| * are forgotten, including ones not explicitly mentioned. |
| * <p> |
| * For a complete description of the configurable options, see |
| * <code>DLTKCore#getDefaultOptions</code>. |
| * </p> |
| * |
| * @param newOptions |
| * the new options (key type: <code>String</code>; value type: |
| * <code>String</code>), or <code>null</code> to flush all custom |
| * options (clients will automatically get the global DLTKCore |
| * options). |
| * @see DLTKCore#getDefaultOptions() |
| * |
| */ |
| void setOptions(Map newOptions); |
| |
| /** |
| * Returns a project fragment for the given resource, which must either be a |
| * folder representing the root of source folders, or <code>.zip</code> |
| * file. This is a handle-only method. The underlying resource may or may |
| * not exist. |
| * |
| * @param resource |
| * the given resource |
| * @return a project fragment for the given resource, which must either be a |
| * folder representing the top of source folders, or a |
| * <code>.zip</code> file |
| */ |
| IProjectFragment getProjectFragment(IResource resource); |
| |
| /** |
| * Returns a package fragment root for the ZIP at the specified file system |
| * path. This is a handle-only method. The underlying |
| * <code>java.io.File</code> may or may not exist. No resource is associated |
| * with this local ZIP package fragment root. |
| * |
| * @param zipPath |
| * the jars's file system path |
| * @return a package fragment root for the JAR at the specified file system |
| * path |
| */ |
| IProjectFragment getProjectFragment(String zipPath); |
| |
| /** |
| * Returns a project fragment for an external library or a source folder at |
| * the specified file system path. This is a handle-only method. The |
| * underlying <code>java.io.File</code> may or may not exist. No resource is |
| * associated with this local library package fragment root. |
| * |
| * @param path |
| * the library's file system path |
| * @return a package fragment root for the external library at the specified |
| * file system path |
| * @since 3.0 |
| */ |
| IProjectFragment getProjectFragment(IPath path); |
| |
| /** |
| * Sets the buildpath of this project using a list of buildpath entries. |
| * |
| * Setting the buildpath to <code>null</code> specifies a default buildpath |
| * (the project root). Setting the buildpath to an empty array specifies an |
| * empty buildpath. |
| * <p> |
| * If a cycle is detected while setting this buildpath, an error marker will |
| * be added to the project closing the cycle. To avoid this problem, use |
| * <code>hasBuildpathCycle(IBuildpathEntry[] entries)</code> before setting |
| * the buildpath. |
| * <p> |
| * This operation acquires a lock on the workspace's root. |
| * |
| * @param entries |
| * a list of buildpath entries |
| * @param monitor |
| * the given progress monitor |
| * @exception ModelException |
| * if the buildpath could not be set. Reasons include: |
| * <ul> |
| * <li> This model element does not exist |
| * (ELEMENT_DOES_NOT_EXIST)</li> <li> The buildpath is being |
| * modified during resource change event notification |
| * (CORE_EXCEPTION) <li> The buildpath failed the validation |
| * check |
| * </ul> |
| * @see IBuildpathEntry |
| */ |
| void setRawBuildpath(IBuildpathEntry[] entries, IProgressMonitor monitor) |
| throws ModelException; |
| |
| /** |
| * Returns true if this is valid DLTK Project. |
| * |
| */ |
| public boolean isValid(); |
| |
| /** |
| * Decodes the buildpath entry that has been encoded in the given string in |
| * the context of this project. Returns null if the encoded entry is |
| * malformed. |
| * |
| * @param encodedEntry |
| * the encoded buildpath entry |
| * @return the decoded buildpath entry, or <code>null</code> if unable to |
| * decode it |
| * |
| */ |
| IBuildpathEntry decodeBuildpathEntry(String encodedEntry); |
| |
| /** |
| * Encodes the given buildpath entry into a string in the context of this |
| * project. |
| * |
| * @param buildpathEntry |
| * the buildpath entry to encode |
| * @return the encoded buildpath entry |
| * |
| */ |
| public String encodeBuildpathEntry(IBuildpathEntry buildpathEntry); |
| |
| IBuildpathEntry[] getRawBuildpath() throws ModelException; |
| |
| /** |
| * This is a helper method returning the resolved buildpath for the project |
| * as a list of simple (non-variable, non-container) buildpath entries. All |
| * buildpath variable and buildpath container entries in the project's raw |
| * buildpath will be replaced by the simple buildpath entries they resolve |
| * to. |
| * <p> |
| * The resulting resolved buildpath is accurate for the given point in time. |
| * If the project's raw buildpath is later modified, or if buildpath |
| * variables are changed, the resolved buildpath can become out of date. |
| * Because of this, hanging on resolved buildpath is not recommended. |
| * </p> |
| * |
| * @param ignoreUnresolvedEntry |
| * indicates how to handle unresolvable variables and containers; |
| * <code>true</code> indicates that missing variables and |
| * unresolvable buildpath containers should be silently ignored, |
| * and that the resulting list should consist only of the entries |
| * that could be successfully resolved; <code>false</code> |
| * indicates that a <code>ModelException</code> should be thrown |
| * for the first unresolved variable or container |
| * @return the resolved buildpath for the project as a list of simple |
| * buildpath entries, where all buildpath variable and container |
| * entries have been resolved and substituted with their final |
| * target entries |
| * @exception ModelException |
| * in one of the corresponding situation: |
| * <ul> |
| * <li>this element does not exist</li> |
| * <li>an exception occurs while accessing its corresponding |
| * resource</li> |
| * <li>a buildpath variable or buildpath container was not |
| * resolvable and <code>ignoreUnresolvedEntry</code> is |
| * <code>false</code>.</li> |
| * </ul> |
| * @see IBuildpathEntry |
| */ |
| IBuildpathEntry[] getResolvedBuildpath(boolean ignoreUnresolvedEntry) |
| throws ModelException; |
| |
| /** |
| * Returns the <code>IModelElement</code> corresponding to the given |
| * buildpath-relative path, or <code>null</code> if no such |
| * <code>IModelElement</code> is found. The result is one of an |
| * <code>ISourceModule</code>, <code>IClassFile</code>, or |
| * <code>IScriptFolder</code>. |
| * <p> |
| * When looking for a package fragment, there might be several potential |
| * matches; only one of them is returned. |
| * |
| * <p> |
| * For example, the path "java/lang/Object.java", would result in the |
| * <code>ISourceModule</code> corresponding to "java.lang.Object". The path |
| * "java/lang" would result in the <code>IScriptFolder</code> for |
| * "java.lang". |
| * |
| * @param path |
| * the given buildpath-relative path |
| * @exception ModelException |
| * if the given path is <code>null</code> or absolute |
| * @return the <code>IModelElement</code> corresponding to the given |
| * buildpath-relative path, or <code>null</code> if no such |
| * <code>IModelElement</code> is found |
| */ |
| IModelElement findElement(IPath path) throws ModelException; |
| |
| /** |
| * Returns the <code>IModelElement</code> corresponding to the given |
| * buildpath-relative path, or <code>null</code> if no such |
| * <code>IModelElement</code> is found. The result is one of an |
| * <code>ISourceModule</code>, <code>IClassFile</code>, or |
| * <code>IScriptFolder</code>. If it is an <code>ISourceModule</code>, its |
| * owner is the given owner. |
| * <p> |
| * When looking for a package fragment, there might be several potential |
| * matches; only one of them is returned. |
| * |
| * <p> |
| * For example, the path "java/lang/Object.java", would result in the |
| * <code>ISourceModule</code> corresponding to "java.lang.Object". The path |
| * "java/lang" would result in the <code>IScriptFolder</code> for |
| * "java.lang". |
| * |
| * @param path |
| * the given buildpath-relative path |
| * @param owner |
| * the owner of the returned compilation unit, ignored if it is |
| * not a compilation unit. |
| * @exception ModelException |
| * if the given path is <code>null</code> or absolute |
| * @return the <code>IModelElement</code> corresponding to the given |
| * buildpath-relative path, or <code>null</code> if no such |
| * <code>IModelElement</code> is found |
| * |
| */ |
| IModelElement findElement(IPath path, WorkingCopyOwner owner) |
| throws ModelException; |
| |
| /** |
| * Returns the first existing package fragment on this project's buildpath |
| * whose path matches the given (absolute) path, or <code>null</code> if |
| * none exist. The path can be: - internal to the workbench: "/Project/src" |
| * - external to the workbench: "c:/jdk/classes.zip/java/lang" |
| * |
| * @param path |
| * the given absolute path |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first existing package fragment on this project's buildpath |
| * whose path matches the given (absolute) path, or |
| * <code>null</code> if none exist |
| */ |
| IScriptFolder findScriptFolder(IPath path) throws ModelException; |
| |
| /** |
| * Returns the existing package fragment root on this project's buildpath |
| * whose path matches the given (absolute) path, or <code>null</code> if one |
| * does not exist. The path can be: - internal to the workbench: |
| * "/Compiler/src" - external to the workbench: "c:/jdk/classes.zip" |
| * |
| * @param path |
| * the given absolute path |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the existing package fragment root on this project's buildpath |
| * whose path matches the given (absolute) path, or |
| * <code>null</code> if one does not exist |
| */ |
| IProjectFragment findProjectFragment(IPath path) throws ModelException; |
| |
| /** |
| * Returns the existing package fragment roots identified by the given |
| * entry. Note that a buildpath entry that refers to another project may |
| * have more than one root (if that project has more than on root containing |
| * source), and buildpath entries within the current project identify a |
| * single root. |
| * <p> |
| * If the buildpath entry denotes a variable, it will be resolved and return |
| * the roots of the target entry (empty if not resolvable). |
| * <p> |
| * If the buildpath 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 IBuildpathContainer |
| * |
| */ |
| IProjectFragment[] findProjectFragments(IBuildpathEntry entry); |
| |
| /** |
| * Returns the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found. The |
| * fully qualified name is a dot-separated name. For example, a class B |
| * defined as a member type of a class A in package x.y should have a the |
| * fully qualified name "x.y.A.B". |
| * |
| * Note that in order to be found, a type name (or its toplevel enclosing |
| * type name) must match its corresponding compilation unit name. As a |
| * consequence, secondary types cannot be found using this functionality. To |
| * find secondary types use {@link #findType(String, IProgressMonitor)} |
| * instead. |
| * |
| * @param fullyQualifiedName |
| * the given fully qualified name |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found |
| * @see IType#getFullyQualifiedName(char) |
| * |
| */ |
| IType findType(String fullyQualifiedName) throws ModelException; |
| |
| /** |
| * Same functionality as {@link #findType(String)} but also look for |
| * secondary types if given name does not match a compilation unit name. |
| * |
| * @param fullyQualifiedName |
| * the given fully qualified name |
| * @param progressMonitor |
| * the progress monitor to report progress to, or |
| * <code>null</code> if no progress monitor is provided |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found |
| * @see IType#getFullyQualifiedName(char) |
| * |
| */ |
| IType findType(String fullyQualifiedName, IProgressMonitor progressMonitor) |
| throws ModelException; |
| |
| /** |
| * Returns the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found. The |
| * fully qualified name is a dot-separated name. For example, a class B |
| * defined as a member type of a class A in package x.y should have a the |
| * fully qualified name "x.y.A.B". If the returned type is part of a |
| * compilation unit, its owner is the given owner. |
| * |
| * 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. To |
| * find secondary types use |
| * {@link #findType(String, WorkingCopyOwner, IProgressMonitor)} instead. |
| * |
| * @param fullyQualifiedName |
| * the given fully qualified name |
| * @param owner |
| * the owner of the returned type's compilation unit |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found |
| * @see IType#getFullyQualifiedName(char) |
| * |
| */ |
| IType findType(String fullyQualifiedName, WorkingCopyOwner owner) |
| throws ModelException; |
| |
| /** |
| * Same functionality as {@link #findType(String, WorkingCopyOwner)} but |
| * also look for secondary types if given name does not match a compilation |
| * unit name. |
| * |
| * @param fullyQualifiedName |
| * the given fully qualified name |
| * @param owner |
| * the owner of the returned type's compilation unit |
| * @param progressMonitor |
| * the progress monitor to report progress to, or |
| * <code>null</code> if no progress monitor is provided |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found |
| * @see IType#getFullyQualifiedName(char) |
| * |
| */ |
| IType findType(String fullyQualifiedName, WorkingCopyOwner owner, |
| IProgressMonitor progressMonitor) throws ModelException; |
| |
| /** |
| * Returns the first type found following this project's buildpath with the |
| * given package name and type qualified name or <code>null</code> if none |
| * is found. The package name is a dot-separated name. The type qualified |
| * name is also a dot-separated name. For example, a class B defined as a |
| * member type of a class A should have the type qualified name "A.B". |
| * |
| * Note that in order to be found, a type name (or its toplevel enclosing |
| * type name) must match its corresponding compilation unit name. As a |
| * consequence, secondary types cannot be found using this functionality. To |
| * find secondary types use |
| * {@link #findType(String, String, IProgressMonitor)} instead. |
| * |
| * @param packageName |
| * the given package name |
| * @param typeQualifiedName |
| * the given type qualified name |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given package name and type qualified name or <code>null</code> |
| * if none is found |
| * @see IType#getTypeQualifiedName(char) |
| * |
| */ |
| IType findType(String packageName, String typeQualifiedName) |
| throws ModelException; |
| |
| /** |
| * Same functionality as {@link #findType(String, String)} but also look for |
| * secondary types if given name does not match a compilation unit name. |
| * |
| * @param packageName |
| * the given package name |
| * @param typeQualifiedName |
| * the given type qualified name |
| * @param progressMonitor |
| * the progress monitor to report progress to, or |
| * <code>null</code> if no progress monitor is provided |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found |
| * @see IType#getFullyQualifiedName(char) |
| * |
| */ |
| IType findType(String packageName, String typeQualifiedName, |
| IProgressMonitor progressMonitor) throws ModelException; |
| |
| /** |
| * Returns the first type found following this project's buildpath with the |
| * given package name and type qualified name or <code>null</code> if none |
| * is found. The package name is a dot-separated name. The type qualified |
| * name is also a dot-separated name. For example, a class B defined as a |
| * member type of a class A should have the type qualified name "A.B". If |
| * the returned type is part of a compilation unit, its owner is the given |
| * owner. |
| * |
| * 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. To |
| * find secondary types use |
| * {@link #findType(String, String, WorkingCopyOwner, IProgressMonitor)} |
| * instead. |
| * |
| * @param packageName |
| * the given package name |
| * @param typeQualifiedName |
| * the given type qualified name |
| * @param owner |
| * the owner of the returned type's compilation unit |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given package name and type qualified name or <code>null</code> |
| * if none is found |
| * @see IType#getTypeQualifiedName(char) |
| * |
| */ |
| IType findType(String packageName, String typeQualifiedName, |
| WorkingCopyOwner owner) throws ModelException; |
| |
| /** |
| * Same functionality as {@link #findType(String, String, WorkingCopyOwner)} |
| * but also look for secondary types if given name does not match a |
| * compilation unit name. |
| * |
| * @param packageName |
| * the given package name |
| * @param typeQualifiedName |
| * the given type qualified name |
| * @param owner |
| * the owner of the returned type's compilation unit |
| * @param progressMonitor |
| * the progress monitor to report progress to, or |
| * <code>null</code> if no progress monitor is provided |
| * @exception ModelException |
| * if this project does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @return the first type found following this project's buildpath with the |
| * given fully qualified name or <code>null</code> if none is found |
| * @see IType#getFullyQualifiedName(char) |
| * |
| */ |
| IType findType(String packageName, String typeQualifiedName, |
| WorkingCopyOwner owner, IProgressMonitor progressMonitor) |
| throws ModelException; |
| |
| /** |
| * Returns the raw buildpath for the project as defined by its |
| * <code>.buildpath</code> file from disk, or <code>null</code> if unable to |
| * read the file. |
| * <p> |
| * This buildpath may differ from the in-memory buildpath returned by |
| * <code>getRawBuildpath</code>, in case the automatic reconciliation |
| * mechanism has not been performed yet. Usually, any change to the |
| * <code>.buildpath</code> file is automatically noticed and reconciled at |
| * the next resource change notification event. However, if the file is |
| * modified within an operation, where this change needs to be taken into |
| * account before the operation ends, then the buildpath from disk can be |
| * read using this method, and further assigned to the project using |
| * <code>setRawBuildpath(...)</code>. |
| * </p> |
| * <p> |
| * Buildpath variable and buildpath container entries can be resolved using |
| * the helper method <code>getResolvedBuildpath</code>; buildpath variable |
| * entries also can be resolved individually using |
| * <code>DLTKCore#getBuildpathVariable</code>). |
| * </p> |
| * <p> |
| * Note that no check is performed whether the project has the script nature |
| * set, allowing an existing <code>.buildpath</code> file to be considered |
| * independantly (unlike <code>getRawBuildpath</code> which requires the |
| * script nature to be associated with the project). |
| * </p> |
| * <p> |
| * In order to manually force a project buildpath refresh, one can simply |
| * assign the project buildpath using the result of this method, as follows: |
| * |
| * <code>proj.setRawBuildpath(proj.readRawBuildpath(), proj.readOutputLocation(), monitor)</code> |
| * (note that the <code>readRawBuildpath/readOutputLocation</code> methods |
| * could return <code>null</code>). |
| * </p> |
| * |
| * @return the raw buildpath from disk for the project, as a list of |
| * buildpath entries |
| * @see #getRawBuildpath() |
| * @see IBuildpathEntry |
| * |
| */ |
| IBuildpathEntry[] readRawBuildpath(); |
| |
| /** |
| * Returns all of the existing project fragments that exist on the |
| * buildpath, in the order they are defined by the buildpath. |
| * |
| * @return all of the existing project fragments that exist on the buildpath |
| * @exception ModelException |
| * if this element does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| */ |
| IProjectFragment[] getAllProjectFragments() throws ModelException; |
| |
| public Object[] getForeignResources() throws ModelException; |
| |
| /** |
| * Returns whether the given element is on the buildpath of this project, |
| * that is, referenced from a buildpath entry and not explicitly excluded |
| * using an exclusion pattern. |
| * |
| * @param element |
| * the given element |
| * @return <code>true</code> if the given element is on the buildpath of |
| * this project, <code>false</code> otherwise |
| * @see IBuildpathEntry#getInclusionPatterns() |
| * @see IBuildpathEntry#getExclusionPatterns() |
| * |
| */ |
| boolean isOnBuildpath(IModelElement element); |
| |
| /** |
| * Returns whether the given resource is on the buildpath of this project, |
| * that is, referenced from a buildpath entry and not explicitly excluded |
| * using an exclusion pattern. |
| * |
| * @param resource |
| * the given resource |
| * @return <code>true</code> if the given resource is on the buildpath of |
| * this project, <code>false</code> otherwise |
| * @see IBuildpathEntry#getInclusionPatterns() |
| * @see IBuildpathEntry#getExclusionPatterns() |
| * |
| */ |
| boolean isOnBuildpath(IResource resource); |
| |
| /** |
| * Creates and returns a type hierarchy for all types in the given region, |
| * considering subtypes within that region. |
| * |
| * @param monitor |
| * the given progress monitor |
| * @param region |
| * the given region |
| * @exception JavaModelException |
| * if this element does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @exception IllegalArgumentException |
| * if region is <code>null</code> |
| * @return a type hierarchy for all types in the given region, considering |
| * subtypes within that region |
| */ |
| ITypeHierarchy newTypeHierarchy(IRegion region, IProgressMonitor monitor) |
| throws ModelException; |
| |
| /** |
| * Creates and returns a type hierarchy for all types in the given region, |
| * considering subtypes within that region and considering types in the |
| * working copies with the given owner. In other words, the owner's working |
| * copies will take precedence over their original compilation units in the |
| * workspace. |
| * <p> |
| * Note that if a working copy is empty, it will be as if the original |
| * compilation unit had been deleted. |
| * <p> |
| * |
| * @param monitor |
| * the given progress monitor |
| * @param region |
| * the given region |
| * @param owner |
| * the owner of working copies that take precedence over their |
| * original compilation units |
| * @exception JavaModelException |
| * if this element does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * @exception IllegalArgumentException |
| * if region is <code>null</code> |
| * @return a type hierarchy for all types in the given region, considering |
| * subtypes within that region |
| * @since 3.0 |
| */ |
| ITypeHierarchy newTypeHierarchy(IRegion region, WorkingCopyOwner owner, |
| IProgressMonitor monitor) throws ModelException; |
| |
| /** |
| * Creates and returns a type hierarchy for the given type considering |
| * subtypes in the specified region. |
| * |
| * @param type |
| * the given type |
| * @param region |
| * the given region |
| * @param monitor |
| * the given monitor |
| * |
| * @exception JavaModelException |
| * if this element does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * |
| * @exception IllegalArgumentException |
| * if type or region is <code>null</code> |
| * @return a type hierarchy for the given type considering subtypes in the |
| * specified region |
| */ |
| ITypeHierarchy newTypeHierarchy(IType type, IRegion region, |
| IProgressMonitor monitor) throws ModelException; |
| |
| /** |
| * Creates and returns a type hierarchy for the given type considering |
| * subtypes in the specified region and considering types in the working |
| * copies with the given owner. In other words, the owner's working copies |
| * will take precedence over their original compilation units in the |
| * workspace. |
| * <p> |
| * Note that if a working copy is empty, it will be as if the original |
| * compilation unit had been deleted. |
| * <p> |
| * |
| * @param type |
| * the given type |
| * @param region |
| * the given region |
| * @param monitor |
| * the given monitor |
| * @param owner |
| * the owner of working copies that take precedence over their |
| * original compilation units |
| * |
| * @exception JavaModelException |
| * if this element does not exist or if an exception occurs |
| * while accessing its corresponding resource |
| * |
| * @exception IllegalArgumentException |
| * if type or region is <code>null</code> |
| * @return a type hierarchy for the given type considering subtypes in the |
| * specified region |
| * @since 3.0 |
| */ |
| ITypeHierarchy newTypeHierarchy(IType type, IRegion region, |
| WorkingCopyOwner owner, IProgressMonitor monitor) |
| throws ModelException; |
| |
| public IScriptFolder[] getScriptFolders() throws ModelException; |
| |
| public IDLTKLanguageToolkit getLanguageToolkit(); |
| } |
