TypeHierarchy

java.lang.Object
- org.aspectj.org.eclipse.jdt.internal.core.hierarchy.TypeHierarchy

All Implemented Interfaces:

IElementChangedListener, ITypeHierarchy

Direct Known Subclasses:

RegionBasedTypeHierarchy
```
public class TypeHierarchy
extends java.lang.Object
implements ITypeHierarchy, IElementChangedListener
```
See Also:

ITypeHierarchy

Field Summary

Fields
Modifier and Type	Field and Description
`protected ChangeCollector`	`changeCollector`
`protected java.util.ArrayList`	`changeListeners` Change listeners - null if no one is listening.
`protected java.util.Map`	`classToSuperclass`
`protected boolean`	`computeSubtypes` Whether this hierarchy should contains subtypes.
`static boolean`	`DEBUG`
`java.util.Map`	`files`
`protected IType`	`focusType` The type the hierarchy was specifically computed for, possibly null.
`protected java.util.ArrayList`	`interfaces`
`java.util.ArrayList`	`missingTypes`
`boolean`	`needsRefresh`
`protected static IType[]`	`NO_TYPE`
`protected Region`	`packageRegion` A region describing the packages considered by this hierarchy.
`protected IProgressMonitor`	`progressMonitor` The progress monitor to report work completed too.
`protected IJavaProject`	`project` The Java Project in which the hierarchy is being built - this provides the context for determining a classpath and namelookup rules.
`protected Region`	`projectRegion` A region describing the projects considered by this hierarchy.
`protected TypeVector`	`rootClasses`
`protected java.util.Map`	`typeFlags`
`protected java.util.Map`	`typeToSubtypes`
`protected java.util.Map`	`typeToSuperInterfaces`
`protected ICompilationUnit[]`	`workingCopies`

Constructor Summary

Constructors
Constructor and Description
`TypeHierarchy()` Creates an empty TypeHierarchy
`TypeHierarchy(IType type, ICompilationUnit[] workingCopies, IJavaProject project, boolean computeSubtypes)` Creates a TypeHierarchy on the given type.
`TypeHierarchy(IType type, ICompilationUnit[] workingCopies, IJavaSearchScope scope, boolean computeSubtypes)` Creates a TypeHierarchy on the given type.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addInterface(IType type)` Adds the type to the collection of interfaces.
`protected void`	`addRootClass(IType type)` Adds the type to the collection of root classes if the classes is not already present in the collection.
`protected void`	`addSubtype(IType type, IType subtype)` Adds the given subtype to the type.
`void`	`addTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)` Adds the given listener for changes to this type hierarchy.
`void`	`cacheFlags(IType type, int flags)` cacheFlags.
`protected void`	`cacheSuperclass(IType type, IType superclass)` Caches the handle of the superclass for the specified type.
`protected void`	`cacheSuperInterfaces(IType type, IType[] superinterfaces)` Caches all of the superinterfaces that are specified for the type.
`protected void`	`checkCanceled()` Checks with the progress monitor to see whether the creation of the type hierarchy should be canceled.
`protected void`	`compute()` Compute this type hierarchy.
`boolean`	`contains(IType type)` Returns whether the given type is part of this hierarchy.
`void`	`elementChanged(ElementChangedEvent event)` Determines if the change affects this hierarchy, and fires change notification if required.
`boolean`	`exists()` Returns whether the type and project this hierarchy was created on exist.
`void`	`fireChange()` Notifies listeners that this hierarchy has changed and needs refreshing.
`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.
`protected IType[]`	`growAndAddToArray(IType[] array, IType addition)` Adds the new element to a new array that contains all of the elements of the old array.
`protected IType[]`	`growAndAddToArray(IType[] array, IType[] additions)` Adds the new elements to a new array that contains all of the elements of the old array.
`boolean`	`hasFineGrainChanges()`
`protected void`	`initialize(int size)` Initializes this hierarchy's internal tables with the given size.
`protected void`	`initializeRegions()` Initializes the file, package and project regions
`boolean`	`isAffected(IJavaElementDelta delta, int eventType)` Returns true if the given delta could change this type hierarchy
`protected boolean`	`isAffectedByOpenable(IJavaElementDelta delta, IJavaElement element, int eventType)` Returns true if the given type delta (a compilation unit delta or a class file delta) could affect this type hierarchy.
`IJavaProject`	`javaProject()` Returns the java project this hierarchy was created in.
`static ITypeHierarchy`	`load(IType type, java.io.InputStream input, WorkingCopyOwner owner)`
`protected boolean`	`packageRegionContainsSamePackageFragment(PackageFragment element)` Returns `true` if an equivalent package fragment is included in the package region.
`protected static byte[]`	`readUntil(java.io.InputStream input, byte separator)`
`protected static byte[]`	`readUntil(java.io.InputStream input, byte separator, int offset)`
`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(java.io.OutputStream output, IProgressMonitor monitor)` Stores the type hierarchy in an output stream.
`java.lang.String`	`toString()`
`protected void`	`worked(int work)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - DEBUG
```
public static boolean DEBUG
```
  - project
```
protected IJavaProject project
```
    The Java Project in which the hierarchy is being built - this provides the context for determining a classpath and namelookup rules. Possibly null.
  - focusType
```
protected IType focusType
```
    The type the hierarchy was specifically computed for, possibly null.
  - workingCopies
```
protected ICompilationUnit[] workingCopies
```
  - classToSuperclass
```
protected java.util.Map classToSuperclass
```
  - typeToSuperInterfaces
```
protected java.util.Map typeToSuperInterfaces
```
  - typeToSubtypes
```
protected java.util.Map typeToSubtypes
```
  - typeFlags
```
protected java.util.Map typeFlags
```
  - rootClasses
```
protected TypeVector rootClasses
```
  - interfaces
```
protected java.util.ArrayList interfaces
```
  - missingTypes
```
public java.util.ArrayList missingTypes
```
  - NO_TYPE
```
protected static final IType[] NO_TYPE
```
  - progressMonitor
```
protected IProgressMonitor progressMonitor
```
    The progress monitor to report work completed too.
  - changeListeners
```
protected java.util.ArrayList changeListeners
```
    Change listeners - null if no one is listening.
  - files
```
public java.util.Map files
```
  - packageRegion
```
protected Region packageRegion
```
    A region describing the packages considered by this hierarchy. Null if not activated.
  - projectRegion
```
protected Region projectRegion
```
    A region describing the projects considered by this hierarchy. Null if not activated.
  - computeSubtypes
```
protected boolean computeSubtypes
```
    Whether this hierarchy should contains subtypes.
  - needsRefresh
```
public boolean needsRefresh
```
  - changeCollector
```
protected ChangeCollector changeCollector
```
- Constructor Detail
  - TypeHierarchy
```
public TypeHierarchy()
```
    Creates an empty TypeHierarchy
  - TypeHierarchy
```
public TypeHierarchy(IType type,
                     ICompilationUnit[] workingCopies,
                     IJavaProject project,
                     boolean computeSubtypes)
```
    Creates a TypeHierarchy on the given type.
  - TypeHierarchy
```
public TypeHierarchy(IType type,
                     ICompilationUnit[] workingCopies,
                     IJavaSearchScope scope,
                     boolean computeSubtypes)
```
    Creates a TypeHierarchy on the given type.
- Method Detail
  - initializeRegions
```
protected void initializeRegions()
```
    Initializes the file, package and project regions
  - addInterface
```
protected void addInterface(IType type)
```
    Adds the type to the collection of interfaces.
  - addRootClass
```
protected void addRootClass(IType type)
```
    Adds the type to the collection of root classes if the classes is not already present in the collection.
  - addSubtype
```
protected void addSubtype(IType type,
                          IType subtype)
```
    Adds the given subtype to the type.
  - addTypeHierarchyChangedListener
```
public void addTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    addTypeHierarchyChangedListener in interface ITypeHierarchy
    
    Parameters:
    
    listener - the listener
    
    See Also:
    
    ITypeHierarchy
  - cacheFlags
```
public void cacheFlags(IType type,
                       int flags)
```
    cacheFlags.
  - cacheSuperclass
```
protected void cacheSuperclass(IType type,
                               IType superclass)
```
    Caches the handle of the superclass for the specified type. As a side effect cache this type as a subtype of the superclass.
  - cacheSuperInterfaces
```
protected void cacheSuperInterfaces(IType type,
                                    IType[] superinterfaces)
```
    Caches all of the superinterfaces that are specified for the type.
  - checkCanceled
```
protected void checkCanceled()
```
    Checks with the progress monitor to see whether the creation of the type hierarchy should be canceled. Should be regularly called so that the user can cancel.
    
    Throws:
    
    OperationCanceledException - if cancelling the operation has been requested
    
    See Also:
    
    IProgressMonitor#isCanceled
  - compute
```
protected void compute()
                throws JavaModelException,
                       CoreException
```
    Compute this type hierarchy.
    
    Throws:
    
    JavaModelException
    
    CoreException
  - contains
```
public boolean contains(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    Returns whether the given type is part of this hierarchy.
    
    Specified by:
    
    contains in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    true if the given type is part of this hierarchy, false otherwise
    
    See Also:
    
    ITypeHierarchy
  - elementChanged
```
public void elementChanged(ElementChangedEvent event)
```
    Determines if the change affects this hierarchy, and fires change notification if required.
    
    Specified by:
    
    elementChanged in interface IElementChangedListener
    
    Parameters:
    
    event - the change event
  - exists
```
public boolean exists()
```
    Description copied from interface: ITypeHierarchy
    
    Returns whether the type and project this hierarchy was created on exist.
    
    Specified by:
    
    exists in interface ITypeHierarchy
    
    Returns:
    
    true if the type and project this hierarchy was created on exist, false otherwise
    
    See Also:
    
    ITypeHierarchy
  - fireChange
```
public void fireChange()
```
    Notifies listeners that this hierarchy has changed and needs refreshing. Note that listeners can be removed as we iterate through the list.
  - getAllClasses
```
public IType[] getAllClasses()
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllClasses in interface ITypeHierarchy
    
    Returns:
    
    all classes in this type hierarchy's graph
    
    See Also:
    
    ITypeHierarchy
  - getAllInterfaces
```
public IType[] getAllInterfaces()
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllInterfaces in interface ITypeHierarchy
    
    Returns:
    
    all interfaces in this type hierarchy's graph
    
    See Also:
    
    ITypeHierarchy
  - getAllSubtypes
```
public IType[] getAllSubtypes(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllSubtypes in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    all resolved subtypes (direct and indirect) of the given type
    
    See Also:
    
    ITypeHierarchy
  - getAllSuperclasses
```
public IType[] getAllSuperclasses(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllSuperclasses in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    all resolved superclasses of the given class, in bottom-up order, an empty array if none.
    
    See Also:
    
    ITypeHierarchy
  - getAllSuperInterfaces
```
public IType[] getAllSuperInterfaces(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllSuperInterfaces in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    all resolved superinterfaces (direct and indirect) of the given type, an empty array if none
    
    See Also:
    
    ITypeHierarchy
  - getAllSupertypes
```
public IType[] getAllSupertypes(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllSupertypes in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    all resolved supertypes of the given class, in bottom-up order, an empty array if none
    
    See Also:
    
    ITypeHierarchy
  - getAllTypes
```
public IType[] getAllTypes()
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getAllTypes in interface ITypeHierarchy
    
    Returns:
    
    all types in this type hierarchy's graph
    
    See Also:
    
    ITypeHierarchy
  - getCachedFlags
```
public int getCachedFlags(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getCachedFlags in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    the modifier flags for this member
    
    See Also:
    
    ITypeHierarchy.getCachedFlags(IType)
  - getExtendingInterfaces
```
public IType[] getExtendingInterfaces(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getExtendingInterfaces in interface ITypeHierarchy
    
    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.
    
    See Also:
    
    ITypeHierarchy
  - getImplementingClasses
```
public IType[] getImplementingClasses(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getImplementingClasses in interface ITypeHierarchy
    
    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
    
    See Also:
    
    ITypeHierarchy
  - getRootClasses
```
public IType[] getRootClasses()
```
    Description copied from interface: ITypeHierarchy
    
    Returns all classes in the graph which have no resolved superclass, in no particular order.
    
    Specified by:
    
    getRootClasses in interface ITypeHierarchy
    
    Returns:
    
    all classes in the graph which have no resolved superclass
    
    See Also:
    
    ITypeHierarchy
  - getRootInterfaces
```
public IType[] getRootInterfaces()
```
    Description copied from interface: ITypeHierarchy
    
    Returns all interfaces in the graph which have no resolved superinterfaces, in no particular order.
    
    Specified by:
    
    getRootInterfaces in interface ITypeHierarchy
    
    Returns:
    
    all interfaces in the graph which have no resolved superinterfaces
    
    See Also:
    
    ITypeHierarchy
  - getSubclasses
```
public IType[] getSubclasses(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getSubclasses in interface ITypeHierarchy
    
    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.
    
    See Also:
    
    ITypeHierarchy
  - getSubtypes
```
public IType[] getSubtypes(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getSubtypes in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    the direct resolved subtypes of the given type limited to the types in this type hierarchy's graph
    
    See Also:
    
    ITypeHierarchy
  - getSuperclass
```
public IType getSuperclass(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getSuperclass in interface ITypeHierarchy
    
    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
    
    See Also:
    
    ITypeHierarchy
  - getSuperInterfaces
```
public IType[] getSuperInterfaces(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getSuperInterfaces in interface ITypeHierarchy
    
    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
    
    See Also:
    
    ITypeHierarchy
  - getSupertypes
```
public IType[] getSupertypes(IType type)
```
    Description copied from interface: ITypeHierarchy
    
    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.
    
    Specified by:
    
    getSupertypes in interface ITypeHierarchy
    
    Parameters:
    
    type - the given type
    
    Returns:
    
    the resolved supertypes of the given type limited to the types in this type hierarchy's graph
    
    See Also:
    
    ITypeHierarchy
  - getType
```
public IType getType()
```
    Description copied from interface: ITypeHierarchy
    
    Returns the type this hierarchy was computed for. Returns null if this hierarchy was computed for a region.
    
    Specified by:
    
    getType in interface ITypeHierarchy
    
    Returns:
    
    the type this hierarchy was computed for
    
    See Also:
    
    ITypeHierarchy
  - growAndAddToArray
```
protected IType[] growAndAddToArray(IType[] array,
                                    IType[] additions)
```
    Adds the new elements to a new array that contains all of the elements of the old array. Returns the new array.
  - growAndAddToArray
```
protected IType[] growAndAddToArray(IType[] array,
                                    IType addition)
```
    Adds the new element to a new array that contains all of the elements of the old array. Returns the new array.
  - hasFineGrainChanges
```
public boolean hasFineGrainChanges()
```
  - initialize
```
protected void initialize(int size)
```
    Initializes this hierarchy's internal tables with the given size.
  - isAffected
```
public boolean isAffected(IJavaElementDelta delta,
                          int eventType)
```
    Returns true if the given delta could change this type hierarchy
    
    Parameters:
    
    eventType - TODO
  - isAffectedByOpenable
```
protected boolean isAffectedByOpenable(IJavaElementDelta delta,
                                       IJavaElement element,
                                       int eventType)
```
    Returns true if the given type delta (a compilation unit delta or a class file delta) could affect this type hierarchy.
    
    Parameters:
    
    eventType - TODO
  - javaProject
```
public IJavaProject javaProject()
```
    Returns the java project this hierarchy was created in.
  - readUntil
```
protected static byte[] readUntil(java.io.InputStream input,
                                  byte separator)
                           throws JavaModelException,
                                  java.io.IOException
```
    Throws:
    
    JavaModelException
    
    java.io.IOException
  - readUntil
```
protected static byte[] readUntil(java.io.InputStream input,
                                  byte separator,
                                  int offset)
                           throws java.io.IOException,
                                  JavaModelException
```
    Throws:
    
    java.io.IOException
    
    JavaModelException
  - load
```
public static ITypeHierarchy load(IType type,
                                  java.io.InputStream input,
                                  WorkingCopyOwner owner)
                           throws JavaModelException
```
    Throws:
    
    JavaModelException
  - packageRegionContainsSamePackageFragment
```
protected boolean packageRegionContainsSamePackageFragment(PackageFragment element)
```
    Returns true if an equivalent package fragment is included in the package region. Package fragments are equivalent if they both have the same name.
  - refresh
```
public void refresh(IProgressMonitor monitor)
             throws JavaModelException
```
    Description copied from interface: ITypeHierarchy
    
    Re-computes the type hierarchy reporting progress.
    
    Specified by:
    
    refresh in interface ITypeHierarchy
    
    Parameters:
    
    monitor - the given progress monitor
    
    Throws:
    
    JavaModelException - if unable to refresh the hierarchy
    
    See Also:
    
    TODO (jerome) should use a PerThreadObject to build the hierarchy instead of synchronizing (see also isAffected(IJavaElementDelta))
  - removeTypeHierarchyChangedListener
```
public void removeTypeHierarchyChangedListener(ITypeHierarchyChangedListener listener)
```
    Description copied from interface: ITypeHierarchy
    
    Removes the given listener from this type hierarchy. Has no effect if an identical listener is not registered.
    
    Specified by:
    
    removeTypeHierarchyChangedListener in interface ITypeHierarchy
    
    Parameters:
    
    listener - the listener
    
    See Also:
    
    ITypeHierarchy
  - store
```
public void store(java.io.OutputStream output,
                  IProgressMonitor monitor)
           throws JavaModelException
```
    Description copied from interface: ITypeHierarchy
    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)
    Specified by:
    
    store in interface ITypeHierarchy
    
    Parameters:
    
    output - 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
    
    See Also:
    
    ITypeHierarchy
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
    
    See Also:
    
    ITypeHierarchy
  - worked
```
protected void worked(int work)
```
    See Also:
    
    IProgressMonitor

Class TypeHierarchy

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEBUG

project

focusType

workingCopies

classToSuperclass

typeToSuperInterfaces

typeToSubtypes

typeFlags

rootClasses

interfaces

missingTypes

NO_TYPE

progressMonitor

changeListeners

files

packageRegion

projectRegion

computeSubtypes

needsRefresh

changeCollector

Constructor Detail

TypeHierarchy

TypeHierarchy

TypeHierarchy

Method Detail

initializeRegions

addInterface

addRootClass

addSubtype

addTypeHierarchyChangedListener

cacheFlags

cacheSuperclass

cacheSuperInterfaces

checkCanceled

compute

contains

elementChanged

exists

fireChange

getAllClasses

getAllInterfaces

getAllSubtypes

getAllSuperclasses

getAllSuperInterfaces

getAllSupertypes

getAllTypes

getCachedFlags

getExtendingInterfaces

getImplementingClasses

getRootClasses

getRootInterfaces

getSubclasses

getSubtypes

getSuperclass

getSuperInterfaces

getSupertypes

getType

growAndAddToArray

growAndAddToArray

hasFineGrainChanges

initialize

isAffected

isAffectedByOpenable

javaProject

readUntil

readUntil

load

packageRegionContainsSamePackageFragment

refresh

removeTypeHierarchyChangedListener

store

toString

worked