# Uses of Package
org.eclipse.core.runtime

Packages that use org.eclipse.core.runtime
org.eclipse.ant.core: Provides support for running the Ant build tool in the platform.
org.eclipse.compare: Provides support for performing structural and textual compare operations on arbitrary data and displaying the results.
org.eclipse.compare.contentmergeviewer: Support for compare and merge viewers which show the content side-by-side.
org.eclipse.compare.patch: Provides support for applying and working with patches.
org.eclipse.compare.rangedifferencer: Provides support for finding the differences between two or three sequences of comparable entities.
org.eclipse.compare.structuremergeviewer: Provides support for finding and displaying the differences between hierarchically structured data.
org.eclipse.core.commands.operations: Classes for the creation of undoable operations which can be added to an operations history and later be undone and redone.
org.eclipse.core.databinding: Provides classes for binding observable objects, for example UI widgets and model objects.
org.eclipse.core.databinding.util: Provides general utilities for data binding.
org.eclipse.core.databinding.validation: Provides the core APIs for validation.
org.eclipse.core.expressions: Application programming interfaces for the expression language.
org.eclipse.core.filebuffers: Provides the API for accessing file buffers.
org.eclipse.core.filebuffers.manipulation: Provides the API for manipulating file buffers.
org.eclipse.core.filesystem: Provides an interface for interacting with a file system.
org.eclipse.core.filesystem.provider: Provides an API to be extended by a file system implementation.
org.eclipse.core.internal.jobs
org.eclipse.core.internal.resources
org.eclipse.core.net.proxy: Provides support for the management of platform level proxy settings.
org.eclipse.core.resources: Provides basic support for managing a workspace and its resources.
org.eclipse.core.resources.filtermatchers: Provides APIs intended to be implemented by the resource filter matchers.
org.eclipse.core.resources.mapping: Provides APIs for integrating application models with the workspace
org.eclipse.core.resources.refresh: Provides APIs intended to be implemented by the auto-refresh providers.
org.eclipse.core.resources.team: Provides APIs intended to be implemented by the Team component.
org.eclipse.core.runtime: Provides support for the runtime platform, core utility methods and the extension registry.
org.eclipse.core.runtime.content: Provides core support for content types.
org.eclipse.core.runtime.dynamichelpers: Provides helpers to facilitate the authoring of dynamic plug-ins.
org.eclipse.core.runtime.jobs: Provides core support for scheduling and interacting with background activity.
org.eclipse.core.runtime.preferences: Provides core support for Eclipse preferences.
org.eclipse.core.runtime.spi: Extension registry infrastructure for service providers
org.eclipse.core.variables: Provides support for defining and contributing variables for the purpose of string substitution.
org.eclipse.debug.core: Provides support for launching programs, breakpoint management, expression management, and debug events.
org.eclipse.debug.core.commands: Provides a set of interfaces for common debug commands.
org.eclipse.debug.core.model: Defines interfaces for debug model elements, source lookup, and launching.
org.eclipse.debug.core.sourcelookup: Provides support for source lookup.
org.eclipse.debug.core.sourcelookup.containers: Provides implementations of common source containers supporting source lookup.
org.eclipse.debug.internal.ui.views.memory.renderings
org.eclipse.debug.ui: Provides a generic debugger user interface that clients may customize via standard workbench extension points.
org.eclipse.debug.ui.actions: Provides a set of actions related to running and debugging applications.
org.eclipse.debug.ui.memory: Provides classes and interfaces to render memory blocks in the memory view.
org.eclipse.debug.ui.sourcelookup: Provides a user interface for debug platform source lookup facilities.
org.eclipse.e4.ui.workbench.modeling: Application programming interfaces describing the Eclipse 4 model services.
org.eclipse.equinox.jsp.jasper.registry: Provides core support for the HttpService Servlet.
org.eclipse.equinox.p2.core: Provides core support for interacting with a p2-based provisioning system
org.eclipse.equinox.p2.engine: Provides support for interacting with the p2 provisioning engine
org.eclipse.equinox.p2.engine.spi: Provides support for registering new provisioning actions and touchpoints.
org.eclipse.equinox.p2.operations: Describes high level provisioning operations that can be resolved and performed either modally or in the background.
org.eclipse.equinox.p2.planner: Provides core support for interacting with a dependency resolution mechanism.
org.eclipse.equinox.p2.query: Provides common classes for the query mechanism.
org.eclipse.equinox.p2.repository: Defines common API for querying and modifying provisioning repositories.
org.eclipse.equinox.p2.repository.artifact: Defines artifact repository.
org.eclipse.equinox.p2.repository.artifact.spi: Defines SPI for registering new implementations of artifact repositories.
org.eclipse.equinox.p2.repository.metadata: Defines metadata repository.
org.eclipse.equinox.p2.repository.metadata.spi: Defines SPI for registering new implementations of metadata repositories.
org.eclipse.equinox.p2.repository.spi: Defines common types for handling repositories.
org.eclipse.equinox.p2.ui: Provides provisioning user interface classes that can be used for assembling a provisioning UI.
org.eclipse.help.search: Provides the ability to add participants to help search and is responsible for creating search indices.
org.eclipse.help.server: Provides the ability to specify the web server to be used by the help system.
org.eclipse.help.ui.browser: Provides an implementation of IWorkbenchWindowActionDelegate for opening a URL in a browser.
org.eclipse.jface.action: Provides support for shared UI resources such as menus, tool bars, and status lines.
org.eclipse.jface.databinding.dialog
org.eclipse.jface.databinding.fieldassist: Provides classes that bridge between data binding and the JFace Fieldassist framework.
org.eclipse.jface.dialogs: Provides support for dialogs.
org.eclipse.jface.operation: Provides JFace support for long-running operations.
org.eclipse.jface.text.contentassist: Provides a content assist add-on for an `ITextViewer`.
org.eclipse.jface.text.hyperlink: Provides support for detecting and displaying hyperlinks in `ISourceViewer`s.
org.eclipse.jface.text.quickassist: This package provides the quick assist assistant add-on for an `ISourceViewer`.
org.eclipse.jface.text.reconciler: Provides a reconciler add-on for an `ITextViewer`.
org.eclipse.jface.text.templates: Application programming interfaces for interaction with the Eclipse text template support.
org.eclipse.jface.util: Provides useful building blocks used throughout JFace, including property change events, a listener list implementation, and runtime checked assertions.
org.eclipse.jface.wizard: Provides a framework for wizards.
org.eclipse.jsch.core: Provides support for the JSch SSH2 library.
org.eclipse.ltk.core.refactoring: Application programmer interface to implement semantic preserving workspace transformations.
org.eclipse.ltk.core.refactoring.history: Application programming interface to query refactoring history information from the refactoring infrastructure.
org.eclipse.ltk.core.refactoring.model: Application programming interface to support logical models.
org.eclipse.ltk.core.refactoring.participants: Application programming interface to participant in existing rename, move and delete refactorings if the refactoring provider supports participation.
org.eclipse.ltk.core.refactoring.resource: Application programmer interface to implement resource dependend refactorings.
org.eclipse.ltk.ui.refactoring: Application programming interface to implement a wizard based user interface for refactorings.
org.eclipse.ltk.ui.refactoring.history: Application programming interface to display and preview refactoring history information.
org.eclipse.ltk.ui.refactoring.model: Application programming interface to provide model integration for refactoring histories.
org.eclipse.search.core.text: Classes giving access to the file (text) search functionality.
org.eclipse.search.ui: Classes and interface required to contribute search dialog pages and search result view pages.
org.eclipse.search.ui.text: Provides the base classes to implement a search result view part for searches with textual matches.
org.eclipse.team.core: Application programming interfaces for defining and working with repository providers.
org.eclipse.team.core.diff: Application programming interfaces for working with diffs.
org.eclipse.team.core.diff.provider: Application programming interfaces for working with diffs.
org.eclipse.team.core.history: Application programming interfaces for describing the history associated with files.
org.eclipse.team.core.mapping: Application programming interfaces for working with resource mappings.
org.eclipse.team.core.mapping.provider: Application programming interfaces for working with resource mappings.
org.eclipse.team.core.subscribers: Application programming interfaces for generating and refreshing synchronization state.
org.eclipse.team.core.synchronize: Application programming interfaces for managing synchronization state.
org.eclipse.team.core.variants: Application programming interfaces for accessing and managing resource variants.
org.eclipse.team.ui: Provides basic support for managing Team providers.
org.eclipse.team.ui.history: Application programming interfaces for working with history.
org.eclipse.team.ui.mapping: Application programming interfaces for working with resource mappings.
org.eclipse.team.ui.synchronize: Contains the team synchronization presentation framework and support for the Synchronize View.
org.eclipse.ui: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.actions: Classes for actions and operations used in a workbench window, page, or part in the Eclipse Platform User Interface.
org.eclipse.ui.activities: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.application: Application-level APIs for configuring and controling the Eclipse Platform User Interface.
org.eclipse.ui.cheatsheets: Provides support for working with cheat sheets.
org.eclipse.ui.commands: Provides support for retrieving information on Commands from the workbench.
org.eclipse.ui.console: Application programming interfaces for interaction with the Eclipse console.
org.eclipse.ui.dialogs: Classes for standard dialogs, wizards, and preference pages in the Eclipse Platform User Interface.
org.eclipse.ui.editors.text: Provides a standard text editor and concrete document providers based `IFileBuffer` and others directly handling `IFile` and `IStorage` as editor input.
org.eclipse.ui.forms.editor: Support for forms-based multi-page editors.
org.eclipse.ui.handlers: Provides support for integrating handlers into the Eclipse workbench.
org.eclipse.ui.ide: APIs for the IDE-specific portion of the Eclipse Platform User Interface.
org.eclipse.ui.ide.dialogs: APIs for dialogs in the IDE-specific portion of the Eclipse Platform User Interface.
org.eclipse.ui.ide.undo: APIs that provide undo and redo behavior for operations that manipulate the workspace.
org.eclipse.ui.internal.views.markers
org.eclipse.ui.intro: Application programming interfaces for interaction with and extension of the product introduction parts.
org.eclipse.ui.intro.config: Provides support for customizing welcome content and presentation.
org.eclipse.ui.intro.universal: Provides a mechanism to add a preference page to customize welcome.
org.eclipse.ui.menus: Provides the public API and default implementation for contributing menu and toolbars to the menu service.
org.eclipse.ui.model: Provides a workbench adapter for displaying workbench elements in the UI without having to know the concrete type of the element, and various label providers for workbench-specific objects like editors, views, and perspectives.
org.eclipse.ui.navigator: Provides the Common Navigator framework.
org.eclipse.ui.navigator.resources: Provides reusable components for clients that need to expand on the capabilities provided by the reference Common Navigator Resources extension.
org.eclipse.ui.operations: Classes that provide the basic workbench UI support for undo and redo of operations.
org.eclipse.ui.part: Classes for the creation of workbench parts that integrate with the Eclipse Platform User Interface.
org.eclipse.ui.plugin: Class hierarchies for plug-ins that integrate with the Eclipse Platform UI.
org.eclipse.ui.preferences: Classes for using the preferences support in org.eclipse.core.runtime.preferences
org.eclipse.ui.progress: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.splash: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.statushandlers: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.testing: Classes for testing support.
org.eclipse.ui.texteditor: Provides a framework for text editors obeying to the desktop rules.
org.eclipse.ui.texteditor.quickdiff: Provides interfaces to for the `org.eclipse.ui.editors.quickDiffReferenceProvider` extension point and adds an action to enable quick diff display for an editor.
org.eclipse.ui.texteditor.rulers: Provides interfaces and classes for the `org.eclipse.ui.workbench.texteditor.rulerColumns`.
org.eclipse.ui.texteditor.spelling: Partial infrastructure for spell checking in text editors.
org.eclipse.ui.texteditor.templates: Application programming interfaces for interaction with the Eclipse text editor template support.
org.eclipse.ui.themes: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.views: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.
org.eclipse.ui.views.bookmarkexplorer: Provides the standard Bookmarks view which displays bookmarks on resources.
org.eclipse.ui.views.contentoutline: Provides the standard Content Outline view which can show the active editor's custom outline for the document being edited.
org.eclipse.ui.views.markers: Utility classes for working with markers in views
org.eclipse.ui.views.navigator: Provides the standard Resource Navigator view which presents the tree of resources in the workspace.
org.eclipse.ui.views.properties: Provides the standard Property Sheet view which displays custom properties of the active workbench part's current selection.
org.eclipse.ui.views.tasklist: Provides the standard Task List view for displaying tasks and problem annotations on resources.
org.eclipse.ui.wizards: Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface wizard support.
org.eclipse.ui.wizards.datatransfer: Provides the standard Import and Export wizards for moving resources into and out of the workspace.
org.eclipse.ui.wizards.newresource: Provides the standard wizards for creating files, folders, and projects in the workspace.

Classes in org.eclipse.core.runtime used by org.eclipse.ant.core
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
Plugin: The abstract superclass of all plug-in runtime class implementations.
Preferences: Deprecated. This class is replaced by `IEclipsePreferences`.
Preferences.IPropertyChangeListener: Deprecated. Listener for property changes.
Preferences.PropertyChangeEvent: Deprecated. An event object describing a change to a named property.

Classes in org.eclipse.core.runtime used by org.eclipse.compare
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.compare.contentmergeviewer
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.compare.patch
CoreException: A checked exception representing a failure.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.compare.rangedifferencer
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.compare.structuremergeviewer
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.commands.operations
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
Status: A concrete status implementation, suitable either for instantiating or subclassing.

Classes in org.eclipse.core.runtime used by org.eclipse.core.databinding
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.databinding.util
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.databinding.validation
IStatus: A status object represents the outcome of an operation.
Status: A concrete status implementation, suitable either for instantiating or subclassing.

Classes in org.eclipse.core.runtime used by org.eclipse.core.expressions
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.

Classes in org.eclipse.core.runtime used by org.eclipse.core.filebuffers
CoreException: A checked exception representing a failure.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.filebuffers.manipulation
CoreException: A checked exception representing a failure.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.

Classes in org.eclipse.core.runtime used by org.eclipse.core.filesystem
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.core.filesystem.provider
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.core.internal.jobs
IAdaptable: An interface for an adaptable object.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.core.internal.resources
IAdaptable: An interface for an adaptable object.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.core.net.proxy
CoreException: A checked exception representing a failure.

Classes in org.eclipse.core.runtime used by org.eclipse.core.resources
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
ICoreRunnable: A functional interface for a runnable that can be cancelled and can report progress using the progress monitor passed to the `ICoreRunnable.run(IProgressMonitor)` method.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
Plugin: The abstract superclass of all plug-in runtime class implementations.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.core.resources.filtermatchers
CoreException: A checked exception representing a failure.

Classes in org.eclipse.core.runtime used by org.eclipse.core.resources.mapping
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
Status: A concrete status implementation, suitable either for instantiating or subclassing.

Classes in org.eclipse.core.runtime used by org.eclipse.core.resources.refresh
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.core.resources.team
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.runtime
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IAdapterFactory: An adapter factory defines behavioral extensions for one or more classes that implements the `IAdaptable` interface.
IAdapterManager: An adapter manager maintains a registry of adapter factories.
IBundleGroup: Bundle groups represent a logical collection of plug-ins (aka bundles).
IBundleGroupProvider: Bundle group providers define groups of plug-ins which have been installed in the current system.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IContributor: This interface describes a registry contributor - an entity that supplies information to the extension registry.
IExtension: An extension declared in a plug-in.
IExtensionDelta: An extension delta represents changes to the extension registry.
IExtensionPoint: An extension point declared in a plug-in.
IExtensionRegistry: The extension registry holds the master list of all discovered namespaces, extension points and extensions.
ILog: A log to which status events can be written.
ILogListener: A log listener is notified of entries added to a plug-in's log.
InvalidRegistryObjectException: An unchecked exception indicating that an attempt to access an extension registry object that is no longer valid.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProduct: Products are the Eclipse unit of branding.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IProgressMonitorWithBlocking: Deprecated.
IRegistryChangeEvent: Registry change events describe changes to the extension registry.
IRegistryChangeListener: Note: for new implementations consider using `IRegistryEventListener`.
IRegistryEventListener: A registry event listener is notified of changes to extension points.
ISafeRunnable: Safe runnables represent blocks of code and associated exception handlers.
ISafeRunnableWithResult: Safe runnables represent blocks of code and associated exception handlers.
IStatus: A status object represents the outcome of an operation.
ListenerList: This class is a thread safe list that is designed for storing lists of listeners.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.
Path: The standard implementation of the `IPath` interface.
PerformanceStats: PerformanceStats collects and aggregates timing data about events such as a builder running, an editor opening, etc.
PerformanceStats.PerformanceListener: A performance listener is periodically notified after performance events occur or after events fail.
Plugin: The abstract superclass of all plug-in runtime class implementations.
PluginVersionIdentifier: Deprecated. clients should use `Version` instead
Preferences: Deprecated. This class is replaced by `IEclipsePreferences`.
Preferences.IPropertyChangeListener: Deprecated. Listener for property changes.
Preferences.PropertyChangeEvent: Deprecated. An event object describing a change to a named property.
ProgressMonitorWrapper: An abstract wrapper around a progress monitor which, unless overridden, forwards `IProgressMonitor` and `IProgressMonitorWithBlocking` methods to the wrapped progress monitor.
Status: A concrete status implementation, suitable either for instantiating or subclassing.
SubMonitor: A progress monitor that uses a given amount of work ticks from a parent monitor.

Classes in org.eclipse.core.runtime used by org.eclipse.core.runtime.content
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.core.runtime.dynamichelpers
IExtension: An extension declared in a plug-in.
IExtensionPoint: An extension point declared in a plug-in.
IExtensionRegistry: The extension registry holds the master list of all discovered namespaces, extension points and extensions.
IRegistryChangeEvent: Registry change events describe changes to the extension registry.
IRegistryChangeListener: Note: for new implementations consider using `IRegistryEventListener`.

Classes in org.eclipse.core.runtime used by org.eclipse.core.runtime.jobs
IAdaptable: An interface for an adaptable object.
ICoreRunnable: A functional interface for a runnable that can be cancelled and can report progress using the progress monitor passed to the `ICoreRunnable.run(IProgressMonitor)` method.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
MultiStatus: A concrete multi-status implementation, suitable either for instantiating or subclassing.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.core.runtime.preferences
CoreException: A checked exception representing a failure.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.runtime.spi
CoreException: A checked exception representing a failure.
IContributor: This interface describes a registry contributor - an entity that supplies information to the extension registry.
IExtensionRegistry: The extension registry holds the master list of all discovered namespaces, extension points and extensions.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.core.variables
CoreException: A checked exception representing a failure.
IStatus: A status object represents the outcome of an operation.
Plugin: The abstract superclass of all plug-in runtime class implementations.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.core
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
Plugin: The abstract superclass of all plug-in runtime class implementations.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.core.commands
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.core.model
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.core.sourcelookup
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.core.sourcelookup.containers
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.internal.ui.views.memory.renderings
IAdaptable: An interface for an adaptable object.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.ui
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.ui.actions
CoreException: A checked exception representing a failure.
ICoreRunnable: A functional interface for a runnable that can be cancelled and can report progress using the progress monitor passed to the `ICoreRunnable.run(IProgressMonitor)` method.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.ui.memory
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.debug.ui.sourcelookup
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.e4.ui.workbench.modeling
IAdapterFactory: An adapter factory defines behavioral extensions for one or more classes that implements the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.jsp.jasper.registry
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IExecutableExtensionFactory: This interface allows extension providers to control how the instances provided to extension-points are being created by referring to the factory instead of referring to a class.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.core
CoreException: A checked exception representing a failure.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.engine
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.engine.spi
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.operations
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
MultiStatus: A concrete multi-status implementation, suitable either for instantiating or subclassing.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.planner
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.query
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.repository
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.repository.artifact
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.repository.artifact.spi
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.repository.metadata
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.repository.metadata.spi
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.repository.spi
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.equinox.p2.ui
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.help.search
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.help.server
CoreException: A checked exception representing a failure.

Classes in org.eclipse.core.runtime used by org.eclipse.help.ui.browser
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.action
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.databinding.dialog
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.databinding.fieldassist
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.dialogs
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.operation
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IProgressMonitorWithBlocking: Deprecated.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.text.contentassist
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.text.hyperlink
IAdaptable: An interface for an adaptable object.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.text.quickassist
AssertionFailedException: `AssertionFailedException` is a runtime exception thrown by some of the methods in `Assert`.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.text.reconciler
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.text.templates
IAdaptable: An interface for an adaptable object.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.util
ISafeRunnable: Safe runnables represent blocks of code and associated exception handlers.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.jface.wizard
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IProgressMonitorWithBlocking: Deprecated.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.jsch.core
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.core.refactoring
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
ICoreRunnable: A functional interface for a runnable that can be cancelled and can report progress using the progress monitor passed to the `ICoreRunnable.run(IProgressMonitor)` method.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.core.refactoring.history
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.core.refactoring.model
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.core.refactoring.participants
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.core.refactoring.resource
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.ui.refactoring
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.ui.refactoring.history
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ltk.ui.refactoring.model
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.search.core.text
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
MultiStatus: A concrete multi-status implementation, suitable either for instantiating or subclassing.

Classes in org.eclipse.core.runtime used by org.eclipse.search.ui
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.

Classes in org.eclipse.core.runtime used by org.eclipse.search.ui.text
CoreException: A checked exception representing a failure.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
Status: A concrete status implementation, suitable either for instantiating or subclassing.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.diff
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.diff.provider
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.history
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.mapping
CoreException: A checked exception representing a failure.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.mapping.provider
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
Status: A concrete status implementation, suitable either for instantiating or subclassing.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.subscribers
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.synchronize
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.team.core.variants
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.team.ui
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IExtension: An extension declared in a plug-in.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.team.ui.history
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.team.ui.mapping
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.team.ui.synchronize
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.ui
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IExecutableExtensionFactory: This interface allows extension providers to control how the instances provided to extension-points are being created by referring to the factory instead of referring to a class.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.actions
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.activities
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.application
IAdaptable: An interface for an adaptable object.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.cheatsheets
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IExecutableExtensionFactory: This interface allows extension providers to control how the instances provided to extension-points are being created by referring to the factory instead of referring to a class.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.commands
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.console
IAdaptable: An interface for an adaptable object.
IStatus: A status object represents the outcome of an operation.
Plugin: The abstract superclass of all plug-in runtime class implementations.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.dialogs
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.editors.text
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
Preferences: Deprecated. This class is replaced by `IEclipsePreferences`.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.forms.editor
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.handlers
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.ide
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
OperationCanceledException: This exception is thrown to blow out of a long-running method when the user cancels it.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.ide.dialogs
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.ide.undo
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.internal.views.markers
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.intro
IAdaptable: An interface for an adaptable object.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.intro.config
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IRegistryChangeEvent: Registry change events describe changes to the extension registry.
IRegistryChangeListener: Note: for new implementations consider using `IRegistryEventListener`.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.intro.universal
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IExecutableExtensionFactory: This interface allows extension providers to control how the instances provided to extension-points are being created by referring to the factory instead of referring to a class.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.menus
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.model
IAdaptable: An interface for an adaptable object.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.navigator
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.navigator.resources
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.operations
IAdaptable: An interface for an adaptable object.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.part
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.plugin
CoreException: A checked exception representing a failure.
Plugin: The abstract superclass of all plug-in runtime class implementations.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.preferences
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.progress
IAdaptable: An interface for an adaptable object.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.
PlatformObject: An abstract superclass implementing the `IAdaptable` interface.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.splash
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.statushandlers
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IStatus: A status object represents the outcome of an operation.
QualifiedName: Qualified names are two-part names: qualifier and local name.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.testing
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.texteditor
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.texteditor.quickdiff
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.texteditor.rulers
CoreException: A checked exception representing a failure.
InvalidRegistryObjectException: An unchecked exception indicating that an attempt to access an extension registry object that is no longer valid.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.texteditor.spelling
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.texteditor.templates
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.themes
CoreException: A checked exception representing a failure.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views.bookmarkexplorer
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views.contentoutline
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views.markers
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views.navigator
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views.properties
IAdaptable: An interface for an adaptable object.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.
IExtension: An extension declared in a plug-in.
IExtensionPoint: An extension point declared in a plug-in.
IRegistryEventListener: A registry event listener is notified of changes to extension points.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.views.tasklist
IAdaptable: An interface for an adaptable object.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.wizards
CoreException: A checked exception representing a failure.
IAdaptable: An interface for an adaptable object.
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".

Classes in org.eclipse.core.runtime used by org.eclipse.ui.wizards.datatransfer
IPath: A path is an ordered collection of string segments, separated by a standard separator character, "/".
IProgressMonitor: The `IProgressMonitor` interface is implemented by objects that monitor the progress of an activity; the methods in this interface are invoked by code that performs the activity.
IStatus: A status object represents the outcome of an operation.

Classes in org.eclipse.core.runtime used by org.eclipse.ui.wizards.newresource
IConfigurationElement: A configuration element, with its attributes and children, directly reflects the content and structure of the extension section within the declaring plug-in's manifest (`plugin.xml`) file.
IExecutableExtension: Interface for executable extension classes that require access to their configuration element, or implement an extension adapter.