Package org.apache.beam.sdk.values

Class TypeDescriptor<T>

java.lang.Object
org.apache.beam.sdk.values.TypeDescriptor<T>
Type Parameters:
T - the type represented by this TypeDescriptor
All Implemented Interfaces:
Serializable
public abstract class TypeDescriptor<T> extends Object implements Serializable
A description of a Java type, including actual generic parameters where possible.

To prevent losing actual type arguments due to erasure, create an anonymous subclass with concrete types: 


 TypeDescriptor<List<String>> typeDescriptor = new TypeDescriptor<List<String>>() {};

If the above were not an anonymous subclass, the type List<String> would be erased and unavailable at run time.

See Also:

  • Constructor Details

    • TypeDescriptor

      protected TypeDescriptor()
      Creates a TypeDescriptor representing the type parameter T. To use this constructor properly, the type parameter must be a concrete type, for example new TypeDescriptor<List<String>>(){}.

    • TypeDescriptor

      protected TypeDescriptor(Object instance)
      Creates a TypeDescriptor representing the type parameter T, which should resolve to a concrete type in the context of the class clazz.

      Unlike TypeDescriptor(Class) this will also use context's of the enclosing instances while attempting to resolve the type. This means that the types of any classes instantiated in the concrete instance should be resolvable.

    • TypeDescriptor

      protected TypeDescriptor(Class<?> clazz)
      Creates a TypeDescriptor representing the type parameter T, which should resolve to a concrete type in the context of the class clazz.

  • Method Details

    • of

      public static <T> TypeDescriptor<T> of(Class<T> type)
      Returns a TypeDescriptor representing the given type.

    • of

      public static TypeDescriptor<?> of(Type type)
      Returns a TypeDescriptor representing the given type.

    • getType

      public Type getType()
      Returns the Type represented by this TypeDescriptor.

    • getRawType

      public Class<? super T> getRawType()
      Returns the Class underlying the Type represented by this TypeDescriptor.

    • getComponentType

      public @Nullable TypeDescriptor<?> getComponentType()
      Returns the component type if this type is an array type, otherwise returns null.

    • getSupertype

      public final TypeDescriptor<? super T> getSupertype(Class<? super T> superclass)
      Returns the generic form of a supertype.

    • isArray

      public final boolean isArray()
      Returns true if this type is known to be an array type.

    • getTypeParameter

      public final TypeVariable<Class<? super T>> getTypeParameter(String paramName)
      Returns a TypeVariable for the named type parameter. Throws IllegalArgumentException if a type variable by the requested type parameter is not found.

      For example, new TypeDescriptor<List>(){}.getTypeParameter("T") returns a TypeVariable<? super List> representing the formal type parameter T.

      Do not mistake the type parameters (formal type argument list) with the actual type arguments. For example, if a class Foo extends List<String>, it does not make sense to ask for a type parameter, because Foo does not have any.

    • isSupertypeOf

      public final boolean isSupertypeOf(TypeDescriptor<?> source)
      Returns true if this type is assignable from the given type.

    • isSubtypeOf

      public final boolean isSubtypeOf(TypeDescriptor<?> parent)
      Return true if this type is a subtype of the given type.

    • getArgumentTypes

      public List<TypeDescriptor<?>> getArgumentTypes(Method method)
      Returns a list of argument types for the given method, which must be a part of the class.

    • resolveType

      public TypeDescriptor<?> resolveType(Type type)
      Returns a TypeDescriptor representing the given type, with type variables resolved according to the specialization in this type.

      For example, consider the following class: 

      
 class MyList implements List<String> { ... }

      The TypeDescriptor returned by 

      
 TypeDescriptor.of(MyList.class)
     .resolveType(Mylist.class.getMethod("get", int.class).getGenericReturnType)
      will represent the type String.

    • getTypes

      public Iterable<TypeDescriptor> getTypes()
      Returns a set of TypeDescriptor, one for each superclass as well as each interface implemented by this class.

    • getInterfaces

      public Iterable<TypeDescriptor> getInterfaces()
      Returns a set of TypeDescriptors, one for each interface implemented by this class.

    • getClasses

      public Iterable<TypeDescriptor> getClasses()
      Returns a set of TypeDescriptors, one for each superclass (including this class).

    • where

      public <X> TypeDescriptor<T> where(TypeParameter<X> typeParameter, TypeDescriptor<X> typeDescriptor)
      Returns a new TypeDescriptor where the type variable represented by typeParameter are substituted by type. For example, it can be used to construct Map<K, V> for any K and V type: 
      
 static <K, V> TypeDescriptor<Map<K, V>> mapOf(
     TypeDescriptor<K> keyType, TypeDescriptor<V> valueType) {
   return new TypeDescriptor<Map<K, V>>() {}
       .where(new TypeParameter<K>() {}, keyType)
       .where(new TypeParameter<V>() {}, valueType);
 }
      Type Parameters:
      X - The parameter type
      Parameters:
      typeParameter - the parameter type variable
      typeDescriptor - the actual type to substitute

    • where

      public TypeDescriptor<T> where(Type formal, Type actual)
      A more general form of where(TypeParameter, TypeDescriptor) that returns a new TypeDescriptor by matching formal against actual to resolve type variables in the current TypeDescriptor.

    • hasUnresolvedParameters

      public boolean hasUnresolvedParameters()
      Returns whether this TypeDescriptor has any unresolved type parameters, as opposed to being a concrete type.

      For example: 

      
 TypeDescriptor.of(new ArrayList<String>() {}.getClass()).hasUnresolvedTypeParameters()
   => false, because the anonymous class is instantiated with a concrete type

 class TestUtils {
   <T> ArrayList<T> createTypeErasedList() {
     return new ArrayList<T>() {};
   }
 }

 TypeDescriptor.of(TestUtils.<String>createTypeErasedList().getClass())
   => true, because the type variable T got type-erased and the anonymous ArrayList class
   is instantiated with an unresolved type variable T.

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(@Nullable Object other)
      Two type descriptor are equal if and only if they represent the same type.
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object