## com.google.gwt.core.ext.typeinfo
Class TypeOracle

    java.lang.Object
      com.google.gwt.core.ext.typeinfo.TypeOracle

    public class TypeOracle

extends java.lang.Object

Provides type-related information about a set of source files, including doc comment metadata.

All type objects exposed, such as `JClassType` and others, have a stable identity relative to this type oracle instance. Consequently, you can reliably compare object identity of any objects this type oracle produces. For example, the following code relies on this stable identity guarantee:

     JClassType o = typeOracle.getJavaLangObject();
     JClassType s1 = typeOracle.getType("java.lang.String");
     JClassType s2 = typeOracle.getType("java.lang.String");
     assert(s1 == s2);
     assert(o == s1.getSuperclass());
     JParameterizedType ls = typeOracle.parse("java.util.List<java.lang.String>");
     assert(ls.getTypeArgs()[0] == s1);

Field Summary
`static java.lang.String` `TAG_TYPEARGS` A reserved metadata tag to indicates that a field type, method return type or method parameter type is intended to be parameterized.

Constructor Summary
`TypeOracle()`

Method Summary
`JPackage` `findPackage(java.lang.String pkgName)` Attempts to find a package by name.
`JClassType` `findType(java.lang.String name)` Finds a class or interface given its fully-qualified name.
`JClassType` `findType(java.lang.String pkgName, java.lang.String typeName)` Finds a type given its package-relative name.
`JArrayType` `getArrayType(JType componentType)` Gets the type object that represents an array of the specified type.
`JClassType` `getJavaLangObject()` Gets a reference to the type object representing `java.lang.Object`.
`JPackage` `getOrCreatePackage(java.lang.String name)` Ensure that a package with the specified name exists as well as its parent packages.
`JPackage` `getPackage(java.lang.String pkgName)` Gets a package by name.
`JPackage[]` `getPackages()` Gets an array of all packages known to this type oracle.
`JParameterizedType` `getParameterizedType(JGenericType genericType, JClassType[] typeArgs)` Gets the parameterized type object that represents the combination of a specified raw type and a set of type arguments.
`JParameterizedType` `getParameterizedType(JGenericType genericType, JClassType enclosingType, JClassType[] typeArgs)` Gets the parameterized type object that represents the combination of a specified raw type and a set of type arguments.
`long` `getReloadCount()`
`JClassType` `getType(java.lang.String name)` Finds a type given its fully qualified name.
`JClassType` `getType(java.lang.String pkgName, java.lang.String topLevelTypeSimpleName)` Finds a type given its package-relative name.
`JClassType[]` `getTypes()` Gets all types, both top-level and nested.
`JWildcardType` `getWildcardType(JWildcardType.BoundType boundType, JClassType typeBound)`
`JType` `parse(java.lang.String type)` Parses the string form of a type to produce the corresponding type object.
`void` `refresh(TreeLogger logger)` Updates relationships within this type oracle.
`void` `removeInvalidatedTypes()` Removes all types that are no longer valid.
`void` `sort(JClassType[] types)` Convenience method to sort class types in a consistent way.
`void` `sort(JConstructor[] ctors)` Convenience method to sort constructors in a consistent way.
`void` `sort(JField[] fields)` Convenience method to sort fields in a consistent way.
`void` `sort(JMethod[] methods)` Convenience method to sort methods in a consistent way.

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

Field Detail

### TAG_TYPEARGS

    public static final java.lang.String TAG_TYPEARGS

  A reserved metadata tag to indicates that a field type, method return type or method parameter type is intended to be parameterized. Note that constructor type parameters are not supported at present.

  See Also:
    Constant Field Values

Constructor Detail

### TypeOracle

    public TypeOracle()

Method Detail

### findPackage

    public JPackage findPackage(java.lang.String pkgName)

  Attempts to find a package by name. All requests for the same package return the same package object.

  Returns:
    `null` if the package could not be found

### findType

    public JClassType findType(java.lang.String name)

  Finds a class or interface given its fully-qualified name. For nested classes, use its source name rather than its binary name (that is, use a "." rather than a "$").

  Returns:
    `null` if the type is not found

### findType

    public JClassType findType(java.lang.String pkgName,
                               java.lang.String typeName)

  Finds a type given its package-relative name. For nested classes, use its source name rather than its binary name (that is, use a "." rather than a "$").

  Returns:
    `null` if the type is not found

### getArrayType

    public JArrayType getArrayType(JType componentType)

  Gets the type object that represents an array of the specified type. The returned type always has a stable identity so as to guarantee that all calls to this method with the same argument return the same object.

  Parameters:
    `componentType` - the component type of the array, which can itself be an array type
  Returns:
    a type object representing an array of the component type

### getJavaLangObject

    public JClassType getJavaLangObject()

  Gets a reference to the type object representing `java.lang.Object`.

### getOrCreatePackage

    public JPackage getOrCreatePackage(java.lang.String name)

  Ensure that a package with the specified name exists as well as its parent packages.

### getPackage

    public JPackage getPackage(java.lang.String pkgName)
                        throws NotFoundException

  Gets a package by name. All requests for the same package return the same package object.

  Returns:
    the package object associated with the specified name
  Throws:
    `NotFoundException`

### getPackages

    public JPackage[] getPackages()

  Gets an array of all packages known to this type oracle.

  Returns:
    an array of packages, possibly of zero-length

### getParameterizedType

    public JParameterizedType getParameterizedType(JGenericType genericType,
                                                   JClassType enclosingType,
                                                   JClassType[] typeArgs)

  Gets the parameterized type object that represents the combination of a specified raw type and a set of type arguments. The returned type always has a stable identity so as to guarantee that all calls to this method with the same arguments return the same object.

  Parameters:
    `genericType` - a generic base class
    `enclosingType` -
    `typeArgs` - the type arguments bound to the specified generic type
  Returns:
    a type object representing this particular binding of type arguments to the specified generic
  Throws:
    `java.lang.IllegalArgumentException` - if the parameterization of a non-static member type does not specify an enclosing type or if not enough arguments were specified to parameterize the generic type
    `java.lang.NullPointerException` - if genericType is `null`

### getParameterizedType

    public JParameterizedType getParameterizedType(JGenericType genericType,
                                                   JClassType[] typeArgs)

  Gets the parameterized type object that represents the combination of a specified raw type and a set of type arguments. The returned type always has a stable identity so as to guarantee that all calls to this method with the same arguments return the same object.

  Parameters:
    `genericType` - a generic base class
    `typeArgs` - the type arguments bound to the specified generic type
  Returns:
    a type object representing this particular binding of type arguments to the specified generic
  Throws:
    `java.lang.IllegalArgumentException` - if the generic type is a non-static member type or if not enough arguments were specified to parameterize the generic type
    `java.lang.NullPointerException` - if genericType is `null`

### getReloadCount

    public long getReloadCount()

### getType

    public JClassType getType(java.lang.String name)
                       throws NotFoundException

  Finds a type given its fully qualified name. For nested classes, use its source name rather than its binary name (that is, use a "." rather than a "$").

  Returns:
    the specified type
  Throws:
    `NotFoundException`

### getType

    public JClassType getType(java.lang.String pkgName,
                              java.lang.String topLevelTypeSimpleName)
                       throws NotFoundException

  Finds a type given its package-relative name. For nested classes, use its source name rather than its binary name (that is, use a "." rather than a "$").

  Returns:
    the specified type
  Throws:
    `NotFoundException`

### getTypes

    public JClassType[] getTypes()

  Gets all types, both top-level and nested.

  Returns:
    an array of types, possibly of zero length

### getWildcardType

    public JWildcardType getWildcardType(JWildcardType.BoundType boundType,
                                         JClassType typeBound)

### parse

    public JType parse(java.lang.String type)
                throws TypeOracleException

  Parses the string form of a type to produce the corresponding type object. The types that can be parsed include primitives, class and interface names, simple parameterized types (those without wildcards or bounds), and arrays of the preceding.

  Examples of types that can be parsed by this method.

  - `int`
  - `java.lang.Object`
  - `java.lang.String[]`
  - `char[][]`
  - `void`
  - `List<Shape>`
  - `List<List<Shape>>`

  Parameters:
    `type` - a type signature to be parsed
  Returns:
    the type object corresponding to the parse type
  Throws:
    `TypeOracleException`

### refresh

    public void refresh(TreeLogger logger)
                 throws NotFoundException

  Updates relationships within this type oracle. Should be called after any changes are made.

  Throws `TypeOracleException` thrown if fundamental baseline correctness criteria are violated, most notably the absence of "java.lang.Object"

  TODO: make this not public.

  Throws:
    `NotFoundException`

### removeInvalidatedTypes

    public void removeInvalidatedTypes()

  Removes all types that are no longer valid. TODO: make not public?

### sort

    public void sort(JClassType[] types)

  Convenience method to sort class types in a consistent way. Note that the order is subject to change and is intended to generate an "aesthetically pleasing" order rather than a computationally reliable order.

### sort

    public void sort(JConstructor[] ctors)

  Convenience method to sort constructors in a consistent way. Note that the order is subject to change and is intended to generate an "aesthetically pleasing" order rather than a computationally reliable order.

### sort

    public void sort(JField[] fields)

  Convenience method to sort fields in a consistent way. Note that the order is subject to change and is intended to generate an "aesthetically pleasing" order rather than a computationally reliable order.

### sort

    public void sort(JMethod[] methods)

  Convenience method to sort methods in a consistent way. Note that the order is subject to change and is intended to generate an "aesthetically pleasing" order rather than a computationally reliable order.