Java tutorial
/* * Copyright (C) 2006 The Guava Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.google.common.reflect; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; import com.google.common.annotations.Beta; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Joiner; import com.google.common.base.Predicate; import com.google.common.collect.FluentIterable; import com.google.common.collect.ForwardingSet; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; import com.google.common.collect.Ordering; import com.google.common.primitives.Primitives; import java.io.Serializable; import java.lang.reflect.Constructor; import java.lang.reflect.GenericArrayType; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.lang.reflect.TypeVariable; import java.lang.reflect.WildcardType; import java.util.Arrays; import java.util.Comparator; import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicReference; import javax.annotation.Nullable; /** * A {@link Type} with generics. * * <p>Operations that are otherwise only available in {@link Class} are implemented to support * {@code Type}, for example {@link #isSubtypeOf}, {@link #isArray} and {@link #getComponentType}. * It also provides additional utilities such as {@link #getTypes}, {@link #resolveType}, etc. * * <p>There are three ways to get a {@code TypeToken} instance: <ul> * <li>Wrap a {@code Type} obtained via reflection. For example: {@code * TypeToken.of(method.getGenericReturnType())}. * <li>Capture a generic type with a (usually anonymous) subclass. For example: <pre> {@code * new TypeToken<List<String>>() {}}</pre> * <p>Note that it's critical that the actual type argument is carried by a subclass. * The following code is wrong because it only captures the {@code <T>} type variable * of the {@code listType()} method signature; while {@code <String>} is lost in erasure: * <pre> {@code * class Util { * static <T> TypeToken<List<T>> listType() { * return new TypeToken<List<T>>() {}; * } * } * * TypeToken<List<String>> stringListType = Util.<String>listType();}</pre> * <li>Capture a generic type with a (usually anonymous) subclass and resolve it against * a context class that knows what the type parameters are. For example: <pre> {@code * abstract class IKnowMyType<T> { * TypeToken<T> type = new TypeToken<T>(getClass()) {}; * } * new IKnowMyType<String>() {}.type => String}</pre> * </ul> * * <p>{@code TypeToken} is serializable when no type variable is contained in the type. * * <p>Note to Guice users: {@code} TypeToken is similar to Guice's {@code TypeLiteral} class * except that it is serializable and offers numerous additional utility methods. * * @author Bob Lee * @author Sven Mawson * @author Ben Yu * @since 12.0 */ @Beta @SuppressWarnings("serial") // SimpleTypeToken is the serialized form. public abstract class TypeToken<T> extends TypeCapture<T> implements Serializable { private final Type runtimeType; /** Resolver for resolving types with {@link #runtimeType} as context. */ private transient TypeResolver typeResolver; /** * Constructs a new type token of {@code T}. * * <p>Clients create an empty anonymous subclass. Doing so embeds the type * parameter in the anonymous class's type hierarchy so we can reconstitute * it at runtime despite erasure. * * <p>For example: <pre> {@code * TypeToken<List<String>> t = new TypeToken<List<String>>() {};}</pre> */ protected TypeToken() { this.runtimeType = capture(); checkState(!(runtimeType instanceof TypeVariable), "Cannot construct a TypeToken for a type variable.\n" + "You probably meant to call new TypeToken<%s>(getClass()) " + "that can resolve the type variable for you.\n" + "If you do need to create a TypeToken of a type variable, " + "please use TypeToken.of() instead.", runtimeType); } /** * Constructs a new type token of {@code T} while resolving free type variables in the context of * {@code declaringClass}. * * <p>Clients create an empty anonymous subclass. Doing so embeds the type * parameter in the anonymous class's type hierarchy so we can reconstitute * it at runtime despite erasure. * * <p>For example: <pre> {@code * abstract class IKnowMyType<T> { * TypeToken<T> getMyType() { * return new TypeToken<T>(getClass()) {}; * } * } * * new IKnowMyType<String>() {}.getMyType() => String}</pre> */ protected TypeToken(Class<?> declaringClass) { Type captured = super.capture(); if (captured instanceof Class) { this.runtimeType = captured; } else { this.runtimeType = of(declaringClass).resolveType(captured).runtimeType; } } private TypeToken(Type type) { this.runtimeType = checkNotNull(type); } /** Returns an instance of type token that wraps {@code type}. */ public static <T> TypeToken<T> of(Class<T> type) { return new SimpleTypeToken<T>(type); } /** Returns an instance of type token that wraps {@code type}. */ public static TypeToken<?> of(Type type) { return new SimpleTypeToken<Object>(type); } /** * Returns the raw type of {@code T}. Formally speaking, if {@code T} is returned by * {@link java.lang.reflect.Method#getGenericReturnType}, the raw type is what's returned by * {@link java.lang.reflect.Method#getReturnType} of the same method object. Specifically: * <ul> * <li>If {@code T} is a {@code Class} itself, {@code T} itself is returned. * <li>If {@code T} is a {@link ParameterizedType}, the raw type of the parameterized type is * returned. * <li>If {@code T} is a {@link GenericArrayType}, the returned type is the corresponding array * class. For example: {@code List<Integer>[] => List[]}. * <li>If {@code T} is a type variable or a wildcard type, the raw type of the first upper bound * is returned. For example: {@code <X extends Foo> => Foo}. * </ul> */ public final Class<? super T> getRawType() { // For wildcard or type variable, the first bound determines the runtime type. Class<?> rawType = getRawTypes().iterator().next(); @SuppressWarnings("unchecked") // raw type is |T| Class<? super T> result = (Class<? super T>) rawType; return result; } /** Returns the represented type. */ public final Type getType() { return runtimeType; } /** * <p>Returns a new {@code TypeToken} where type variables represented by {@code typeParam} * are substituted by {@code typeArg}. For example, it can be used to construct * {@code Map<K, V>} for any {@code K} and {@code V} type: <pre> {@code * static <K, V> TypeToken<Map<K, V>> mapOf( * TypeToken<K> keyType, TypeToken<V> valueType) { * return new TypeToken<Map<K, V>>() {} * .where(new TypeParameter<K>() {}, keyType) * .where(new TypeParameter<V>() {}, valueType); * }}</pre> * * @param <X> The parameter type * @param typeParam the parameter type variable * @param typeArg the actual type to substitute */ public final <X> TypeToken<T> where(TypeParameter<X> typeParam, TypeToken<X> typeArg) { TypeResolver resolver = new TypeResolver().where( ImmutableMap.of(new TypeResolver.TypeVariableKey(typeParam.typeVariable), typeArg.runtimeType)); // If there's any type error, we'd report now rather than later. return new SimpleTypeToken<T>(resolver.resolveType(runtimeType)); } /** * <p>Returns a new {@code TypeToken} where type variables represented by {@code typeParam} * are substituted by {@code typeArg}. For example, it can be used to construct * {@code Map<K, V>} for any {@code K} and {@code V} type: <pre> {@code * static <K, V> TypeToken<Map<K, V>> mapOf( * Class<K> keyType, Class<V> valueType) { * return new TypeToken<Map<K, V>>() {} * .where(new TypeParameter<K>() {}, keyType) * .where(new TypeParameter<V>() {}, valueType); * }}</pre> * * @param <X> The parameter type * @param typeParam the parameter type variable * @param typeArg the actual type to substitute */ public final <X> TypeToken<T> where(TypeParameter<X> typeParam, Class<X> typeArg) { return where(typeParam, of(typeArg)); } /** * <p>Resolves the given {@code type} against the type context represented by this type. * For example: <pre> {@code * new TypeToken<List<String>>() {}.resolveType( * List.class.getMethod("get", int.class).getGenericReturnType()) * => String.class}</pre> */ public final TypeToken<?> resolveType(Type type) { checkNotNull(type); TypeResolver resolver = typeResolver; if (resolver == null) { resolver = (typeResolver = TypeResolver.accordingTo(runtimeType)); } return of(resolver.resolveType(type)); } private Type[] resolveInPlace(Type[] types) { for (int i = 0; i < types.length; i++) { types[i] = resolveType(types[i]).getType(); } return types; } private TypeToken<?> resolveSupertype(Type type) { TypeToken<?> supertype = resolveType(type); // super types' type mapping is a subset of type mapping of this type. supertype.typeResolver = typeResolver; return supertype; } /** * Returns the generic superclass of this type or {@code null} if the type represents * {@link Object} or an interface. This method is similar but different from {@link * Class#getGenericSuperclass}. For example, {@code * new TypeToken<StringArrayList>() {}.getGenericSuperclass()} will return {@code * new TypeToken<ArrayList<String>>() {}}; while {@code * StringArrayList.class.getGenericSuperclass()} will return {@code ArrayList<E>}, where {@code E} * is the type variable declared by class {@code ArrayList}. * * <p>If this type is a type variable or wildcard, its first upper bound is examined and returned * if the bound is a class or extends from a class. This means that the returned type could be a * type variable too. */ @Nullable final TypeToken<? super T> getGenericSuperclass() { if (runtimeType instanceof TypeVariable) { // First bound is always the super class, if one exists. return boundAsSuperclass(((TypeVariable<?>) runtimeType).getBounds()[0]); } if (runtimeType instanceof WildcardType) { // wildcard has one and only one upper bound. return boundAsSuperclass(((WildcardType) runtimeType).getUpperBounds()[0]); } Type superclass = getRawType().getGenericSuperclass(); if (superclass == null) { return null; } @SuppressWarnings("unchecked") // super class of T TypeToken<? super T> superToken = (TypeToken<? super T>) resolveSupertype(superclass); return superToken; } @Nullable private TypeToken<? super T> boundAsSuperclass(Type bound) { TypeToken<?> token = of(bound); if (token.getRawType().isInterface()) { return null; } @SuppressWarnings("unchecked") // only upper bound of T is passed in. TypeToken<? super T> superclass = (TypeToken<? super T>) token; return superclass; } /** * Returns the generic interfaces that this type directly {@code implements}. This method is * similar but different from {@link Class#getGenericInterfaces()}. For example, {@code * new TypeToken<List<String>>() {}.getGenericInterfaces()} will return a list that contains * {@code new TypeToken<Iterable<String>>() {}}; while {@code List.class.getGenericInterfaces()} * will return an array that contains {@code Iterable<T>}, where the {@code T} is the type * variable declared by interface {@code Iterable}. * * <p>If this type is a type variable or wildcard, its upper bounds are examined and those that * are either an interface or upper-bounded only by interfaces are returned. This means that the * returned types could include type variables too. */ final ImmutableList<TypeToken<? super T>> getGenericInterfaces() { if (runtimeType instanceof TypeVariable) { return boundsAsInterfaces(((TypeVariable<?>) runtimeType).getBounds()); } if (runtimeType instanceof WildcardType) { return boundsAsInterfaces(((WildcardType) runtimeType).getUpperBounds()); } ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type interfaceType : getRawType().getGenericInterfaces()) { @SuppressWarnings("unchecked") // interface of T TypeToken<? super T> resolvedInterface = (TypeToken<? super T>) resolveSupertype(interfaceType); builder.add(resolvedInterface); } return builder.build(); } private ImmutableList<TypeToken<? super T>> boundsAsInterfaces(Type[] bounds) { ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type bound : bounds) { @SuppressWarnings("unchecked") // upper bound of T TypeToken<? super T> boundType = (TypeToken<? super T>) of(bound); if (boundType.getRawType().isInterface()) { builder.add(boundType); } } return builder.build(); } /** * Returns the set of interfaces and classes that this type is or is a subtype of. The returned * types are parameterized with proper type arguments. * * <p>Subtypes are always listed before supertypes. But the reverse is not true. A type isn't * necessarily a subtype of all the types following. Order between types without subtype * relationship is arbitrary and not guaranteed. * * <p>If this type is a type variable or wildcard, upper bounds that are themselves type variables * aren't included (their super interfaces and superclasses are). */ public final TypeSet getTypes() { return new TypeSet(); } /** * Returns the generic form of {@code superclass}. For example, if this is * {@code ArrayList<String>}, {@code Iterable<String>} is returned given the * input {@code Iterable.class}. */ public final TypeToken<? super T> getSupertype(Class<? super T> superclass) { checkArgument(this.someRawTypeIsSubclassOf(superclass), "%s is not a super class of %s", superclass, this); if (runtimeType instanceof TypeVariable) { return getSupertypeFromUpperBounds(superclass, ((TypeVariable<?>) runtimeType).getBounds()); } if (runtimeType instanceof WildcardType) { return getSupertypeFromUpperBounds(superclass, ((WildcardType) runtimeType).getUpperBounds()); } if (superclass.isArray()) { return getArraySupertype(superclass); } @SuppressWarnings("unchecked") // resolved supertype TypeToken<? super T> supertype = (TypeToken<? super T>) resolveSupertype( toGenericType(superclass).runtimeType); return supertype; } /** * Returns subtype of {@code this} with {@code subclass} as the raw class. * For example, if this is {@code Iterable<String>} and {@code subclass} is {@code List}, * {@code List<String>} is returned. */ public final TypeToken<? extends T> getSubtype(Class<?> subclass) { checkArgument(!(runtimeType instanceof TypeVariable), "Cannot get subtype of type variable <%s>", this); if (runtimeType instanceof WildcardType) { return getSubtypeFromLowerBounds(subclass, ((WildcardType) runtimeType).getLowerBounds()); } // unwrap array type if necessary if (isArray()) { return getArraySubtype(subclass); } // At this point, it's either a raw class or parameterized type. checkArgument(getRawType().isAssignableFrom(subclass), "%s isn't a subclass of %s", subclass, this); Type resolvedTypeArgs = resolveTypeArgsForSubclass(subclass); @SuppressWarnings("unchecked") // guarded by the isAssignableFrom() statement above TypeToken<? extends T> subtype = (TypeToken<? extends T>) of( replaceTypeVariablesWithWildcard(resolvedTypeArgs, subclass)); return subtype; } private static final Type replaceTypeVariablesWithWildcard(Type type, final Class<?> declaringClass) { checkNotNull(declaringClass); final AtomicReference<Type> result = new AtomicReference<Type>(); result.set(type); new TypeVisitor() { @Override void visitTypeVariable(TypeVariable<?> var) { if (var.getGenericDeclaration() == declaringClass) { result.set(Types.subtypeOf(Object.class)); } } @Override void visitParameterizedType(ParameterizedType pt) { result.set(Types.newParameterizedTypeWithOwner( // Replaces type vars on the owner type if it's owner type of declaringClass. declaringClass.getEnclosingClass() == null ? pt.getOwnerType() : replaceTypeVariablesWithWildcard(pt.getOwnerType(), declaringClass.getEnclosingClass()), (Class<?>) pt.getRawType(), replaceTypeVariablesWithWildcard(pt.getActualTypeArguments(), declaringClass))); } @Override void visitWildcardType(WildcardType t) { } @Override void visitGenericArrayType(GenericArrayType t) { } @Override void visitClass(Class<?> t) { } }.visit(type); return result.get(); } private static final Type[] replaceTypeVariablesWithWildcard(Type[] types, Class<?> declaringClass) { Type[] result = new Type[types.length]; for (int i = 0; i < types.length; i++) { result[i] = replaceTypeVariablesWithWildcard(types[i], declaringClass); } return result; } /** * Returns true if this type is a supertype of the given {@code type}. "Supertype" is defined * according to <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1" * >the rules for type arguments</a> introduced with Java generics. * * @deprecated Use the method under its new name, {@link #isSupertypeOf(TypeToken)}. This method * will be removed in Guava release 20.0. */ @Deprecated public final boolean isAssignableFrom(TypeToken<?> type) { return isSupertypeOf(type); } /** * Returns true if this type is a supertype of the given {@code type}. "Supertype" is defined * according to <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1" * >the rules for type arguments</a> introduced with Java generics. * * @deprecated Use the method under its new name, {@link #isSupertypeOf(Type)}. This method will * be removed in Guava release 20.0. */ @Deprecated public final boolean isAssignableFrom(Type type) { return isSupertypeOf(type); } /** * Returns true if this type is a supertype of the given {@code type}. "Supertype" is defined * according to <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1" * >the rules for type arguments</a> introduced with Java generics. * * @since 19.0 */ public final boolean isSupertypeOf(TypeToken<?> type) { return type.isSubtypeOf(getType()); } /** * Returns true if this type is a supertype of the given {@code type}. "Supertype" is defined * according to <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1" * >the rules for type arguments</a> introduced with Java generics. * * @since 19.0 */ public final boolean isSupertypeOf(Type type) { return of(type).isSubtypeOf(getType()); } /** * Returns true if this type is a subtype of the given {@code type}. "Subtype" is defined * according to <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1" * >the rules for type arguments</a> introduced with Java generics. * * @since 19.0 */ public final boolean isSubtypeOf(TypeToken<?> type) { return isSubtypeOf(type.getType()); } /** * Returns true if this type is a subtype of the given {@code type}. "Subtype" is defined * according to <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1" * >the rules for type arguments</a> introduced with Java generics. * * @since 19.0 */ public final boolean isSubtypeOf(Type supertype) { checkNotNull(supertype); if (supertype instanceof WildcardType) { // if 'supertype' is <? super Foo>, 'this' can be: // Foo, SubFoo, <? extends Foo>. // if 'supertype' is <? extends Foo>, nothing is a subtype. return any(((WildcardType) supertype).getLowerBounds()).isSupertypeOf(runtimeType); } // if 'this' is wildcard, it's a suptype of to 'supertype' if any of its "extends" // bounds is a subtype of 'supertype'. if (runtimeType instanceof WildcardType) { // <? super Base> is of no use in checking 'from' being a subtype of 'to'. return any(((WildcardType) runtimeType).getUpperBounds()).isSubtypeOf(supertype); } // if 'this' is type variable, it's a subtype if any of its "extends" // bounds is a subtype of 'supertype'. if (runtimeType instanceof TypeVariable) { return runtimeType.equals(supertype) || any(((TypeVariable<?>) runtimeType).getBounds()).isSubtypeOf(supertype); } if (runtimeType instanceof GenericArrayType) { return of(supertype).isSuperTypeOfArray((GenericArrayType) runtimeType); } // Proceed to regular Type subtype check if (supertype instanceof Class) { return this.someRawTypeIsSubclassOf((Class<?>) supertype); } else if (supertype instanceof ParameterizedType) { return this.isSubtypeOfParameterizedType((ParameterizedType) supertype); } else if (supertype instanceof GenericArrayType) { return this.isSubTypeOfArrayType((GenericArrayType) supertype); } else { // to instanceof TypeVariable return false; } } /** * Returns true if this type is known to be an array type, such as {@code int[]}, {@code T[]}, * {@code <? extends Map<String, Integer>[]>} etc. */ public final boolean isArray() { return getComponentType() != null; } /** * Returns true if this type is one of the nine primitive types (including {@code void}). * * @since 15.0 */ public final boolean isPrimitive() { return (runtimeType instanceof Class) && ((Class<?>) runtimeType).isPrimitive(); } /** * Returns the corresponding wrapper type if this is a primitive type; otherwise returns * {@code this} itself. Idempotent. * * @since 15.0 */ public final TypeToken<T> wrap() { if (isPrimitive()) { @SuppressWarnings("unchecked") // this is a primitive class Class<T> type = (Class<T>) runtimeType; return of(Primitives.wrap(type)); } return this; } private boolean isWrapper() { return Primitives.allWrapperTypes().contains(runtimeType); } /** * Returns the corresponding primitive type if this is a wrapper type; otherwise returns * {@code this} itself. Idempotent. * * @since 15.0 */ public final TypeToken<T> unwrap() { if (isWrapper()) { @SuppressWarnings("unchecked") // this is a wrapper class Class<T> type = (Class<T>) runtimeType; return of(Primitives.unwrap(type)); } return this; } /** * Returns the array component type if this type represents an array ({@code int[]}, {@code T[]}, * {@code <? extends Map<String, Integer>[]>} etc.), or else {@code null} is returned. */ @Nullable public final TypeToken<?> getComponentType() { Type componentType = Types.getComponentType(runtimeType); if (componentType == null) { return null; } return of(componentType); } /** * Returns the {@link Invokable} for {@code method}, which must be a member of {@code T}. * * @since 14.0 */ public final Invokable<T, Object> method(Method method) { checkArgument(this.someRawTypeIsSubclassOf(method.getDeclaringClass()), "%s not declared by %s", method, this); return new Invokable.MethodInvokable<T>(method) { @Override Type getGenericReturnType() { return resolveType(super.getGenericReturnType()).getType(); } @Override Type[] getGenericParameterTypes() { return resolveInPlace(super.getGenericParameterTypes()); } @Override Type[] getGenericExceptionTypes() { return resolveInPlace(super.getGenericExceptionTypes()); } @Override public TypeToken<T> getOwnerType() { return TypeToken.this; } @Override public String toString() { return getOwnerType() + "." + super.toString(); } }; } /** * Returns the {@link Invokable} for {@code constructor}, which must be a member of {@code T}. * * @since 14.0 */ public final Invokable<T, T> constructor(Constructor<?> constructor) { checkArgument(constructor.getDeclaringClass() == getRawType(), "%s not declared by %s", constructor, getRawType()); return new Invokable.ConstructorInvokable<T>(constructor) { @Override Type getGenericReturnType() { return resolveType(super.getGenericReturnType()).getType(); } @Override Type[] getGenericParameterTypes() { return resolveInPlace(super.getGenericParameterTypes()); } @Override Type[] getGenericExceptionTypes() { return resolveInPlace(super.getGenericExceptionTypes()); } @Override public TypeToken<T> getOwnerType() { return TypeToken.this; } @Override public String toString() { return getOwnerType() + "(" + Joiner.on(", ").join(getGenericParameterTypes()) + ")"; } }; } /** * The set of interfaces and classes that {@code T} is or is a subtype of. {@link Object} is not * included in the set if this type is an interface. */ public class TypeSet extends ForwardingSet<TypeToken<? super T>> implements Serializable { private transient ImmutableSet<TypeToken<? super T>> types; TypeSet() { } /** Returns the types that are interfaces implemented by this type. */ public TypeSet interfaces() { return new InterfaceSet(this); } /** Returns the types that are classes. */ public TypeSet classes() { return new ClassSet(); } @Override protected Set<TypeToken<? super T>> delegate() { ImmutableSet<TypeToken<? super T>> filteredTypes = types; if (filteredTypes == null) { // Java has no way to express ? super T when we parameterize TypeToken vs. Class. @SuppressWarnings({ "unchecked", "rawtypes" }) ImmutableList<TypeToken<? super T>> collectedTypes = (ImmutableList) TypeCollector.FOR_GENERIC_TYPE .collectTypes(TypeToken.this); return (types = FluentIterable.from(collectedTypes) .filter(TypeFilter.IGNORE_TYPE_VARIABLE_OR_WILDCARD).toSet()); } else { return filteredTypes; } } /** Returns the raw types of the types in this set, in the same order. */ public Set<Class<? super T>> rawTypes() { // Java has no way to express ? super T when we parameterize TypeToken vs. Class. @SuppressWarnings({ "unchecked", "rawtypes" }) ImmutableList<Class<? super T>> collectedTypes = (ImmutableList) TypeCollector.FOR_RAW_TYPE .collectTypes(getRawTypes()); return ImmutableSet.copyOf(collectedTypes); } private static final long serialVersionUID = 0; } private final class InterfaceSet extends TypeSet { private final transient TypeSet allTypes; private transient ImmutableSet<TypeToken<? super T>> interfaces; InterfaceSet(TypeSet allTypes) { this.allTypes = allTypes; } @Override protected Set<TypeToken<? super T>> delegate() { ImmutableSet<TypeToken<? super T>> result = interfaces; if (result == null) { return (interfaces = FluentIterable.from(allTypes).filter(TypeFilter.INTERFACE_ONLY).toSet()); } else { return result; } } @Override public TypeSet interfaces() { return this; } @Override public Set<Class<? super T>> rawTypes() { // Java has no way to express ? super T when we parameterize TypeToken vs. Class. @SuppressWarnings({ "unchecked", "rawtypes" }) ImmutableList<Class<? super T>> collectedTypes = (ImmutableList) TypeCollector.FOR_RAW_TYPE .collectTypes(getRawTypes()); return FluentIterable.from(collectedTypes).filter(new Predicate<Class<?>>() { @Override public boolean apply(Class<?> type) { return type.isInterface(); } }).toSet(); } @Override public TypeSet classes() { throw new UnsupportedOperationException("interfaces().classes() not supported."); } private Object readResolve() { return getTypes().interfaces(); } private static final long serialVersionUID = 0; } private final class ClassSet extends TypeSet { private transient ImmutableSet<TypeToken<? super T>> classes; @Override protected Set<TypeToken<? super T>> delegate() { ImmutableSet<TypeToken<? super T>> result = classes; if (result == null) { @SuppressWarnings({ "unchecked", "rawtypes" }) ImmutableList<TypeToken<? super T>> collectedTypes = (ImmutableList) TypeCollector.FOR_GENERIC_TYPE .classesOnly().collectTypes(TypeToken.this); return (classes = FluentIterable.from(collectedTypes) .filter(TypeFilter.IGNORE_TYPE_VARIABLE_OR_WILDCARD).toSet()); } else { return result; } } @Override public TypeSet classes() { return this; } @Override public Set<Class<? super T>> rawTypes() { // Java has no way to express ? super T when we parameterize TypeToken vs. Class. @SuppressWarnings({ "unchecked", "rawtypes" }) ImmutableList<Class<? super T>> collectedTypes = (ImmutableList) TypeCollector.FOR_RAW_TYPE .classesOnly().collectTypes(getRawTypes()); return ImmutableSet.copyOf(collectedTypes); } @Override public TypeSet interfaces() { throw new UnsupportedOperationException("classes().interfaces() not supported."); } private Object readResolve() { return getTypes().classes(); } private static final long serialVersionUID = 0; } private enum TypeFilter implements Predicate<TypeToken<?>> { IGNORE_TYPE_VARIABLE_OR_WILDCARD { @Override public boolean apply(TypeToken<?> type) { return !(type.runtimeType instanceof TypeVariable || type.runtimeType instanceof WildcardType); } }, INTERFACE_ONLY { @Override public boolean apply(TypeToken<?> type) { return type.getRawType().isInterface(); } } } /** * Returns true if {@code o} is another {@code TypeToken} that represents the same {@link Type}. */ @Override public boolean equals(@Nullable Object o) { if (o instanceof TypeToken) { TypeToken<?> that = (TypeToken<?>) o; return runtimeType.equals(that.runtimeType); } return false; } @Override public int hashCode() { return runtimeType.hashCode(); } @Override public String toString() { return Types.toString(runtimeType); } /** Implemented to support serialization of subclasses. */ protected Object writeReplace() { // TypeResolver just transforms the type to our own impls that are Serializable // except TypeVariable. return of(new TypeResolver().resolveType(runtimeType)); } /** * Ensures that this type token doesn't contain type variables, which can cause unchecked type * errors for callers like {@link TypeToInstanceMap}. */ final TypeToken<T> rejectTypeVariables() { new TypeVisitor() { @Override void visitTypeVariable(TypeVariable<?> type) { throw new IllegalArgumentException( runtimeType + "contains a type variable and is not safe for the operation"); } @Override void visitWildcardType(WildcardType type) { visit(type.getLowerBounds()); visit(type.getUpperBounds()); } @Override void visitParameterizedType(ParameterizedType type) { visit(type.getActualTypeArguments()); visit(type.getOwnerType()); } @Override void visitGenericArrayType(GenericArrayType type) { visit(type.getGenericComponentType()); } }.visit(runtimeType); return this; } private boolean someRawTypeIsSubclassOf(Class<?> superclass) { for (Class<?> rawType : getRawTypes()) { if (superclass.isAssignableFrom(rawType)) { return true; } } return false; } private boolean isSubtypeOfParameterizedType(ParameterizedType supertype) { Class<?> matchedClass = of(supertype).getRawType(); if (!this.someRawTypeIsSubclassOf(matchedClass)) { return false; } Type[] typeParams = matchedClass.getTypeParameters(); Type[] toTypeArgs = supertype.getActualTypeArguments(); for (int i = 0; i < typeParams.length; i++) { // If 'supertype' is "List<? extends CharSequence>" // and 'this' is StringArrayList, // First step is to figure out StringArrayList "is-a" List<E> and <E> is // String. // typeParams[0] is E and fromTypeToken.get(typeParams[0]) will resolve to // String. // String is then matched against <? extends CharSequence>. if (!resolveType(typeParams[i]).is(toTypeArgs[i])) { return false; } } return true; } private boolean isSubTypeOfArrayType(GenericArrayType supertype) { if (runtimeType instanceof Class) { Class<?> fromClass = (Class<?>) runtimeType; if (!fromClass.isArray()) { return false; } return of(fromClass.getComponentType()).isSubtypeOf(supertype.getGenericComponentType()); } else if (runtimeType instanceof GenericArrayType) { GenericArrayType fromArrayType = (GenericArrayType) runtimeType; return of(fromArrayType.getGenericComponentType()).isSubtypeOf(supertype.getGenericComponentType()); } else { return false; } } private boolean isSuperTypeOfArray(GenericArrayType subtype) { if (runtimeType instanceof Class) { Class<?> thisClass = (Class<?>) runtimeType; if (!thisClass.isArray()) { return thisClass.isAssignableFrom(Object[].class); } return of(subtype.getGenericComponentType()).isSubtypeOf(thisClass.getComponentType()); } else if (runtimeType instanceof GenericArrayType) { return of(subtype.getGenericComponentType()) .isSubtypeOf(((GenericArrayType) runtimeType).getGenericComponentType()); } else { return false; } } /** * Return true if any of the following conditions is met: <ul> * <li>'this' and {@code formalType} are equal * <li>{@code formalType} is {@code <? extends Foo>} and 'this' is a subtype of {@code Foo} * <li>{@code formalType} is {@code <? super Foo>} and 'this' is a supertype of {@code Foo} * </ul> */ private boolean is(Type formalType) { if (runtimeType.equals(formalType)) { return true; } if (formalType instanceof WildcardType) { // if "formalType" is <? extends Foo>, "this" can be: // Foo, SubFoo, <? extends Foo>, <? extends SubFoo>, <T extends Foo> or // <T extends SubFoo>. // if "formalType" is <? super Foo>, "this" can be: // Foo, SuperFoo, <? super Foo> or <? super SuperFoo>. return every(((WildcardType) formalType).getUpperBounds()).isSupertypeOf(runtimeType) && every(((WildcardType) formalType).getLowerBounds()).isSubtypeOf(runtimeType); } return false; } private static Bounds every(Type[] bounds) { // Every bound must match. On any false, result is false. return new Bounds(bounds, false); } private static Bounds any(Type[] bounds) { // Any bound matches. On any true, result is true. return new Bounds(bounds, true); } private static class Bounds { private final Type[] bounds; private final boolean target; Bounds(Type[] bounds, boolean target) { this.bounds = bounds; this.target = target; } boolean isSubtypeOf(Type supertype) { for (Type bound : bounds) { if (of(bound).isSubtypeOf(supertype) == target) { return target; } } return !target; } boolean isSupertypeOf(Type subtype) { TypeToken<?> type = of(subtype); for (Type bound : bounds) { if (type.isSubtypeOf(bound) == target) { return target; } } return !target; } } private ImmutableSet<Class<? super T>> getRawTypes() { final ImmutableSet.Builder<Class<?>> builder = ImmutableSet.builder(); new TypeVisitor() { @Override void visitTypeVariable(TypeVariable<?> t) { visit(t.getBounds()); } @Override void visitWildcardType(WildcardType t) { visit(t.getUpperBounds()); } @Override void visitParameterizedType(ParameterizedType t) { builder.add((Class<?>) t.getRawType()); } @Override void visitClass(Class<?> t) { builder.add(t); } @Override void visitGenericArrayType(GenericArrayType t) { builder.add(Types.getArrayClass(of(t.getGenericComponentType()).getRawType())); } }.visit(runtimeType); // Cast from ImmutableSet<Class<?>> to ImmutableSet<Class<? super T>> @SuppressWarnings({ "unchecked", "rawtypes" }) ImmutableSet<Class<? super T>> result = (ImmutableSet) builder.build(); return result; } /** * Returns the type token representing the generic type declaration of {@code cls}. For example: * {@code TypeToken.getGenericType(Iterable.class)} returns {@code Iterable<T>}. * * <p>If {@code cls} isn't parameterized and isn't a generic array, the type token of the class is * returned. */ @VisibleForTesting static <T> TypeToken<? extends T> toGenericType(Class<T> cls) { if (cls.isArray()) { Type arrayOfGenericType = Types.newArrayType( // If we are passed with int[].class, don't turn it to GenericArrayType toGenericType(cls.getComponentType()).runtimeType); @SuppressWarnings("unchecked") // array is covariant TypeToken<? extends T> result = (TypeToken<? extends T>) of(arrayOfGenericType); return result; } TypeVariable<Class<T>>[] typeParams = cls.getTypeParameters(); Type ownerType = cls.isMemberClass() ? toGenericType(cls.getEnclosingClass()).runtimeType : null; if ((typeParams.length > 0) || (ownerType != cls.getEnclosingClass())) { @SuppressWarnings("unchecked") // Like, it's Iterable<T> for Iterable.class TypeToken<? extends T> type = (TypeToken<? extends T>) of( Types.newParameterizedTypeWithOwner(ownerType, cls, typeParams)); return type; } else { return of(cls); } } private TypeToken<? super T> getSupertypeFromUpperBounds(Class<? super T> supertype, Type[] upperBounds) { for (Type upperBound : upperBounds) { @SuppressWarnings("unchecked") // T's upperbound is <? super T>. TypeToken<? super T> bound = (TypeToken<? super T>) of(upperBound); if (bound.isSubtypeOf(supertype)) { @SuppressWarnings({ "rawtypes", "unchecked" }) // guarded by the isSubtypeOf check. TypeToken<? super T> result = bound.getSupertype((Class) supertype); return result; } } throw new IllegalArgumentException(supertype + " isn't a super type of " + this); } private TypeToken<? extends T> getSubtypeFromLowerBounds(Class<?> subclass, Type[] lowerBounds) { for (Type lowerBound : lowerBounds) { @SuppressWarnings("unchecked") // T's lower bound is <? extends T> TypeToken<? extends T> bound = (TypeToken<? extends T>) of(lowerBound); // Java supports only one lowerbound anyway. return bound.getSubtype(subclass); } throw new IllegalArgumentException(subclass + " isn't a subclass of " + this); } private TypeToken<? super T> getArraySupertype(Class<? super T> supertype) { // with component type, we have lost generic type information // Use raw type so that compiler allows us to call getSupertype() @SuppressWarnings("rawtypes") TypeToken componentType = checkNotNull(getComponentType(), "%s isn't a super type of %s", supertype, this); // array is covariant. component type is super type, so is the array type. @SuppressWarnings("unchecked") // going from raw type back to generics TypeToken<?> componentSupertype = componentType.getSupertype(supertype.getComponentType()); @SuppressWarnings("unchecked") // component type is super type, so is array type. TypeToken<? super T> result = (TypeToken<? super T>) // If we are passed with int[].class, don't turn it to GenericArrayType of(newArrayClassOrGenericArrayType(componentSupertype.runtimeType)); return result; } private TypeToken<? extends T> getArraySubtype(Class<?> subclass) { // array is covariant. component type is subtype, so is the array type. TypeToken<?> componentSubtype = getComponentType().getSubtype(subclass.getComponentType()); @SuppressWarnings("unchecked") // component type is subtype, so is array type. TypeToken<? extends T> result = (TypeToken<? extends T>) // If we are passed with int[].class, don't turn it to GenericArrayType of(newArrayClassOrGenericArrayType(componentSubtype.runtimeType)); return result; } private Type resolveTypeArgsForSubclass(Class<?> subclass) { if (runtimeType instanceof Class) { // no resolution needed return subclass; } // class Base<A, B> {} // class Sub<X, Y> extends Base<X, Y> {} // Base<String, Integer>.subtype(Sub.class): // Sub<X, Y>.getSupertype(Base.class) => Base<X, Y> // => X=String, Y=Integer // => Sub<X, Y>=Sub<String, Integer> TypeToken<?> genericSubtype = toGenericType(subclass); @SuppressWarnings({ "rawtypes", "unchecked" }) // subclass isn't <? extends T> Type supertypeWithArgsFromSubtype = genericSubtype.getSupertype((Class) getRawType()).runtimeType; return new TypeResolver().where(supertypeWithArgsFromSubtype, runtimeType) .resolveType(genericSubtype.runtimeType); } /** * Creates an array class if {@code componentType} is a class, or else, a * {@link GenericArrayType}. This is what Java7 does for generic array type * parameters. */ private static Type newArrayClassOrGenericArrayType(Type componentType) { return Types.JavaVersion.JAVA7.newArrayType(componentType); } private static final class SimpleTypeToken<T> extends TypeToken<T> { SimpleTypeToken(Type type) { super(type); } private static final long serialVersionUID = 0; } /** * Collects parent types from a sub type. * * @param <K> The type "kind". Either a TypeToken, or Class. */ private abstract static class TypeCollector<K> { static final TypeCollector<TypeToken<?>> FOR_GENERIC_TYPE = new TypeCollector<TypeToken<?>>() { @Override Class<?> getRawType(TypeToken<?> type) { return type.getRawType(); } @Override Iterable<? extends TypeToken<?>> getInterfaces(TypeToken<?> type) { return type.getGenericInterfaces(); } @Nullable @Override TypeToken<?> getSuperclass(TypeToken<?> type) { return type.getGenericSuperclass(); } }; static final TypeCollector<Class<?>> FOR_RAW_TYPE = new TypeCollector<Class<?>>() { @Override Class<?> getRawType(Class<?> type) { return type; } @Override Iterable<? extends Class<?>> getInterfaces(Class<?> type) { return Arrays.asList(type.getInterfaces()); } @Nullable @Override Class<?> getSuperclass(Class<?> type) { return type.getSuperclass(); } }; /** For just classes, we don't have to traverse interfaces. */ final TypeCollector<K> classesOnly() { return new ForwardingTypeCollector<K>(this) { @Override Iterable<? extends K> getInterfaces(K type) { return ImmutableSet.of(); } @Override ImmutableList<K> collectTypes(Iterable<? extends K> types) { ImmutableList.Builder<K> builder = ImmutableList.builder(); for (K type : types) { if (!getRawType(type).isInterface()) { builder.add(type); } } return super.collectTypes(builder.build()); } }; } final ImmutableList<K> collectTypes(K type) { return collectTypes(ImmutableList.of(type)); } ImmutableList<K> collectTypes(Iterable<? extends K> types) { // type -> order number. 1 for Object, 2 for anything directly below, so on so forth. Map<K, Integer> map = Maps.newHashMap(); for (K type : types) { collectTypes(type, map); } return sortKeysByValue(map, Ordering.natural().reverse()); } /** Collects all types to map, and returns the total depth from T up to Object. */ private int collectTypes(K type, Map<? super K, Integer> map) { Integer existing = map.get(this); if (existing != null) { // short circuit: if set contains type it already contains its supertypes return existing; } int aboveMe = getRawType(type).isInterface() ? 1 // interfaces should be listed before Object : 0; for (K interfaceType : getInterfaces(type)) { aboveMe = Math.max(aboveMe, collectTypes(interfaceType, map)); } K superclass = getSuperclass(type); if (superclass != null) { aboveMe = Math.max(aboveMe, collectTypes(superclass, map)); } /* * TODO(benyu): should we include Object for interface? * Also, CharSequence[] and Object[] for String[]? * */ map.put(type, aboveMe + 1); return aboveMe + 1; } private static <K, V> ImmutableList<K> sortKeysByValue(final Map<K, V> map, final Comparator<? super V> valueComparator) { Ordering<K> keyOrdering = new Ordering<K>() { @Override public int compare(K left, K right) { return valueComparator.compare(map.get(left), map.get(right)); } }; return keyOrdering.immutableSortedCopy(map.keySet()); } abstract Class<?> getRawType(K type); abstract Iterable<? extends K> getInterfaces(K type); @Nullable abstract K getSuperclass(K type); private static class ForwardingTypeCollector<K> extends TypeCollector<K> { private final TypeCollector<K> delegate; ForwardingTypeCollector(TypeCollector<K> delegate) { this.delegate = delegate; } @Override Class<?> getRawType(K type) { return delegate.getRawType(type); } @Override Iterable<? extends K> getInterfaces(K type) { return delegate.getInterfaces(type); } @Override K getSuperclass(K type) { return delegate.getSuperclass(type); } } } }