Eclipse Platform
Release 3.0

Uses of Interface
org.eclipse.core.runtime.IAdaptable

Packages that use IAdaptable
org.eclipse.compare Provides support for performing structural and textual compare operations on arbitrary data and displaying the results.  
org.eclipse.core.internal.jobs   
org.eclipse.core.internal.resources   
org.eclipse.core.resources Provides basic support for managing a workspace and its resources.  
org.eclipse.core.runtime Provides core support for plug-ins and the plug-in registry.  
org.eclipse.core.runtime.jobs Provides core support for scheduling and interacting with background activity.  
org.eclipse.debug.core Provides support for launching programs, breakpoint management, expression management, and debug events. 
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.core.sourcelookup.containers   
org.eclipse.debug.ui Provides a generic debugger user interface that clients may customize via standard workbench extension points. 
org.eclipse.search.ui Provides classes and interfaces to run search queries and manage their results.  
org.eclipse.team.core Application programming interfaces for defining and working with repository providers.  
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.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.application Application-level APIs for configuring and controling the Eclipse Platform User Interface.  
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.intro Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.  
org.eclipse.ui.intro.config   
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.part Classes for the creation of workbench parts that integrate with the Eclipse Platform User Interface.  
org.eclipse.ui.progress Application programming interfaces for interaction with and extension of the Eclipse Platform User Interface.  
org.eclipse.ui.texteditor Provides a framework for text editors obeying to the desktop rules.  
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.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.update.configuration Provides support for accessing local installation information.  
org.eclipse.update.core Provides support for extending the base installation and update services.  
org.eclipse.update.core.model Provides model support for extending the base installation and update services.  
 

Uses of IAdaptable in org.eclipse.compare
 

Classes in org.eclipse.compare that implement IAdaptable
 class CompareEditorInput
          A compare operation which can present its results in a special editor.
 

Methods in org.eclipse.compare with parameters of type IAdaptable
static Image CompareUI.getImage(IAdaptable adaptable)
          Returns a shared image for the given adaptable.
 

Uses of IAdaptable in org.eclipse.core.internal.jobs
 

Classes in org.eclipse.core.internal.jobs that implement IAdaptable
 class org.eclipse.core.internal.jobs.InternalJob
          Internal implementation class for jobs.
 

Uses of IAdaptable in org.eclipse.core.internal.resources
 

Classes in org.eclipse.core.internal.resources that implement IAdaptable
 class org.eclipse.core.internal.resources.InternalWorkspaceJob
          Batches the activity of a job as a single operation, without obtaining the workspace lock.
 

Uses of IAdaptable in org.eclipse.core.resources
 

Subinterfaces of IAdaptable in org.eclipse.core.resources
 interface IContainer
          Interface for resources which may contain other resources (termed its members).
 interface IEncodedStorage
          A storage that knows how its contents are encoded.
 interface IFile
          Files are leaf resources which contain data.
 interface IFileState
          A previous state of a file stored in the workspace's local history.
 interface IFolder
          Folders may be leaf or non-leaf resources and may contain files and/or other folders.
 interface IMarker
          Markers are a general mechanism for associating notes and metadata with resources.
 interface IProject
          A project is a type of resource which groups resources into buildable, reusable units.
 interface IResource
          The workspace analog of file system files and directories.
 interface IResourceDelta
          A resource delta represents changes in the state of a resource tree between two discrete points in time.
 interface IStorage
          A storage object represents a set of bytes which can be accessed.
 interface IWorkspace
          Workspaces are the basis for Eclipse Platform resource management.
 interface IWorkspaceRoot
          A root resource represents the top of the resource hierarchy in a workspace.
 

Classes in org.eclipse.core.resources that implement IAdaptable
 class WorkspaceJob
          A job that makes an atomic modification to the workspace.
 

Uses of IAdaptable in org.eclipse.core.runtime
 

Classes in org.eclipse.core.runtime that implement IAdaptable
 class PlatformObject
          An abstract superclass implementing the IAdaptable interface.
 

Uses of IAdaptable in org.eclipse.core.runtime.jobs
 

Classes in org.eclipse.core.runtime.jobs that implement IAdaptable
 class Job
          Jobs are units of runnable work that can be scheduled to be run with the job manager.
 

Uses of IAdaptable in org.eclipse.debug.core
 

Subinterfaces of IAdaptable in org.eclipse.debug.core
 interface ILaunch
          A launch is the result of launching a debug session and/or one or more system processes.
 interface ILaunchConfiguration
          A launch configuration describes how to launch an application.
 interface ILaunchConfigurationType
          Describes and creates instances of a specific type of launch configuration.
 interface ILaunchConfigurationWorkingCopy
          An editable copy of a launch configuration.
 

Classes in org.eclipse.debug.core that implement IAdaptable
 class Launch
          A launch is the result of launching a debug session and/or one or more system processes.
 

Uses of IAdaptable in org.eclipse.debug.core.model
 

Subinterfaces of IAdaptable in org.eclipse.debug.core.model
 interface IBreakpoint
          A breakpoint is capable of suspending the execution of a program at a specific location when a program is running in debug mode.
 interface IDebugElement
          A debug element represents an artifact in a program being debugged.
 interface IDebugTarget
          A debug target is a debuggable execution context.
 interface IErrorReportingExpression
          An expression that can report errors which occurred during the expression's evaluation.
 interface IExpression
          An expression is a snippet of code that can be evaluated to produce a value.
 interface IIndexedValue
          A value containing an indexed collection of variables - for example, an array.
 interface ILineBreakpoint
          A breakpoint that can be located at a specific line of source code.
 interface IMemoryBlock
          A contiguous segment of memory in an execution context.
 interface IProcess
          A process represents a program running in normal (non-debug) mode.
 interface IRegister
          A register is a special kind of variable that is contained in a register group.
 interface IRegisterGroup
          A register group is a group of registers that are assigned to a stack frame.
 interface IStackFrame
          A stack frame represents an execution context in a suspended thread.
 interface IThread
          A thread is a sequential flow of execution in a debug target.
 interface IValue
          A value represents the value of a variable.
 interface IVariable
          A variable represents a visible data structure in a stack frame or value.
 interface IWatchExpression
          A watch expression is an expression that is evaluated in the context of a specific stack frame, thread, debug target, process, or launch.
 

Classes in org.eclipse.debug.core.model that implement IAdaptable
 class Breakpoint
          Abstract implementation of a breakpoint.
 class LineBreakpoint
          Abstract implementation of a line breakpoint.
 class RuntimeProcess
          Standard implementation of an IProcess that wrappers a system process (java.lang.Process).
 

Uses of IAdaptable in org.eclipse.debug.core.sourcelookup
 

Subinterfaces of IAdaptable in org.eclipse.debug.core.sourcelookup
 interface ISourceContainer
          A source container is a container of source code.
 

Uses of IAdaptable in org.eclipse.debug.core.sourcelookup.containers
 

Classes in org.eclipse.debug.core.sourcelookup.containers that implement IAdaptable
 class AbstractSourceContainer
          Common function for source containers.
 class ArchiveSourceContainer
          Archive source container for an archive in the workspace.
 class CompositeSourceContainer
          A source container of source containers.
 class DefaultSourceContainer
          A source container that computers the default source lookup path for a launch configuration on each launch using a launch configuration's associated source path computer.
 class DirectorySourceContainer
          A directory in the local file system.
 class ExternalArchiveSourceContainer
          An archive in the local file system.
 class FolderSourceContainer
          A folder in the workspace.
 class LocalFileStorage
          Implementation of storage for a local file (java.io.File).
 class ProjectSourceContainer
          A project in the workspace.
 class WorkspaceSourceContainer
          All projects in the workspace.
 class ZipEntryStorage
          Storage implementation for zip entries.
 

Uses of IAdaptable in org.eclipse.debug.internal.core.sourcelookup.containers
 

Classes in org.eclipse.debug.internal.core.sourcelookup.containers that implement IAdaptable
 class org.eclipse.debug.internal.core.sourcelookup.containers.ContainerSourceContainer
          A container in the workspace.
 

Uses of IAdaptable in org.eclipse.debug.ui
 

Subinterfaces of IAdaptable in org.eclipse.debug.ui
 interface IDebugView
          Common function for debug views.
 

Classes in org.eclipse.debug.ui that implement IAdaptable
 class AbstractDebugView
          Common function for views related to debugging.
 

Methods in org.eclipse.debug.ui that return IAdaptable
static IAdaptable DebugUITools.getDebugContext()
          Returns the currently selected element in the debug view of the current workbench page, or null if there is no current debug context, or if not called from the UI thread.
 

Uses of IAdaptable in org.eclipse.search.ui
 

Subinterfaces of IAdaptable in org.eclipse.search.ui
 interface ISearchResultView
          Deprecated. Use ISearchResultViewPart instead.
 interface ISearchResultViewPart
           Interface for the search result view.
 

Uses of IAdaptable in org.eclipse.team.core
 

Classes in org.eclipse.team.core that implement IAdaptable
 class RepositoryProvider
          A concrete subclass of RepositoryProvider is created for each project that is associated with a repository provider.
 

Uses of IAdaptable in org.eclipse.team.core.synchronize
 

Classes in org.eclipse.team.core.synchronize that implement IAdaptable
 class SyncInfo
          Describes the synchronization of a local resource relative to a remote resource variant.
 

Uses of IAdaptable in org.eclipse.team.core.variants
 

Classes in org.eclipse.team.core.variants that implement IAdaptable
 class CachedResourceVariant
          A resource variant is a partial implementation of a remote resource whose contents and handle are cached locally.
 

Uses of IAdaptable in org.eclipse.team.ui
 

Subinterfaces of IAdaptable in org.eclipse.team.ui
 interface ISaveableWorkbenchPart
          A saveable workbench part is a visual component that can be shown within different contexts (e.g a dialog, workbench page).
 

Classes in org.eclipse.team.ui that implement IAdaptable
 class SaveablePartAdapter
          This adapter provides default implementations for methods on ISaveableWorkbenchPart and IWorkbenchPart.
 

Uses of IAdaptable in org.eclipse.team.ui.synchronize
 

Subinterfaces of IAdaptable in org.eclipse.team.ui.synchronize
 interface ISynchronizeView
          A view that displays synchronization participants that are registered with the synchronize manager.
 

Classes in org.eclipse.team.ui.synchronize that implement IAdaptable
 class ParticipantPageSaveablePart
          Displays a synchronize participant page combined with the compare/merge infrastructured.
 class SyncInfoCompareInput
          A SyncInfo editor input used as input to a two-way or three-way compare viewer.
 

Uses of IAdaptable in org.eclipse.ui
 

Subinterfaces of IAdaptable in org.eclipse.ui
 interface IEditorInput
          IEditorInput is a light weight descriptor of editor input, like a file name but more abstract.
 interface IEditorPart
          An editor is a visual component within a workbench page.
 interface IEditorSite
          The primary interface between an editor part and the workbench.
 interface IFileEditorInput
          This interface defines a file-oriented input to an editor.
 interface IInPlaceEditor
          Interface for editor parts that represent an in-place style editor.
 interface IInPlaceEditorInput
          This interface defines an editor input for in-place editors.
 interface IPathEditorInput
          This interface defines an editor input based on the local file system path of a file.
 interface IReusableEditor
          Interface for reusable editors.
 interface IStorageEditorInput
          Interface for a IStorage input to an editor.
 interface IViewPart
          A view is a visual component within a workbench page.
 interface IViewSite
          The primary interface between a view part and the workbench.
 interface IWorkbenchPart
          A workbench part is a visual component within a workbench page.
 interface IWorkbenchPart2
          Extends IWorkbenchPart, adding the name and status text properties.
 interface IWorkbenchPartSite
          The primary interface between a workbench part and the workbench.
 interface IWorkbenchSite
          The common interface between the workbench and its parts, including pages within parts.
 

Methods in org.eclipse.ui that return IAdaptable
 IAdaptable IElementFactory.createElement(IMemento memento)
          Re-creates and returns an object from the state captured within the given memento.
 IAdaptable IWorkbenchPropertyPage.getElement()
          Returns the object that owns the properties shown in this page.
 IAdaptable IWorkbenchPage.getInput()
          Returns the input for this page.
 IAdaptable[] IWorkingSet.getElements()
          Returns the elements that are contained in this working set.
 

Methods in org.eclipse.ui with parameters of type IAdaptable
 void IWorkbenchPropertyPage.setElement(IAdaptable element)
          Sets the object that owns the properties shown in this page.
 IWorkingSet IWorkingSetManager.createWorkingSet(String name, IAdaptable[] elements)
          Creates a new working set.
 IWorkbenchPage IWorkbenchWindow.openPage(String perspectiveId, IAdaptable input)
          Creates and opens a new workbench page.
 IWorkbenchPage IWorkbenchWindow.openPage(IAdaptable input)
          Creates and opens a new workbench page.
 IWorkbenchWindow IWorkbench.openWorkbenchWindow(String perspectiveId, IAdaptable input)
          Creates and opens a new workbench window with one page.
 IWorkbenchWindow IWorkbench.openWorkbenchWindow(IAdaptable input)
          Creates and opens a new workbench window with one page.
 IWorkbenchPage IWorkbench.showPerspective(String perspectiveId, IWorkbenchWindow window, IAdaptable input)
          Shows the specified perspective to the user.
 void IWorkingSet.setElements(IAdaptable[] elements)
          Sets the elements that are contained in this working set.
 IResource IContributorResourceAdapter.getAdaptedResource(IAdaptable adaptable)
          Return the resource that the supplied adaptable adapts to.
 

Uses of IAdaptable in org.eclipse.ui.actions
 

Methods in org.eclipse.ui.actions with parameters of type IAdaptable
 void OpenPerspectiveMenu.setPageInput(IAdaptable input)
          Deprecated. Sets the page input.
 void OpenNewPageMenu.setPageInput(IAdaptable input)
          Deprecated. Sets the page input.
 void OpenNewWindowMenu.setPageInput(IAdaptable input)
          Deprecated. Sets the page input.
 void OpenInNewWindowAction.setPageInput(IAdaptable input)
          Set the input to use for the new window's page.
 

Constructors in org.eclipse.ui.actions with parameters of type IAdaptable
OpenPerspectiveMenu(IWorkbenchWindow window, IAdaptable input)
          Deprecated. Constructs a new instance of OpenNewPageMenu.
OpenNewPageMenu(IWorkbenchWindow window, IAdaptable input)
          Deprecated. Constructs a new instance of OpenNewPageMenu.
OpenNewWindowMenu(IWorkbenchWindow window, IAdaptable input)
          Deprecated. Constructs a new instance of OpenNewPageMenu.
OpenInNewWindowAction(IWorkbenchWindow window, IAdaptable input)
          Creates a new OpenInNewWindowAction.
OpenWithMenu(IWorkbenchPage page, IAdaptable file)
          Constructs a new instance of OpenWithMenu.
 

Uses of IAdaptable in org.eclipse.ui.application
 

Methods in org.eclipse.ui.application that return IAdaptable
 IAdaptable WorkbenchAdvisor.getDefaultPageInput()
          Returns the default input for newly created workbench pages.
 

Uses of IAdaptable in org.eclipse.ui.console
 

Subinterfaces of IAdaptable in org.eclipse.ui.console
 interface IConsoleView
          A view that displays consoles registered with the console manager.
 

Uses of IAdaptable in org.eclipse.ui.dialogs
 

Classes in org.eclipse.ui.dialogs that implement IAdaptable
 class FileSystemElement
          Instances of this class represent files or file-like entities (eg.- zip file entries) on the local file system.
 

Methods in org.eclipse.ui.dialogs that return IAdaptable
 IAdaptable PropertyPage.getElement()
           
 

Methods in org.eclipse.ui.dialogs with parameters of type IAdaptable
 void PropertyPage.setElement(IAdaptable element)
          Sets the element that owns properties shown on this page.
protected  Object[] WizardExportPage.queryIndividualResourcesToExport(IAdaptable rootResource)
          Deprecated. Queries the user for the individual resources that are to be exported and returns these resources as a collection.
 

Constructors in org.eclipse.ui.dialogs with parameters of type IAdaptable
ResourceSelectionDialog(Shell parentShell, IAdaptable rootElement, String message)
          Creates a resource selection dialog rooted at the given element.
 

Uses of IAdaptable in org.eclipse.ui.editors.text
 

Classes in org.eclipse.ui.editors.text that implement IAdaptable
 class TextEditor
          The standard text editor for file resources (IFile).
 

Uses of IAdaptable in org.eclipse.ui.forms.editor
 

Subinterfaces of IAdaptable in org.eclipse.ui.forms.editor
 interface IFormPage
          Interface that all GUI pages need to implement in order to be added to FormEditor part.
 

Classes in org.eclipse.ui.forms.editor that implement IAdaptable
 class FormEditor
          This class forms a base of multi-page form editors that typically use one or more pages with forms and one page for raw source of the editor input.
 class FormPage
          A base class that all pages that should be added to FormEditor must subclass.
 

Uses of IAdaptable in org.eclipse.ui.intro
 

Subinterfaces of IAdaptable in org.eclipse.ui.intro
 interface IIntroPart
          The intro part is a visual component within the workbench responsible for introducing the product to new users.
 interface IIntroSite
          The primary interface between an intro part and the workbench.
 

Uses of IAdaptable in org.eclipse.ui.intro.config
 

Classes in org.eclipse.ui.intro.config that implement IAdaptable
 class CustomizableIntroPart
          A re-usable intro part that the Eclipse platform uses for its Out of the Box Experience.
 

Uses of IAdaptable in org.eclipse.ui.model
 

Classes in org.eclipse.ui.model that implement IAdaptable
 class AdaptableList
          A modifiable list of IAdaptable objects.
 

Methods in org.eclipse.ui.model with parameters of type IAdaptable
 AdaptableList AdaptableList.add(IAdaptable adaptable)
          Adds the given adaptable object to this list.
 void AdaptableList.remove(IAdaptable adaptable)
          Removes the given adaptable object from this list.
 

Constructors in org.eclipse.ui.model with parameters of type IAdaptable
AdaptableList(IAdaptable[] newChildren)
          Creates a new adaptable list containing the given children.
 

Uses of IAdaptable in org.eclipse.ui.part
 

Subinterfaces of IAdaptable in org.eclipse.ui.part
 interface IPageSite
          The primary interface between a page and the outside world.
 

Classes in org.eclipse.ui.part that implement IAdaptable
 class EditorPart
          Abstract base implementation of all workbench editors.
 class FileEditorInput
          Adapter for making a file resource a suitable input for an editor.
 class FileInPlaceEditorInput
          Adapter for making a file resource a suitable input for an in-place editor.
 class IntroPart
          Abstract base implementation of an intro part.
 class MultiEditor
          A MultiEditor is a composite of editors.
 class MultiEditorInput
          Implements a input for a MultiEditor.
 class MultiPageEditor
          Deprecated. Use the class MultiPageEditorPart instead
 class MultiPageEditorPart
          A multi-page editor is an editor with multiple pages, each of which may contain an editor or an arbitrary SWT control.
 class MultiPageEditorSite
          Site for a nested editor within a multi-page editor.
 class PageBookView
          Abstract superclass of all multi-page workbench views.
 class PageSite
          This implementation of IPageSite provides a site for a page within a PageBookView.
 class ViewPart
          Abstract base implementation of all workbench views.
 class WorkbenchPart
          Abstract base implementation of all workbench parts.
 

Methods in org.eclipse.ui.part that return IAdaptable
 IAdaptable FileEditorInputFactory.createElement(IMemento memento)
           
 IAdaptable FileEditorInputFactory.createElement(IMemento memento)
           
 

Uses of IAdaptable in org.eclipse.ui.progress
 

Classes in org.eclipse.ui.progress that implement IAdaptable
 class UIJob
          The UIJob is a Job that runs within the UI Thread via an asyncExec.
 class WorkbenchJob
          WorkbenchJob is a type of job that implements a done listener and does the shutdown checks before scheduling.
 

Uses of IAdaptable in org.eclipse.ui.texteditor
 

Subinterfaces of IAdaptable in org.eclipse.ui.texteditor
 interface ITextEditor
          Interface to a text editor.
 

Classes in org.eclipse.ui.texteditor that implement IAdaptable
 class AbstractDecoratedTextEditor
          An intermediate editor comprising functionality not present in the leaner AbstractTextEditor, but used in many heavy weight (and especially source editing) editors, such as line numbers, change ruler, overview ruler, print margins, current line highlighting, etc.
 class AbstractTextEditor
          Abstract base implementation of a text editor.
 class StatusTextEditor
          Capable of handling input elements that have an associated status with them.
 

Uses of IAdaptable in org.eclipse.ui.views.bookmarkexplorer
 

Classes in org.eclipse.ui.views.bookmarkexplorer that implement IAdaptable
 class BookmarkNavigator
          Main class for the bookmark navigator for displaying bookmarks on resources and opening an editor on the bookmarked resource when the user commands.
 

Uses of IAdaptable in org.eclipse.ui.views.contentoutline
 

Classes in org.eclipse.ui.views.contentoutline that implement IAdaptable
 class ContentOutline
          Main class for the Content Outline View.
 

Uses of IAdaptable in org.eclipse.ui.views.navigator
 

Subinterfaces of IAdaptable in org.eclipse.ui.views.navigator
 interface IResourceNavigator
          This interface defines the API for the resource navigator.
 

Classes in org.eclipse.ui.views.navigator that implement IAdaptable
 class ResourceNavigator
          Implements the Resource Navigator view.
 

Methods in org.eclipse.ui.views.navigator that return IAdaptable
protected  IAdaptable ResourceNavigator.getInitialInput()
          Returns the initial input for the viewer.
 

Uses of IAdaptable in org.eclipse.ui.views.properties
 

Classes in org.eclipse.ui.views.properties that implement IAdaptable
 class PropertySheet
          Main class for the Property Sheet View.
 

Uses of IAdaptable in org.eclipse.ui.views.tasklist
 

Classes in org.eclipse.ui.views.tasklist that implement IAdaptable
 class TaskList
          Main class for the Task List view for displaying tasks and problem annotations on resources, and for opening an editor on the resource when the user commands.
 

Methods in org.eclipse.ui.views.tasklist with parameters of type IAdaptable
 IResource ITaskListResourceAdapter.getAffectedResource(IAdaptable adaptable)
          Returns the resource to query for the markers to display for the given adaptable.
 

Uses of IAdaptable in org.eclipse.update.configuration
 

Subinterfaces of IAdaptable in org.eclipse.update.configuration
 interface IActivity
          Install activity.
 interface IConfiguredSite
          Configured Site.
 interface IInstallConfiguration
          Installation configuration.
 interface ILocalSite
          Local Site.
 interface ISessionDelta
          Deprecated. Do not use this interface
 interface IVolume
          Local Volume Info.
 

Uses of IAdaptable in org.eclipse.update.core
 

Subinterfaces of IAdaptable in org.eclipse.update.core
 interface IArchiveReference
          Site archive interface.
 interface ICategory
          Feature category definition.
 interface IFeature
          Feature defines the packaging "container" for a group of related plug-ins, plug-in fragments, and optionally non-plug-in files.
 interface IFeatureReference
          Feature reference.
 interface IImport
          Plug-in dependency entry.
 interface IIncludedFeatureReference
          Included Feature reference.
 interface IInstallHandlerEntry
          Install handler entry.
 interface INonPluginEntry
          Non-plug-in entry defines an arbitrary non-plug-in data file packaged as part of a feature.
 interface IPlatformEnvironment
          Plug-in entry defines a packaging reference from a feature to a plug-in.
 interface IPluginEntry
          Plug-in entry defines a packaging reference from a feature to a plug-in.
 interface ISite
          Site represents a location containing some number of features (packaged or installed).
 interface ISiteFeatureReference
          Site Feature reference.
 interface IURLEntry
          URL entry is an annotated URL object.
 

Classes in org.eclipse.update.core that implement IAdaptable
 class ArchiveReference
          Convenience implementation of a site archive.
 class Category
          Convenience implementation of feature category definition.
 class Feature
          Convenience implementation of a feature.
 class FeatureReference
          Convenience implementation of a feature reference.
 class Import
          Convenience implementation of a plug-in dependency.
 class IncludedFeatureReference
          This is a utility class representing the options of a nested feature.
 class InstallHandlerEntry
          Convenience implementation of an install handler entry.
 class NonPluginEntry
          Convenience implementation of non-plug-in entry.
 class PluginEntry
          Convenience implementation of plug-in entry.
 class Site
          Convenience implementation of a site.
 class SiteFeatureReference
          Convenience implementation of a feature reference.
 class SiteFeatureReferenceModel
          Site Feature reference model object.
 class URLEntry
          Convenience implementation of an annotated URL.
 

Uses of IAdaptable in org.eclipse.update.core.model
 

Classes in org.eclipse.update.core.model that implement IAdaptable
 class ArchiveReferenceModel
          Site archive model object.
 class CategoryModel
          Feature category definition model object.
 class ContentEntryModel
          Content entry model object.
 class FeatureModel
          Feature model object.
 class FeatureReferenceModel
          Feature reference model object.
 class ImportModel
          Plug-in dependency model object.
 class IncludedFeatureReferenceModel
          Included Feature reference model object.
 class InstallHandlerEntryModel
          Install handler entry model object.
 class ModelObject
          Root model object.
 class NonPluginEntryModel
          Non-plug-in entry model object.
 class PluginEntryModel
          Plug-in entry model object.
 class SiteModel
          Site model object.
 class URLEntryModel
          Annotated URL model object.
 


Eclipse Platform
Release 3.0

Guidelines for using Eclipse APIs.

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