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

## org.eclipse.jdt.core
Interface ITypeHierarchy

public interface ITypeHierarchy

A type hierarchy provides navigations between a type and its resolved supertypes and subtypes for a specific type or for all types within a region. Supertypes may extend outside of the type hierarchy's region in which it was created such that the root of the hierarchy is always included. For example, if a type hierarchy is created for a `java.io.File`, and the region the hierarchy was created in is the package fragment `java.io`, the supertype `java.lang.Object` will still be included.

A type hierarchy is static and can become stale. Although consistent when created, it does not automatically track changes in the model. As changes in the model potentially invalidate the hierarchy, change notifications are sent to registered `ITypeHierarchyChangedListener`s. Listeners should use the `exists` method to determine if the hierarchy has become completely invalid (for example, when the type or project the hierarchy was created on has been removed). To refresh a hierarchy, use the `refresh` method.

The type hierarchy may contain cycles due to malformed supertype declarations. Most type hierarchy queries are oblivious to cycles; the `getAll*` methods are implemented such that they are unaffected by cycles.

This interface is not intended to be implemented by clients.

Method Summary
`void` | `addTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)` Adds the given listener for changes to this type hierarchy.
`boolean` | `contains(IType type)` Returns whether the given type is part of this hierarchy.
`boolean` | `exists()` Returns whether the type and project this hierarchy was created on exist.
`IType[]` | `getAllClasses()` Returns all classes in this type hierarchy's graph, in no particular order.
`IType[]` | `getAllInterfaces()` Returns all interfaces in this type hierarchy's graph, in no particular order.
`IType[]` | `getAllSubtypes(IType type)` Returns all resolved subtypes (direct and indirect) of the given type, in no particular order, limited to the types in this type hierarchy's graph.
`IType[]` | `getAllSuperclasses(IType type)` Returns all resolved superclasses of the given class, in bottom-up order.
`IType[]` | `getAllSuperInterfaces(IType type)` Returns all resolved superinterfaces (direct and indirect) of the given type.
`IType[]` | `getAllSupertypes(IType type)` Returns all resolved supertypes of the given type, in bottom-up order.
`IType[]` | `getAllTypes()` Returns all types in this type hierarchy's graph, in no particular order.
`int` | `getCachedFlags(IType type)` Return the flags associated with the given type (would be equivalent to `IMember.getFlags()`), or `-1` if this information wasn't cached on the hierarchy during its computation.
`IType[]` | `getExtendingInterfaces(IType type)` Returns all interfaces resolved to extend the given interface, in no particular order, limited to the interfaces in this hierarchy's graph.
`IType[]` | `getImplementingClasses(IType type)` Returns all classes resolved to implement the given interface, in no particular order, limited to the classes in this type hierarchy's graph.
`IType[]` | `getRootClasses()` Returns all classes in the graph which have no resolved superclass, in no particular order.
`IType[]` | `getRootInterfaces()` Returns all interfaces in the graph which have no resolved superinterfaces, in no particular order.
`IType[]` | `getSubclasses(IType type)` Returns the direct resolved subclasses of the given class, in no particular order, limited to the classes in this type hierarchy's graph.
`IType[]` | `getSubtypes(IType type)` Returns the direct resolved subtypes of the given type, in no particular order, limited to the types in this type hierarchy's graph.
`IType` | `getSuperclass(IType type)` Returns the resolved superclass of the given class, or `null` if the given class has no superclass, the superclass could not be resolved, or if the given type is an interface.
`IType[]` | `getSuperInterfaces(IType type)` Returns the direct resolved interfaces that the given type implements or extends, in no particular order, limited to the interfaces in this type hierarchy's graph.
`IType[]` | `getSupertypes(IType type)` Returns the resolved supertypes of the given type, in no particular order, limited to the types in this type hierarchy's graph.
`IType` | `getType()` Returns the type this hierarchy was computed for.
`void` | `refresh(IProgressMonitor monitor)` Re-computes the type hierarchy reporting progress.
`void` | `removeTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)` Removes the given listener from this type hierarchy.
`void` | `store(OutputStream outputStream, IProgressMonitor monitor)` Stores the type hierarchy in an output stream.

Method Detail

### addTypeHierarchyChangedListener

    public void addTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)

  Adds the given listener for changes to this type hierarchy. Listeners are notified when this type hierarchy changes and needs to be refreshed. Has no effect if an identical listener is already registered.

  Parameters:
    `listener` - the listener

### contains

    public boolean contains(IType type)

  Returns whether the given type is part of this hierarchy.

  Parameters:
    `type` - the given type
  Returns:
    true if the given type is part of this hierarchy, false otherwise

### exists

    public boolean exists()

  Returns whether the type and project this hierarchy was created on exist.

  Returns:
    true if the type and project this hierarchy was created on exist, false otherwise

### getAllClasses

    public IType[] getAllClasses()

  Returns all classes in this type hierarchy's graph, in no particular order. Any classes in the creation region which were not resolved to have any subtypes or supertypes are not included in the result.

  Returns:
    all classes in this type hierarchy's graph

### getAllInterfaces

    public IType[] getAllInterfaces()

  Returns all interfaces in this type hierarchy's graph, in no particular order. Any interfaces in the creation region which were not resolved to have any subtypes or supertypes are not included in the result.

  Returns:
    all interfaces in this type hierarchy's graph

### getAllSubtypes

    public IType[] getAllSubtypes(IType type)

  Returns all resolved subtypes (direct and indirect) of the given type, in no particular order, limited to the types in this type hierarchy's graph. An empty array is returned if there are no resolved subtypes for the given type.

  Parameters:
    `type` - the given type
  Returns:
    all resolved subtypes (direct and indirect) of the given type

### getAllSuperclasses

    public IType[] getAllSuperclasses(IType type)

  Returns all resolved superclasses of the given class, in bottom-up order. An empty array is returned if there are no resolved superclasses for the given class.

  NOTE: once a type hierarchy has been created, it is more efficient to query the hierarchy for superclasses than to query a class recursively up the superclass chain. Querying an element performs a dynamic resolution, whereas the hierarchy returns a pre-computed result.

  Parameters:
    `type` - the given type
  Returns:
    all resolved superclasses of the given class, in bottom-up order, an empty array if none.

### getAllSuperInterfaces

    public IType[] getAllSuperInterfaces(IType type)

  Returns all resolved superinterfaces (direct and indirect) of the given type. If the given type is a class, this includes all superinterfaces of all superclasses. An empty array is returned if there are no resolved superinterfaces for the given type.

  NOTE: once a type hierarchy has been created, it is more efficient to query the hierarchy for superinterfaces than to query a type recursively. Querying an element performs a dynamic resolution, whereas the hierarchy returns a pre-computed result.

  Parameters:
    `type` - the given type
  Returns:
    all resolved superinterfaces (direct and indirect) of the given type, an empty array if none

### getAllSupertypes

    public IType[] getAllSupertypes(IType type)

  Returns all resolved supertypes of the given type, in bottom-up order. An empty array is returned if there are no resolved supertypes for the given type.

  Note that `java.lang.Object` is NOT considered to be a supertype of any interface type.

  NOTE: once a type hierarchy has been created, it is more efficient to query the hierarchy for supertypes than to query a type recursively up the supertype chain. Querying an element performs a dynamic resolution, whereas the hierarchy returns a pre-computed result.

  Parameters:
    `type` - the given type
  Returns:
    all resolved supertypes of the given class, in bottom-up order, an empty array if none

### getAllTypes

    public IType[] getAllTypes()

  Returns all types in this type hierarchy's graph, in no particular order. Any types in the creation region which were not resolved to have any subtypes or supertypes are not included in the result.

  Returns:
    all types in this type hierarchy's grap

### getCachedFlags

    public int getCachedFlags(IType type)

  Return the flags associated with the given type (would be equivalent to `IMember.getFlags()`), or `-1` if this information wasn't cached on the hierarchy during its computation.

  Parameters:
    `type` - the given type
  Returns:
    the modifier flags for this member
  Since:
    2.0
  See Also:
    `Flags`

### getExtendingInterfaces

    public IType[] getExtendingInterfaces(IType type)

  Returns all interfaces resolved to extend the given interface, in no particular order, limited to the interfaces in this hierarchy's graph. Returns an empty collection if the given type is a class, or if no interfaces were resolved to extend the given interface.

  Parameters:
    `type` - the given type
  Returns:
    all interfaces resolved to extend the given interface limited to the interfaces in this hierarchy's graph, an empty array if none.

### getImplementingClasses

    public IType[] getImplementingClasses(IType type)

  Returns all classes resolved to implement the given interface, in no particular order, limited to the classes in this type hierarchy's graph. Returns an empty collection if the given type is a class, or if no classes were resolved to implement the given interface.

  Parameters:
    `type` - the given type
  Returns:
    all classes resolved to implement the given interface limited to the classes in this type hierarchy's graph, an empty array if none

### getRootClasses

    public IType[] getRootClasses()

  Returns all classes in the graph which have no resolved superclass, in no particular order.

  Returns:
    all classes in the graph which have no resolved superclass

### getRootInterfaces

    public IType[] getRootInterfaces()

  Returns all interfaces in the graph which have no resolved superinterfaces, in no particular order.

  Returns:
    all interfaces in the graph which have no resolved superinterfaces

### getSubclasses

    public IType[] getSubclasses(IType type)

  Returns the direct resolved subclasses of the given class, in no particular order, limited to the classes in this type hierarchy's graph. Returns an empty collection if the given type is an interface, or if no classes were resolved to be subclasses of the given class.

  Parameters:
    `type` - the given type
  Returns:
    the direct resolved subclasses of the given class limited to the classes in this type hierarchy's graph, an empty collection if none.

### getSubtypes

    public IType[] getSubtypes(IType type)

  Returns the direct resolved subtypes of the given type, in no particular order, limited to the types in this type hierarchy's graph. If the type is a class, this returns the resolved subclasses. If the type is an interface, this returns both the classes which implement the interface and the interfaces which extend it.

  Parameters:
    `type` - the given type
  Returns:
    the direct resolved subtypes of the given type limited to the types in this type hierarchy's graph

### getSuperclass

    public IType getSuperclass(IType type)

  Returns the resolved superclass of the given class, or `null` if the given class has no superclass, the superclass could not be resolved, or if the given type is an interface.

  Parameters:
    `type` - the given type
  Returns:
    the resolved superclass of the given class, or `null` if the given class has no superclass, the superclass could not be resolved, or if the given type is an interface

### getSuperInterfaces

    public IType[] getSuperInterfaces(IType type)

  Returns the direct resolved interfaces that the given type implements or extends, in no particular order, limited to the interfaces in this type hierarchy's graph. For classes, this gives the interfaces that the class implements. For interfaces, this gives the interfaces that the interface extends.

  Parameters:
    `type` - the given type
  Returns:
    the direct resolved interfaces that the given type implements or extends limited to the interfaces in this type hierarchy's graph

### getSupertypes

    public IType[] getSupertypes(IType type)

  Returns the resolved supertypes of the given type, in no particular order, limited to the types in this type hierarchy's graph. For classes, this returns its superclass and the interfaces that the class implements. For interfaces, this returns the interfaces that the interface extends. As a consequence `java.lang.Object` is NOT considered to be a supertype of any interface type.

  Parameters:
    `type` - the given type
  Returns:
    the resolved supertypes of the given type limited to the types in this type hierarchy's graph

### getType

    public IType getType()

  Returns the type this hierarchy was computed for. Returns `null` if this hierarchy was computed for a region.

  Returns:
    the type this hierarchy was computed for

### refresh

    public void refresh(IProgressMonitor monitor)
                 throws JavaModelException

  Re-computes the type hierarchy reporting progress.

  Parameters:
    `monitor` - the given progress monitor
  Throws:
    `JavaModelException` - if unable to refresh the hierarchy

### removeTypeHierarchyChangedListener

    public void removeTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)

  Removes the given listener from this type hierarchy. Has no affect if an identical listener is not registered.

  Parameters:
    `listener` - the listener

### store

    public void store(OutputStream outputStream,
                      IProgressMonitor monitor)
               throws JavaModelException

  Stores the type hierarchy in an output stream. This stored hierarchy can be load by IType#loadTypeHierachy(IJavaProject, InputStream, IProgressMonitor). Listeners of this hierarchy are not stored. Only hierarchies created by the following methods can be store:
  - IType#newSupertypeHierarchy(IProgressMonitor)
  - IType#newTypeHierarchy(IJavaProject, IProgressMonitor)
  - IType#newTypeHierarchy(IProgressMonitor)

  Parameters:
    `outputStream` - output stream where the hierarchy will be stored
    `monitor` - the given progress monitor
  Throws:
    `JavaModelException` - if unable to store the hierarchy in the ouput stream
  Since:
    2.1
  See Also:
    `IType.loadTypeHierachy(java.io.InputStream, IProgressMonitor)`

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

Copyright (c) IBM Corp. and others 2000, 2004. All Rights Reserved.