Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.eclipse.core.resources
Interface IWorkspace

All Superinterfaces:
  IAdaptable

public interface IWorkspace
extends IAdaptable

Workspaces are the basis for Eclipse Platform resource management. There is only one workspace per running platform. All resources exist in the context of this workspace.

A workspace corresponds closely to discreet areas in the local file system. Each project in a workspace maps onto a specific area of the file system. The folders and files within a project map directly onto the corresponding directories and files in the file system. One subdirectory, the workspace metadata area, contains internal information about the workspace and its resources. This metadata area should be accessed only by the Platform or via Platform API calls.

Workspaces add value over using the file system directly in that they allow for comprehensive change tracking (through `IResourceDelta` s), various forms of resource metadata (e.g., markers and properties) as well as support for managing application/tool state (e.g., saving and restoring).

The workspace as a whole is thread safe and allows one writer concurrent with multiple readers. It also supports mechanisms for saving and snapshooting the current resource state.

The workspace is provided by the Resources plug-in and is automatically created when that plug-in is activated. The default workspace data area (i.e., where its resources are stored) overlap exactly with the platform's data area. That is, by default, the workspace's projects are found directly in the platform's data area. Individual project locations can be specified explicitly.

This interface is not intended to be implemented by clients.

Workspaces implement the `IAdaptable` interface; extensions are managed by the platform's adapter manager.

Nested Class Summary
`static class` | `IWorkspace.ProjectOrder` Data structure for holding the multi-part outcome of `IWorkspace.computeProjectOrder`.

Field Summary
`static int` | `AVOID_UPDATE` flag constant (bit mask value 1) indicating that resource change notifications should be avoided during the invocation of a compound resource changing operation.

Method Summary
`void` | `addResourceChangeListener(IResourceChangeListener listener)` Adds the given listener for resource change events to this workspace.
`void` | `addResourceChangeListener(IResourceChangeListener listener, int eventMask)` Adds the given listener for the specified resource change events to this workspace.
`ISavedState` | `addSaveParticipant(Plugin plugin, ISaveParticipant participant)` Registers the given plug-in's workspace save participant, and returns an object describing the workspace state at the time of the last save in which the plug-in participated.
`void` | `build(int kind, IProgressMonitor monitor)` Builds all projects in this workspace.
`void` | `checkpoint(boolean build)` Checkpoints the operation currently in progress.
`IProject[][]` | `computePrerequisiteOrder(IProject[] projects)` Deprecated. Replaced by `IWorkspace.computeProjectOrder`, which produces a more usable result when there are cycles in project reference graph.
`IWorkspace.ProjectOrder` | `computeProjectOrder(IProject[] projects)` Computes a total ordering of the given projects based on both static and dynamic project references.
`IStatus` | `copy(IResource[] resources, IPath destination, boolean force, IProgressMonitor monitor)` Copies the given sibling resources so that they are located as members of the resource at the given path; the names of the copies are the same as the corresponding originals.
`IStatus` | `copy(IResource[] resources, IPath destination, int updateFlags, IProgressMonitor monitor)` Copies the given sibling resources so that they are located as members of the resource at the given path; the names of the copies are the same as the corresponding originals.
`IStatus` | `delete(IResource[] resources, boolean force, IProgressMonitor monitor)` Deletes the given resources.
`IStatus` | `delete(IResource[] resources, int updateFlags, IProgressMonitor monitor)` Deletes the given resources.
`void` | `deleteMarkers(IMarker[] markers)` Removes the given markers from the resources with which they are associated.
`void` | `forgetSavedTree(String pluginId)` Forgets any resource tree being saved for the plug-in with the given name.
`Map` | `getDanglingReferences()` Finds all dangling project references in this workspace.
`IWorkspaceDescription` | `getDescription()` Returns the workspace description.
`IProjectNatureDescriptor` | `getNatureDescriptor(String natureId)` Returns the nature descriptor with the given unique identifier, or `null` if there is no such nature.
`IProjectNatureDescriptor[]` | `getNatureDescriptors()` Returns all nature descriptors known to this workspace.
`IPathVariableManager` | `getPathVariableManager()` Returns the path variable manager for this workspace.
`IWorkspaceRoot` | `getRoot()` Returns the root resource of this workspace.
`IResourceRuleFactory` | `getRuleFactory()` Returns a factory for obtaining scheduling rules prior to modifying resources in the workspace.
`ISynchronizer` | `getSynchronizer()` Returns the synchronizer for this workspace.
`boolean` | `isAutoBuilding()` Returns whether this workspace performs auto-builds.
`boolean` | `isTreeLocked()` Returns whether the workspace tree is currently locked.
`IProjectDescription` | `loadProjectDescription(IPath projectDescriptionFile)` Reads the project description file (".project") from the given location in the local file system.
`IStatus` | `move(IResource[] resources, IPath destination, boolean force, IProgressMonitor monitor)` Moves the given sibling resources so that they are located as members of the resource at the given path; the names of the new members are the same.
`IStatus` | `move(IResource[] resources, IPath destination, int updateFlags, IProgressMonitor monitor)` Moves the given sibling resources so that they are located as members of the resource at the given path; the names of the new members are the same.
`IProjectDescription` | `newProjectDescription(String projectName)` Creates and returns a new project description for a project with the given name.
`void` | `removeResourceChangeListener(IResourceChangeListener listener)` Removes the given resource change listener from this workspace.
`void` | `removeSaveParticipant(Plugin plugin)` Removes the workspace save participant for the given plug-in from this workspace.
`void` | `run(IWorkspaceRunnable action, IProgressMonitor monitor)` Runs the given action as an atomic workspace operation.
`void` | `run(IWorkspaceRunnable action, ISchedulingRule rule, int flags, IProgressMonitor monitor)` Runs the given action as an atomic workspace operation.
`IStatus` | `save(boolean full, IProgressMonitor monitor)` Saves this workspace's valuable state on disk.
`void` | `setDescription(IWorkspaceDescription description)` Sets the workspace description.
`void` | `setWorkspaceLock(WorkspaceLock lock)` Deprecated. it is no longer possible to override the workspace lock behavior. This functionality is now provided in the platform API by implementing the org.eclipse.core.runtime.jobs.ILockListener interface.
`String[]` | `sortNatureSet(String[] natureIds)` Returns a copy of the given set of natures sorted in prerequisite order.
`IStatus` | `validateEdit(IFile[] files, Object context)` Advises that the caller intends to modify the contents of the given files in the near future and asks whether modifying all these files would be reasonable.
`IStatus` | `validateLinkLocation(IResource resource, IPath location)` Validates the given path as the location of the given resource on disk.
`IStatus` | `validateName(String segment, int typeMask)` Validates the given string as the name of a resource valid for one of the given types.
`IStatus` | `validateNatureSet(String[] natureIds)` Validates that each of the given natures exists, and that all nature constraints are satisfied within the given set.
`IStatus` | `validatePath(String path, int typeMask)` Validates the given string as a path for a resource of the given type(s).
`IStatus` | `validateProjectLocation(IProject project, IPath location)` Validates the given path as the location of the given project on disk.

Methods inherited from interface org.eclipse.core.runtime.IAdaptable
`getAdapter`

Field Detail

### AVOID_UPDATE

    public static final int AVOID_UPDATE

  flag constant (bit mask value 1) indicating that resource change notifications should be avoided during the invocation of a compound resource changing operation.

  Since:
    3.0
  See Also:
    `run(IWorkspaceRunnable, IProgressMonitor)`, Constant Field Values

Method Detail

### addResourceChangeListener

    public void addResourceChangeListener(IResourceChangeListener listener)

  Adds the given listener for resource change events to this workspace. Has no effect if an identical listener is already registered.

  This method is equivalent to:

       addResourceChangeListener(listener, IResourceChangeEvent.PRE_CLOSE | IResourceChangeEvent.PRE_DELETE | IResourceChangeEvent.POST_CHANGE);

  Parameters:
    `listener` - the listener
  See Also:
    `IResourceChangeListener`, `IResourceChangeEvent`, `addResourceChangeListener(IResourceChangeListener, int)`, `removeResourceChangeListener(IResourceChangeListener)`

### addResourceChangeListener

    public void addResourceChangeListener(IResourceChangeListener listener,
                                          int eventMask)

  Adds the given listener for the specified resource change events to this workspace. Has no effect if an identical listener is already registered for these events. After completion of this method, the given listener will be registered for exactly the specified events. If they were previously registered for other events, they will be deregistered.

  Once registered, a listener starts receiving notification of changes to resources in the workspace. The resource deltas in the resource change event are rooted at the workspace root. Most resource change notifications occur well after the fact; the exception is pre-notification of impending project closures and deletions. The listener continues to receive notifications until it is replaced or removed.

  Listeners can listen for several types of event as defined in `IResourceChangeEvent`. Clients are free to register for any number of event types however if they register for more than one, it is their responsibility to ensure they correctly handle the case where the same resource change shows up in multiple notifications. Clients are guaranteed to receive only the events for which they are registered.

  Parameters:
    `listener` - the listener
    `eventMask` - the bit-wise OR of all event types of interest to the listener
  See Also:
    `IResourceChangeListener`, `IResourceChangeEvent`, `removeResourceChangeListener(IResourceChangeListener)`

### addSaveParticipant

    public ISavedState addSaveParticipant(Plugin plugin,
                                          ISaveParticipant participant)
                                   throws CoreException

  Registers the given plug-in's workspace save participant, and returns an object describing the workspace state at the time of the last save in which the plug-in participated.

  Once registered, the workspace save participant will actively participate in the saving of this workspace.

  Parameters:
    `plugin` - the plug-in
    `participant` - the participant
  Returns:
    the last saved state in which the plug-in participated, or `null` if the plug-in has not participated before
  Throws:
    `CoreException` - if the method fails to add the participant. Reasons include:
    - The previous state could not be recovered.
  See Also:
    `ISaveParticipant`, `removeSaveParticipant(Plugin)`

### build

    public void build(int kind,
                      IProgressMonitor monitor)
               throws CoreException

  Builds all projects in this workspace. Projects are built in the order specified in this workspace's description. Projects not mentioned in the order or for which the order cannot be determined are built in an undefined order after all other projects have been built. If no order is specified, the workspace computes an order determined by project references.

  This method may change resources; these changes will be reported in a subsequent resource change event.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `kind` - the kind of build being requested. Valid values are
    - `FULL_BUILD`- indicates a full build.
    - `INCREMENTAL_BUILD`- indicates a incremental build.
    - `CLEAN_BUILD`- indicates a clean request. Clean does not actually build anything, but rather discards all problems and build states.
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Throws:
    `CoreException` - if some of the builds fail. The status contained in the exception is a multi-status with entries for the project builds that failed.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  See Also:
    `IProject.build(int, IProgressMonitor)`, `computeProjectOrder(IProject[])`, `IncrementalProjectBuilder.FULL_BUILD`, `IncrementalProjectBuilder.INCREMENTAL_BUILD`, `IncrementalProjectBuilder.CLEAN_BUILD`, `IResourceRuleFactory.buildRule()`

### checkpoint

    public void checkpoint(boolean build)

  Checkpoints the operation currently in progress. This method is used in the middle of a group of operations to force a background auto-build (if the build argument is true) and send an interim notification of resource change events.

  When invoked in the dynamic scope of a call to the `IWorkspace.run` method, this method reports a single resource change event describing the net effect of all changes done to resources since the last round of notifications. When the outermost `run` method eventually completes, it will do another auto-build (if enabled) and report the resource changes made after this call.

  This method has no effect if invoked outside the dynamic scope of a call to the `IWorkspace.run` method.

  This method should be used under controlled circumstance (e.g., to break up extremely long-running operations).

  Parameters:
    `build` - whether or not to run a build
  See Also:
    `run(IWorkspaceRunnable, ISchedulingRule, int, IProgressMonitor)`

### computePrerequisiteOrder

    public IProject[][] computePrerequisiteOrder(IProject[] projects)

  Deprecated. Replaced by `IWorkspace.computeProjectOrder`, which produces a more usable result when there are cycles in project reference graph.

  Returns the prerequisite ordering of the given projects. The computation is done by interpreting project references as dependency relationships. For example if A references B and C, and C references B, this method, given the list A, B, C will return the order B, C, A. That is, projects with no dependencies are listed first.

  The return value is a two element array of project arrays. The first project array is the list of projects which could be sorted (as outlined above). The second element of the return value is an array of the projects which are ambiguously ordered (e.g., they are part of a cycle).

  Cycles and ambiguities are handled by elimination. Projects involved in cycles are simply cut out of the ordered list and returned in an undefined order. Closed and non-existent projects are ignored and do not appear in the returned value at all.

  Parameters:
    `projects` - the projects to order
  Returns:
    the projects in sorted order and a list of projects which could not be ordered

### computeProjectOrder

    public IWorkspace.ProjectOrder computeProjectOrder(IProject[] projects)

  Computes a total ordering of the given projects based on both static and dynamic project references. If an existing and open project P references another existing and open project Q also included in the list, then Q should come before P in the resulting ordering. Closed and non-existent projects are ignored, and will not appear in the result. References to non-existent or closed projects are also ignored, as are any self-references. The total ordering is always consistent with the global total ordering of all open projects in the workspace.

  When there are choices, the choice is made in a reasonably stable way. For example, given an arbitrary choice between two projects, the one with the lower collating project name is usually selected.

  When the project reference graph contains cyclic references, it is impossible to honor all of the relationships. In this case, the result ignores as few relationships as possible. For example, if P2 references P1, P4 references P3, and P2 and P3 reference each other, then exactly one of the relationships between P2 and P3 will have to be ignored. The outcome will be either [P1, P2, P3, P4] or [P1, P3, P2, P4]. The result also contains complete details of any cycles present.

  This method is time-consuming and should not be called unnecessarily. There are a very limited set of changes to a workspace that could affect the outcome: creating, renaming, or deleting a project; opening or closing a project; adding or removing a project reference.

  Parameters:
    `projects` - the projects to order
  Returns:
    result describing the project order
  Since:
    2.1

### copy

    public IStatus copy(IResource[] resources,
                        IPath destination,
                        boolean force,
                        IProgressMonitor monitor)
                 throws CoreException

  Copies the given sibling resources so that they are located as members of the resource at the given path; the names of the copies are the same as the corresponding originals.

  This is a convenience method, fully equivalent to:

       copy(resources, destination, (force ? IResource.FORCE : IResource.NONE), monitor);

  This method changes resources; these changes will be reported in a subsequent resource change event that will include an indication that the resources have been added to the new parent.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `resources` - the resources to copy
    `destination` - the destination container path
    `force` - a flag controlling whether resources that are not in sync with the local file system will be tolerated
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    a status object with code `OK` if there were no problems; otherwise a description (possibly a multi-status) consisting of low-severity warnings or informational messages
  Throws:
    `CoreException` - if the method fails to copy some resources. The status contained in the exception may be a multi-status indicating where the individual failures occurred.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  See Also:
    `copy(IResource[],IPath,int,IProgressMonitor)`

### copy

    public IStatus copy(IResource[] resources,
                        IPath destination,
                        int updateFlags,
                        IProgressMonitor monitor)
                 throws CoreException

  Copies the given sibling resources so that they are located as members of the resource at the given path; the names of the copies are the same as the corresponding originals.

  This method can be expressed as a series of calls to `IResource.copy(IPath,int,IProgressMonitor)`, with "best effort" semantics:

  - Resources are copied in the order specified, using the given update flags.
  - Duplicate resources are only copied once.
  - The method fails if the resources are not all siblings.
  - The failure of an individual copy does not necessarily prevent the method from attempting to copy other resources.
  - The method fails if there are projects among the resources.
  - The method fails if the path of the resources is a prefix of the destination path.
  - This method also fails if one or more of the individual resource copy steps fails.

  After successful completion, corresponding new resources will now exist as members of the resource at the given path.

  The supplied path may be absolute or relative. Absolute paths fully specify the new location for the resource, including its project. Relative paths are considered to be relative to the container of the resources being copied. A trailing separator is ignored.

  This method changes resources; these changes will be reported in a subsequent resource change event that will include an indication that the resources have been added to the new parent.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `resources` - the resources to copy
    `destination` - the destination container path
    `updateFlags` - bit-wise or of update flag constants
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    a status object with code `OK` if there were no problems; otherwise a description (possibly a multi-status) consisting of low-severity warnings or informational messages
  Throws:
    `CoreException` - if the method fails to copy some resources. The status contained in the exception may be a multi-status indicating where the individual failures occurred. Reasons include:
    - One of the resources does not exist.
    - The resources are not siblings.
    - One of the resources, or one of its descendents, is not local.
    - The resource corresponding to the destination path does not exist.
    - The resource corresponding to the parent destination path is a closed project.
    - A corresponding target resource does exist.
    - A resource of a different type exists at the target path.
    - One of the resources is a project.
    - The path of one of the resources is a prefix of the destination path.
    - One of the resources, or one of its descendents, is out of sync with the local file system and `FORCE` is not specified.
    - Resource changes are disallowed during certain types of resource change event notification. See `IResourceChangeEvent` for more details.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  Since:
    2.0
  See Also:
    `IResource.copy(IPath,int,IProgressMonitor)`, `IResourceRuleFactory.copyRule(IResource, IResource)`

### delete

    public IStatus delete(IResource[] resources,
                          boolean force,
                          IProgressMonitor monitor)
                   throws CoreException

  Deletes the given resources.

  This is a convenience method, fully equivalent to:

       delete(resources, IResource.KEEP_HISTORY | (force ? IResource.FORCE : IResource.NONE), monitor);

  This method changes resources; these changes will be reported in a subsequent resource change event.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `resources` - the resources to delete
    `force` - a flag controlling whether resources that are not in sync with the local file system will be tolerated
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    status with code `OK` if there were no problems; otherwise a description (possibly a multi-status) consisting of low-severity warnings or informational messages
  Throws:
    `CoreException` - if the method fails to delete some resource. The status contained in the exception is a multi-status indicating where the individual failures occurred.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  See Also:
    `delete(IResource[],int,IProgressMonitor)`

### delete

    public IStatus delete(IResource[] resources,
                          int updateFlags,
                          IProgressMonitor monitor)
                   throws CoreException

  Deletes the given resources.

  This method can be expressed as a series of calls to `IResource.delete(int,IProgressMonitor)`.

  The semantics of multiple deletion are:

  - Resources are deleted in the order presented, using the given update flags.
  - Resources that do not exist are ignored.
  - An individual deletion fails if the resource still exists afterwards.
  - The failure of an individual deletion does not prevent the method from attempting to delete other resources.
  - This method fails if one or more of the individual resource deletions fails; that is, if at least one of the resources in the list still exists at the end of this method.

  This method changes resources; these changes will be reported in a subsequent resource change event.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `resources` - the resources to delete
    `updateFlags` - bit-wise or of update flag constants
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    status with code `OK` if there were no problems; otherwise a description (possibly a multi-status) consisting of low-severity warnings or informational messages
  Throws:
    `CoreException` - if the method fails to delete some resource. The status contained in the exception is a multi-status indicating where the individual failures occurred.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  Since:
    2.0
  See Also:
    `IResource.delete(int,IProgressMonitor)`, `IResourceRuleFactory.deleteRule(IResource)`

### deleteMarkers

    public void deleteMarkers(IMarker[] markers)
                       throws CoreException

  Removes the given markers from the resources with which they are associated. Markers that do not exist are ignored.

  This method changes resources; these changes will be reported in a subsequent resource change event.

  Parameters:
    `markers` - the markers to remove
  Throws:
    `CoreException` - if this method fails. Reasons include:
    - Resource changes are disallowed during certain types of resource change event notification. See `IResourceChangeEvent` for more details.
  See Also:
    `IResourceRuleFactory.markerRule(IResource)`

### forgetSavedTree

    public void forgetSavedTree(String pluginId)

  Forgets any resource tree being saved for the plug-in with the given name. If the plug-in id is `null`, all trees are forgotten.

  Clients should not call this method unless they have a reason to do so. A plug-in which uses `ISaveContext.needDelta` in the process of a save indicates that it would like to be fed the resource delta the next time it is reactivated. If a plug-in never gets reactivated (or if it fails to successfully register to participate in workspace saves), the workspace nevertheless retains the necessary information to generate the resource delta if asked. This method allows such a long term leak to be plugged.

  Parameters:
    `pluginId` - the unique identifier of the plug-in
  See Also:
    `ISaveContext.needDelta()`

### getNatureDescriptors

    public IProjectNatureDescriptor[] getNatureDescriptors()

  Returns all nature descriptors known to this workspace. Returns an empty array if there are no installed natures.

  Returns:
    the nature descriptors known to this workspace
  Since:
    2.0

### getNatureDescriptor

    public IProjectNatureDescriptor getNatureDescriptor(String natureId)

  Returns the nature descriptor with the given unique identifier, or `null` if there is no such nature.

  Parameters:
    `natureId` - the nature extension identifer (e.g. `"com.example.coolNature"`).
  Returns:
    the nature descriptor, or `null`
  Since:
    2.0

### getDanglingReferences

    public Map getDanglingReferences()

  Finds all dangling project references in this workspace. Projects which are not open are ignored. Returns a map with one entry for each open project in the workspace that has at least one dangling project reference; the value of the entry is an array of projects which are referenced by that project but do not exist in the workspace. Returns an empty Map if there are no projects in the workspace.

  Returns:
    a map (key type: `IProject`, value type: `IProject[]`) from project to dangling project references

### getDescription

    public IWorkspaceDescription getDescription()

  Returns the workspace description. This object is responsible for defining workspace preferences. The returned value is a modifiable copy but changes are not automatically applied to the workspace. In order to changes take effect, `IWorkspace.setDescription` needs to be called. The workspace description values are store in the preference store.

  Returns:
    the workspace description
  See Also:
    `setDescription(IWorkspaceDescription)`

### getRoot

    public IWorkspaceRoot getRoot()

  Returns the root resource of this workspace.

  Returns:
    the workspace root

### getRuleFactory

    public IResourceRuleFactory getRuleFactory()

  Returns a factory for obtaining scheduling rules prior to modifying resources in the workspace.

  Returns:
    a resource rule factory
  Since:
    3.0
  See Also:
    `IResourceRuleFactory`

### getSynchronizer

    public ISynchronizer getSynchronizer()

  Returns the synchronizer for this workspace.

  Returns:
    the synchronizer
  See Also:
    `ISynchronizer`

### isAutoBuilding

    public boolean isAutoBuilding()

  Returns whether this workspace performs auto-builds.

  Returns:
    `true` if auto-building is on, `false` otherwise

### isTreeLocked

    public boolean isTreeLocked()

  Returns whether the workspace tree is currently locked. Resource changes are disallowed during certain types of resource change event notification. See `IResourceChangeEvent` for more details.

  Returns:
    boolean `true` if the workspace tree is locked, `false` otherwise
  Since:
    2.1
  See Also:
    `IResourceChangeEvent`

### loadProjectDescription

    public IProjectDescription loadProjectDescription(IPath projectDescriptionFile)
                                               throws CoreException

  Reads the project description file (".project") from the given location in the local file system. This object is useful for discovering the correct name for a project before importing it into the workspace.

  The returned value is writeable.

  Parameters:
    `projectDescriptionFile` - the path in the local file system of an existing project description file
  Returns:
    a new project description
  Throws:
    `CoreException` - if the operation failed, either because the project description file does not exist, or cannot be opened, or cannot be parsed as a legal project description file
  Since:
    2.0
  See Also:
    `newProjectDescription(String)`, `IProject.getDescription()`

### move

    public IStatus move(IResource[] resources,
                        IPath destination,
                        boolean force,
                        IProgressMonitor monitor)
                 throws CoreException

  Moves the given sibling resources so that they are located as members of the resource at the given path; the names of the new members are the same.

  This is a convenience method, fully equivalent to:

       move(resources, destination, IResource.KEEP_HISTORY | (force ? IResource.FORCE : IResource.NONE), monitor);

  This method changes resources; these changes will be reported in a subsequent resource change event that will include an indication that the resources have been removed from their parent and that corresponding resources have been added to the new parent. Additional information provided with resource delta shows that these additions and removals are pairwise related.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `resources` - the resources to move
    `destination` - the destination container path
    `force` - a flag controlling whether resources that are not in sync with the local file system will be tolerated
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    status with code `OK` if there were no problems; otherwise a description (possibly a multi-status) consisting of low-severity warnings or informational messages.
  Throws:
    `CoreException` - if the method fails to move some resources. The status contained in the exception may be a multi-status indicating where the individual failures occurred.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  See Also:
    `move(IResource[],IPath,int,IProgressMonitor)`

### move

    public IStatus move(IResource[] resources,
                        IPath destination,
                        int updateFlags,
                        IProgressMonitor monitor)
                 throws CoreException

  Moves the given sibling resources so that they are located as members of the resource at the given path; the names of the new members are the same.

  This method can be expressed as a series of calls to `IResource.move`, with "best effort" semantics:

  - Resources are moved in the order specified.
  - Duplicate resources are only moved once.
  - The `force` flag has the same meaning as it does on the corresponding single-resource method.
  - The method fails if the resources are not all siblings.
  - The method fails the path of any of the resources is a prefix of the destination path.
  - The failure of an individual move does not necessarily prevent the method from attempting to move other resources.
  - This method also fails if one or more of the individual resource moves fails; that is, if at least one of the resources in the list still exists at the end of this method.
  - History is kept for moved files. When projects are moved, no history is kept

  After successful completion, the resources and descendents will no longer exist; but corresponding new resources will now exist as members of the resource at the given path.

  The supplied path may be absolute or relative. Absolute paths fully specify the new location for the resource, including its project. Relative paths are considered to be relative to the container of the resources being moved. A trailing separator is ignored.

  This method changes resources; these changes will be reported in a subsequent resource change event that will include an indication that the resources have been removed from their parent and that corresponding resources have been added to the new parent. Additional information provided with resource delta shows that these additions and removals are pairwise related.

  This method is long-running; progress and cancellation are provided by the given progress monitor.

  Parameters:
    `resources` - the resources to move
    `destination` - the destination container path
    `updateFlags` - bit-wise or of update flag constants
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    status with code `OK` if there were no problems; otherwise a description (possibly a multi-status) consisting of low-severity warnings or informational messages.
  Throws:
    `CoreException` - if the method fails to move some resources. The status contained in the exception may be a multi-status indicating where the individual failures occurred. Reasons include:
    - One of the resources does not exist.
    - The resources are not siblings.
    - One of the resources, or one of its descendents, is not local.
    - The resource corresponding to the destination path does not exist.
    - The resource corresponding to the parent destination path is a closed project.
    - A corresponding target resource does exist.
    - A resource of a different type exists at the target path.
    - The path of one of the resources is a prefix of the destination path.
    - One of the resources, or one of its descendents, is out of sync with the local file system and `FORCE` is `false`.
    - Resource changes are disallowed during certain types of resource change event notification. See `IResourceChangeEvent` for more details.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  Since:
    2.0
  See Also:
    `IResource.move(IPath,int,IProgressMonitor)`, `IResourceRuleFactory.moveRule(IResource, IResource)`

### newProjectDescription

    public IProjectDescription newProjectDescription(String projectName)

  Creates and returns a new project description for a project with the given name. This object is useful when creating, moving or copying projects.

  The project description is initialized to:

  - the given project name
  - no references to other projects
  - an empty build spec
  - an empty comment

  The returned value is writeable.

  Parameters:
    `projectName` - the name of the project
  Returns:
    a new project description
  See Also:
    `IProject.getDescription()`, `IProject.create(IProjectDescription, IProgressMonitor)`, `IResource.copy(IProjectDescription, int, IProgressMonitor)`, `IProject.move(IProjectDescription, boolean, IProgressMonitor)`

### removeResourceChangeListener

    public void removeResourceChangeListener(IResourceChangeListener listener)

  Removes the given resource change listener from this workspace. Has no effect if an identical listener is not registered.

  Parameters:
    `listener` - the listener
  See Also:
    `IResourceChangeListener`, `addResourceChangeListener(IResourceChangeListener)`

### removeSaveParticipant

    public void removeSaveParticipant(Plugin plugin)

  Removes the workspace save participant for the given plug-in from this workspace. If no such participant is registered, no action is taken.

  Once removed, the workspace save participant no longer actively participates in any future saves of this workspace.

  Parameters:
    `plugin` - the plug-in
  See Also:
    `ISaveParticipant`, `addSaveParticipant(Plugin, ISaveParticipant)`

### run

    public void run(IWorkspaceRunnable action,
                    ISchedulingRule rule,
                    int flags,
                    IProgressMonitor monitor)
             throws CoreException

  Runs the given action as an atomic workspace operation.

  After running a method that modifies resources in the workspace, registered listeners receive after-the-fact notification of what just transpired, in the form of a resource change event. This method allows clients to call a number of methods that modify resources and only have resource change event notifications reported at the end of the entire batch.

  If this method is called outside the dynamic scope of another such call, this method runs the action and then reports a single resource change event describing the net effect of all changes done to resources by the action.

  If this method is called in the dynamic scope of another such call, this method simply runs the action.

  The supplied scheduling rule is used to determine whether this operation can be run simultaneously with workspace changes in other threads. If the scheduling rule conflicts with another workspace change that is currently running, the calling thread will be blocked until that change completes. If the action attempts to make changes to the workspace that were not specified in the scheduling rule, it will fail. If no scheduling rule is supplied, then any attempt to change resources will fail. If a non-`null` scheduling rule is supplied, this operation must always support cancelation in the case where this operation becomes blocked by a long running background operation.

  The AVOID_UPDATE flag controls whether periodic resource change notifications should occur during the scope of this call. If this flag is specified, and no other threads modify the workspace concurrently, then all resource change notifications will be deferred until the end of this call. If this flag is not specified, the platform may decide to broadcast periodic resource change notifications during the scope of this call.

  Flags other than `AVOID_UPDATE` are ignored.

  Parameters:
    `action` - the action to perform
    `rule` - the scheduling rule to use when running this operation, or `null` if there are no scheduling restrictions for this operation.
    `flags` - bit-wise or of flag constants (only AVOID_UPDATE is relevant here)
    `monitor` - a progress monitor, or `null` if progress reporting is not desired.
  Throws:
    `CoreException` - if the operation failed.
    `OperationCanceledException` - if the operation is canceled. If a non-`null` scheduling rule is supplied, cancelation can occur even if no progress monitor is provided.
  Since:
    3.0
  See Also:
    `AVOID_UPDATE`, `IResourceRuleFactory`

### run

    public void run(IWorkspaceRunnable action,
                    IProgressMonitor monitor)
             throws CoreException

  Runs the given action as an atomic workspace operation.

  This is a convenience method, fully equivalent to:

       workspace.run(action, workspace.getRoot(), IWorkspace.AVOID_UPDATE, monitor);

  Parameters:
    `action` - the action to perform
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Throws:
    `CoreException` - if the operation failed.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.

### save

    public IStatus save(boolean full,
                        IProgressMonitor monitor)
                 throws CoreException

  Saves this workspace's valuable state on disk. Consults with all registered plug-ins so that they can coordinate the saving of their persistent state as well.

  The `full` parameter indicates whether a full save or a snapshot is being requested. Snapshots save the workspace information that is considered hard to be recomputed in the unlikely event of a crash. It includes parts of the workspace tree, workspace and projects descriptions, markers and sync infos. Full saves are heavy weight operations which save the complete workspace state.

  To ensure that all outstanding changes to the workspace have been reported to interested parties prior to saving, a full save cannot be used within the dynamic scope of an `IWorkspace.run` invocation. Snapshots can be called anytime and are interpreted by the workspace as a hint that a snapshot is required. The workspace will perform the snapshot when possible. Even as a hint, snapshots should only be called when necessary as they impact system performance. Although saving does not change the workspace per se, its execution is serialized like methods that write the workspace.

  The workspace is comprised of several different kinds of data with varying degrees of importance. The most important data, the resources themselves and their persistent properties, are written to disk immediately; other data are kept in volatile memory and only written to disk periodically; and other data are maintained in memory and never written out. The following table summarizes what gets saved when:

  - creating or deleting resource - immediately
  - setting contents of file - immediately
  - changes to project description - immediately
  - session properties - never
  - changes to persistent properties - immediately
  - markers -`save`
  - synchronizer info -`save`
  - shape of the workspace resource tree -`save`
  - list of active plug-ins - never
  Resource-based plug-in also have data with varying degrees of importance. Each plug-in gets to decide the policy for protecting its data, either immediately, never, or at `save` time. For the latter, the plug-in coordinates its actions with the workspace (see `ISaveParticipant` for details).

  If the platform is shutdown (or crashes) after saving the workspace, any information written to disk by the last successful workspace `save` will be restored the next time the workspace is reopened for the next session. Naturally, information that is written to disk immediately will be as of the last time it was changed.

  The workspace provides a general mechanism for keeping concerned parties apprised of any and all changes to resources in the workspace ( `IResourceChangeListener`). It is even possible for a plug-in to find out about changes to resources that happen between workspace sessions (see `IWorkspace.addSaveParticipant`).

  At certain points during this method, the entire workspace resource tree must be locked to prevent resources from being changed (read access to resources is permitted).

  Implementation note: The execution sequence is as follows.

  - A long-term lock on the workspace is taken out to prevent further changes to workspace until the save is done.
  - The list of saveable resource tree snapshots is initially empty.
  - A different `ISaveContext` object is created for each registered workspace save participant plug-in, reflecting the kind of save (`ISaveContext.getKind`), the previous save number in which this plug-in actively participated, and the new save number (= previous save number plus 1).
  - Each registered workspace save participant is sent `prepareToSave(context)`, passing in its own context object.
    - Plug-in suspends all activities until further notice.
    If `prepareToSave` fails (throws an exception), the problem is logged and the participant is marked as unstable.
  - In dependent-before-prerequisite order, each registered workspace save participant is sent `saving(context)`, passing in its own context object.
    - Plug-in decides whether it wants to actively participate in this save. The plug-in only needs to actively participate if some of its important state has changed since the last time it actively participated. If it does decide to actively participate, it writes its important state to a brand new file in its plug-in state area under a generated file name based on `context.getStateNumber()` and calls `context.needStateNumber()` to indicate that it has actively participated. If upon reactivation the plug-in will want a resource delta covering all changes between now and then, the plug-in should invoke `context.needDelta()` to request this now; otherwise, a resource delta for the intervening period will not be available on reactivation.
    If `saving` fails (throws an exception), the problem is logged and the participant is marked as unstable.
  - The plug-in save table contains an entry for each plug-in that has registered to participate in workspace saves at some time in the past (the list of plug-ins increases monotonically). Each entry records the save number of the last successful save in which that plug-in actively participated, and, optionally, a saved resource tree (conceptually, this is a complete tree; in practice, it is compressed into a special delta tree representation). A copy of the plug-in save table is made. Entries are created or modified for each registered plug-in to record the appropriate save number (either the previous save number, or the previous save number plus 1, depending on whether the participant was active and asked for a new number).
  - The workspace tree, the modified copy of the plug-in save table, all markers, etc. and all saveable resource tree snapshots are written to disk as one atomic operation .
  - The long-term lock on the workspace is released.
  - If the atomic save succeeded:
    - The modified copy of the plug-in save table becomes the new plug-in save table.
    - In prerequisite-before-dependent order, each registered workspace save participant is sent `doneSaving(context)`, passing in its own context object.
      - Plug-in may perform clean up by deleting obsolete state files in its plug-in state area.
      - Plug-in resumes its normal activities.
      If `doneSaving` fails (throws an exception), the problem is logged and the participant is marked as unstable. (The state number in the save table is not rolled back just because of this instability.)
    - The workspace save operation returns.
  - If it failed:
    - The workspace previous state is restored.
    - In prerequisite-before-dependent order, each registered workspace save participant is sent `rollback(context)`, passing in its own context object.
      - Plug-in may perform clean up by deleting newly-created but obsolete state file in its plug-in state area.
      - Plug-in resumes its normal activities.
      If `rollback` fails (throws an exception), the problem is logged and the participant is marked as unstable. (The state number in the save table is rolled back anyway.)
    - The workspace save operation fails.

  After a full save, the platform can be shutdown. This will cause the Resources plug-in and all the other plug-ins to shutdown, without disturbing the saved workspace on disk.

  When the platform is later restarted, activating the Resources plug-in opens the saved workspace. This reads into memory the workspace's resource tree, plug-in save table, and saved resource tree snapshots (everything that was written to disk in the atomic operation above). Later, when a plug-in gets reactivated and registers to participate in workspace saves, it is handed back the info from its entry in the plug-in save table, if it has one. It gets back the number of the last save in which it actively participated and, possibly, a resource delta.

  The only source of long term garbage would come from a plug-in that never gets reactivated, or one that gets reactivated but fails to register for workspace saves. (There is no such problem with a plug-in that gets uninstalled; its easy enough to scrub its state areas and delete its entry in the plug-in save table.)

  Parameters:
    `full` - `true` if this is a full save, and `false` if this is only a snapshot for protecting against crashes
    `monitor` - a progress monitor, or `null` if progress reporting is not desired
  Returns:
    a status that may contain warnings, such as the failure of an individual participant
  Throws:
    `CoreException` - if this method fails to save the state of this workspace. Reasons include:
    - The operation cannot be batched with others.
    `OperationCanceledException` - if the operation is canceled. Cancelation can occur even if no progress monitor is provided.
  See Also:
    `addSaveParticipant(Plugin, ISaveParticipant)`

### setDescription

    public void setDescription(IWorkspaceDescription description)
                        throws CoreException

  Sets the workspace description. Its values are stored in the preference store.

  Parameters:
    `description` - the new workspace description.
  Throws:
    `CoreException` - if the method fails. Reasons include:
    - There was a problem setting the workspace description.
  See Also:
    `getDescription()`

### setWorkspaceLock

    public void setWorkspaceLock(WorkspaceLock lock)

  Deprecated. it is no longer possible to override the workspace lock behavior. This functionality is now provided in the platform API by implementing the org.eclipse.core.runtime.jobs.ILockListener interface.

  Sets the lock to use for controlling write access to this workspace. The lock must only be set once.

  This method is for internal use by the platform-related plug-ins. Clients should not call this method.

  Parameters:
    `lock` - the lock to install on this workspace.

### sortNatureSet

    public String[] sortNatureSet(String[] natureIds)

  Returns a copy of the given set of natures sorted in prerequisite order. For each nature, it is guaranteed that all of its prerequisites will preceed it in the resulting array.

  Natures that are missing from the install or are involved in a prerequisite cycle are sorted arbitrarily. Duplicate nature IDs are removed, so the returned array may be smaller than the original.

  Parameters:
    `natureIds` - a valid set of nature extension identifiers
  Returns:
    the set of nature Ids sorted in prerequisite order
  Since:
    2.0
  See Also:
    `validateNatureSet(String[])`

### validateEdit

    public IStatus validateEdit(IFile[] files,
                                Object context)

  Advises that the caller intends to modify the contents of the given files in the near future and asks whether modifying all these files would be reasonable. The files must all exist. This method is used to give the VCM component an opportunity to check out (or otherwise prepare) the files if required. (It is provided in this component rather than in the UI so that "core" (i.e., head-less) clients can use it. Similarly, it is located outside the VCM component for the convenience of clients that must also operate in configurations without VCM.)

  A client (such as an editor) should perform a `validateEdit` on a file whenever it finds itself in the following position: (a) the file is marked read-only, and (b) the client believes it likely (not necessarily certain) that it will modify the file's contents at some point. A case in point is an editor that has a buffer opened on a file. When the user starts to dirty the buffer, the editor should check to see whether the file is read-only. If it is, it should call `validateEdit`, and can reasonably expect this call, when successful, to cause the file to become read-write. An editor should also be sensitive to a file becoming read-only again even after a successful `validateEdit` (e.g., due to the user checking in the file in a different view); the editor should again call `validateEdit` if the file is read-only before attempting to save the contents of the file.

  By passing a UI context, the caller indicates that the VCM component may contact the user to help decide how best to proceed. If no UI context is provided, the VCM component will make its decision without additional interaction with the user. If OK is returned, the caller can safely assume that all of the given files haven been prepared for modification and that there is good reason to believe that `IFile.setContents` (or `appendContents`) would be successful on any of them. If the result is not OK, modifying the given files might not succeed for the reason(s) indicated.

  If a shell is passed in as the context, the VCM component may bring up a dialogs to query the user or report difficulties; the shell should be used to parent any such dialogs; the caller may safely assume that the reasons for failure will have been made clear to the user. If `null` is passed, the user should not be contacted; any failures should be reported via the result; the caller may chose to present these to the user however they see fit. The ideal implementation of this method is transactional; no files would be affected unless the go-ahead could be given. (In practice, there may be no feasible way to ensure such changes get done atomically.)

  The method calls `IFileModificationValidator.validateEdit` for the file modification validator (if provided by the VCM plug-in). When there is no file modification validator, this method returns a status with an `IResourceStatus.READ_ONLY_LOCAL` code if one of the files is read-only, and a status with an `IStatus.OK` code otherwise.

  This method may be called from any thread. If the UI context is used, it is the responsibility of the implementor of `IFileModificationValidator.validateEdit` to interact with the UI context in an appropriate thread.

  Parameters:
    `files` - the files that are to be modified; these files must all exist in the workspace
    `context` - the `org.eclipse.swt.widgets.Shell` that is to be used to parent any dialogs with the user, or `null` if there is no UI context (declared as an `Object` to avoid any direct references on the SWT component)
  Returns:
    a status object that is OK if things are fine, otherwise a status describing reasons why modifying the given files is not reasonable
  Since:
    2.0
  See Also:
    `IResourceRuleFactory.validateEditRule(IResource[])`

### validateLinkLocation

    public IStatus validateLinkLocation(IResource resource,
                                        IPath location)

  Validates the given path as the location of the given resource on disk. The path must be either an absolute file system path, or a relative path whose first segment is the name of a defined workspace path variable. In addition to the restrictions for paths in general (see `IPath. isValidPath`), a link location must also obey the following rules:
  - must not overlap with the platform's metadata directory
  - must not be the same as or a parent of the root directory of the project the linked resource is contained in

  This method also checks that the given resource can legally become a linked resource. This includes the following restrictions:

  - must have a project as its immediate parent
  - project natures and the team hook may disallow linked resources on projects they are associated with
  - the global workspace preference to disable linking, `ResourcesPlugin.PREF_DISABLE_LINKING` must not be set to "true"
  .

  This method will return a status with severity `IStatus.ERROR` if the location does not obey the above rules. Also, this method will return a status with severity `IStatus.WARNING` if the location overlaps the location of any existing resource in the workspace.

  Note: this method does not consider whether files or directories exist in the filesystem at the specified path.

  Parameters:
    `resource` - the resource to validate the location for
    `location` - the location of the linked resource contents on disk
  Returns:
    a status object with code `IStatus.OK` if the given location is valid as the linked resource location, otherwise a status object with severity `IStatus.WARNING` or `IStatus.ERROR` indicating what is wrong with the location
  Since:
    2.1
  See Also:
    `IStatus.OK`, `ResourcesPlugin.PREF_DISABLE_LINKING`

### validateName

    public IStatus validateName(String segment,
                                int typeMask)

  Validates the given string as the name of a resource valid for one of the given types.

  In addition to the basic restrictions on paths in general (see `IPath.isValidSegment`), a resource name must also obey the following rules:

  - it must not be empty
  - it must not be a single period character (".")
  - it must not contain two or more consecutive period characters
  - it must not end in a period character
  - it must not contain any characters or substrings that are not valid on the filesystem on which workspace root is located.

  This validation check is done automatically as a resource is created (but not when the resource handle is constructed); this means that any resource that exists can be safely assumed to have a valid name and path. Note that the name of the workspace root resource is inherently invalid.

  Parameters:
    `segment` - the name segment to be checked
    `typeMask` - bitwise-or of the resource type constants ( `FILE`,`FOLDER`,`PROJECT` or `ROOT`) indicating expected resource type(s)
  Returns:
    a status object with code `IStatus.OK` if the given string is valid as a resource name, otherwise a status object indicating what is wrong with the string
  See Also:
    `IResource.PROJECT`, `IResource.FOLDER`, `IResource.FILE`, `IStatus.OK`

### validateNatureSet

    public IStatus validateNatureSet(String[] natureIds)

  Validates that each of the given natures exists, and that all nature constraints are satisfied within the given set.

  The following conditions apply to validation of a set of natures:

  - all natures in the set exist in the plug-in registry
  - all prerequisites of each nature are present in the set
  - there are no cycles in the prerequisite graph of the set
  - there are no two natures in the set that specify one-of-nature inclusion in the same group.
  - there are no two natures in the set with the same id

  An empty nature set is always valid.

  Parameters:
    `natureIds` - an array of nature extension identifiers
  Returns:
    a status object with code `IStatus.OK` if the given set of natures is valid, otherwise a status object indicating what is wrong with the set
  Since:
    2.0

### validatePath

    public IStatus validatePath(String path,
                                int typeMask)

  Validates the given string as a path for a resource of the given type(s).

  In addition to the restrictions for paths in general (see `IPath.isValidPath`), a resource path should also obey the following rules:

  - a resource path should be an absolute path with no device id
  - its segments should be valid names according to `validateName`
  - a path for the workspace root must be the canonical root path
  - a path for a project should have exactly 1 segment
  - a path for a file or folder should have more than 1 segment
  - the first segment should be a valid project name
  - the second through penultimate segments should be valid folder names
  - the last segment should be a valid name of the given type

  Note: this method does not consider whether a resource at the specified path exists.

  This validation check is done automatically as a resource is created (but not when the resource handle is constructed); this means that any resource that exists can be safely assumed to have a valid name and path.

  Parameters:
    `path` - the path string to be checked
    `typeMask` - bitwise-or of the resource type constants ( `FILE`,`FOLDER`,`PROJECT`, or `ROOT`) indicating expected resource type(s)
  Returns:
    a status object with code `IStatus.OK` if the given path is valid as a resource path, otherwise a status object indicating what is wrong with the string
  See Also:
    `IResource.PROJECT`, `IResource.FOLDER`, `IResource.FILE`, `IStatus.OK`, `IResourceStatus.getPath()`

### validateProjectLocation

    public IStatus validateProjectLocation(IProject project,
                                           IPath location)

  Validates the given path as the location of the given project on disk. The path must be either an absolute file system path, or a relative path whose first segment is the name of a defined workspace path variable. In addition to the restrictions for paths in general (see `IPath. isValidPath`), a location path should also obey the following rules:
  - must not overlap with another open or closed project
  - must not overlap with the platform's working directory
  - must not be the same as or a child of the location of any existing linked resource in the given project

  Note: this method does not consider whether files or directories exist in the filesystem at the specified path.

  Parameters:
    `project` - the project to validate the location for
    `location` - the location of the project contents on disk
  Returns:
    a status object with code `IStatus.OK` if the given location is valid as the project content location, otherwise a status object indicating what is wrong with the location
  See Also:
    `IProjectDescription.getLocation()`, `IProjectDescription.setLocation(IPath)`, `IStatus.OK`

### getPathVariableManager

    public IPathVariableManager getPathVariableManager()

  Returns the path variable manager for this workspace.

  Returns:
    the path variable manager
  Since:
    2.1
  See Also:
    `IPathVariableManager`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse Platform Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Guidelines for using Eclipse APIs.

Copyright (c) IBM Corp. and others 2000, 2004. All rights reserved.