@Override public boolean equals(Object other) { if (this == other) { return true; } if (!(other instanceof ParameterizedType)) { return false; } ParameterizedType otherType = (ParameterizedType) other; return (otherType.getOwnerType() == null && this.rawType.equals(otherType.getRawType()) && Arrays.equals(this.typeArguments, otherType.getActualTypeArguments())); }
/** * Returns the owner type of a {@link ParameterizedType} or enclosing class of a {@link Class}, or * null otherwise. */ private @Nullable Type getOwnerTypeIfPresent() { if (runtimeType instanceof ParameterizedType) { return ((ParameterizedType) runtimeType).getOwnerType(); } else if (runtimeType instanceof Class<?>) { return ((Class<?>) runtimeType).getEnclosingClass(); } else { return null; } }
private static ParameterizedType canonicalizeWildcardsInParameterizedType( ParameterizedType type) { Class<?> rawType = (Class<?>) type.getRawType(); TypeVariable<?>[] typeVars = rawType.getTypeParameters(); Type[] typeArgs = type.getActualTypeArguments(); for (int i = 0; i < typeArgs.length; i++) { typeArgs[i] = canonicalizeTypeArg(typeVars[i], typeArgs[i]); } return Types.newParameterizedTypeWithOwner(type.getOwnerType(), rawType, typeArgs); }
private static ClassOwnership detectJvmBehavior() { class LocalClass<T> {} Class<?> subclass = new LocalClass<String>() {}.getClass(); ParameterizedType parameterizedType = (ParameterizedType) subclass.getGenericSuperclass(); for (ClassOwnership behavior : ClassOwnership.values()) { if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) { return behavior; } } throw new AssertionError(); } }
@Override public boolean equals(Object other) { if (!(other instanceof ParameterizedType)) { return false; } ParameterizedType that = (ParameterizedType) other; return getRawType().equals(that.getRawType()) && Objects.equal(getOwnerType(), that.getOwnerType()) && Arrays.equals(getActualTypeArguments(), that.getActualTypeArguments()); }
@Override void visitParameterizedType(ParameterizedType parameterizedType) { Class<?> rawClass = (Class<?>) parameterizedType.getRawType(); TypeVariable<?>[] vars = rawClass.getTypeParameters(); Type[] typeArgs = parameterizedType.getActualTypeArguments(); checkState(vars.length == typeArgs.length); for (int i = 0; i < vars.length; i++) { map(new TypeVariableKey(vars[i]), typeArgs[i]); } visit(rawClass); visit(parameterizedType.getOwnerType()); }
private static ClassOwnership detectJvmBehavior() { class LocalClass<T> {} Class<?> subclass = new LocalClass<String>() {}.getClass(); ParameterizedType parameterizedType = (ParameterizedType) subclass.getGenericSuperclass(); for (ClassOwnership behavior : ClassOwnership.values()) { if (behavior.getOwnerType(LocalClass.class) == parameterizedType.getOwnerType()) { return behavior; } } throw new AssertionError(); } }
private ParameterizedType resolveParameterizedType(ParameterizedType type) { Type owner = type.getOwnerType(); Type resolvedOwner = (owner == null) ? null : resolveType(owner); Type resolvedRawType = resolveType(type.getRawType()); Type[] args = type.getActualTypeArguments(); Type[] resolvedArgs = resolveTypes(args); return Types.newParameterizedTypeWithOwner( resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs); }
@Override public boolean equals(Object other) { if (!(other instanceof ParameterizedType)) { return false; } ParameterizedType that = (ParameterizedType) other; return getRawType().equals(that.getRawType()) && Objects.equal(getOwnerType(), that.getOwnerType()) && Arrays.equals(getActualTypeArguments(), that.getActualTypeArguments()); }
private ParameterizedType resolveParameterizedType(ParameterizedType type) { Type owner = type.getOwnerType(); Type resolvedOwner = (owner == null) ? null : resolveType(owner); Type resolvedRawType = resolveType(type.getRawType()); Type[] args = type.getActualTypeArguments(); Type[] resolvedArgs = resolveTypes(args); return Types.newParameterizedTypeWithOwner( resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs); }
public void testToGenericType_staticMemberClass() throws Exception { Method getStaticAnonymousClassMethod = TypeTokenTest.class.getDeclaredMethod("getStaticAnonymousClass", Object.class); ParameterizedType javacReturnType = (ParameterizedType) getStaticAnonymousClassMethod.getGenericReturnType(); ParameterizedType parameterizedType = (ParameterizedType) TypeToken.toGenericType(GenericClass.class).getType(); assertThat(parameterizedType.getOwnerType()).isEqualTo(javacReturnType.getOwnerType()); }
@Override void visitParameterizedType(ParameterizedType parameterizedType) { Class<?> rawClass = (Class<?>) parameterizedType.getRawType(); TypeVariable<?>[] vars = rawClass.getTypeParameters(); Type[] typeArgs = parameterizedType.getActualTypeArguments(); checkState(vars.length == typeArgs.length); for (int i = 0; i < vars.length; i++) { map(new TypeVariableKey(vars[i]), typeArgs[i]); } visit(rawClass); visit(parameterizedType.getOwnerType()); }
public void testVisitNull() { new BaseTypeVisitor() .visit(((ParameterizedType) ArrayList.class.getGenericSuperclass()).getOwnerType()); }
@Test public void parameterizedType() throws Exception { ParameterizedType type = (ParameterizedType) SerializableTypeWrapper.forField(Fields.class.getField("parameterizedType")); assertThat(type.toString(), equalTo("java.util.List<java.lang.String>")); assertSerializable(type); assertSerializable(type.getOwnerType()); assertSerializable(type.getRawType()); assertSerializable(type.getActualTypeArguments()); assertSerializable(type.getActualTypeArguments()[0]); }
public void testGetSubtype_innerTypeOfGenericClassTranslatesOwnerTypeVars() { TypeToken<TwoTypeArgs<?, ?>.InnerType<?, ?>> supertype = new TypeToken<TwoTypeArgs<?, ?>.InnerType<?, ?>>() {}; TypeToken<StringForFirstTypeArg<Integer>.StringInnerType<Long>> subtype = new TypeToken<StringForFirstTypeArg<Integer>.StringInnerType<Long>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(StringForFirstTypeArg.StringInnerType.class, actualSubtype.getRawType()); assertThat(actualSubtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class); ParameterizedType actualOwnerType = (ParameterizedType) actualSubtype.getOwnerType(); assertEquals(StringForFirstTypeArg.class, actualOwnerType.getRawType()); }
public void testResolveType_parameterizedType() { @SuppressWarnings("rawtypes") // trying to test raw type Parameterized<?, ?, ?> parameterized = new Parameterized<TypeTokenResolutionTest, Bar, String>() {}; TypeResolver typeResolver = TypeResolver.covariantly(parameterized.getClass()); ParameterizedType resolved = (ParameterizedType) typeResolver.resolveType(parameterized.parameterizedType()); assertEquals(TypeTokenResolutionTest.class, resolved.getOwnerType()); assertEquals(Bar.class, resolved.getRawType()); assertThat(resolved.getActualTypeArguments()).asList().contains(String.class); }
public void testGetSubtype_recursiveTypeBoundInSubtypeTranslatedAsIs() { class BaseWithTypeVar<T> {} class Outer<O> { class Sub<X> extends BaseWithTypeVar<List<X>> {} class Sub2<Y extends Sub2<Y>> extends BaseWithTypeVar<List<Y>> {} } ParameterizedType subtype = (ParameterizedType) new TypeToken<BaseWithTypeVar<List<?>>>() {}.getSubtype(Outer.Sub.class).getType(); assertEquals(Outer.Sub.class, subtype.getRawType()); assertThat(subtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class); ParameterizedType owner = (ParameterizedType) subtype.getOwnerType(); assertEquals(Outer.class, owner.getRawType()); // This returns a strange ? extends Sub2<Y> type, which isn't ideal. TypeToken<?> unused = new TypeToken<BaseWithTypeVar<List<?>>>() {}.getSubtype(Outer.Sub2.class); }
public void testNewParameterizedType() { ParameterizedType jvmType = (ParameterizedType) new TypeCapture<HashMap<String, int[][]>>() {}.capture(); ParameterizedType ourType = Types.newParameterizedType(HashMap.class, String.class, int[][].class); new EqualsTester().addEqualityGroup(jvmType, ourType).testEquals(); assertEquals(jvmType.toString(), ourType.toString()); assertEquals(jvmType.hashCode(), ourType.hashCode()); assertEquals(HashMap.class, ourType.getRawType()); assertThat(ourType.getActualTypeArguments()) .asList() .containsExactlyElementsIn(asList(jvmType.getActualTypeArguments())) .inOrder(); assertEquals( Arrays.asList(String.class, Types.newArrayType(Types.newArrayType(int.class))), Arrays.asList(ourType.getActualTypeArguments())); assertEquals(null, ourType.getOwnerType()); }
public void testNewParameterizedType_ownerTypeImplied() throws Exception { ParameterizedType jvmType = (ParameterizedType) new TypeCapture<Entry<String, Integer>>() {}.capture(); ParameterizedType ourType = Types.newParameterizedType(Entry.class, String.class, Integer.class); assertEquals(jvmType, ourType); assertEquals(Map.class, ourType.getOwnerType()); }
public void testNewParameterizedTypeWithOwner() { ParameterizedType jvmType = (ParameterizedType) new TypeCapture<Entry<String, int[][]>>() {}.capture(); ParameterizedType ourType = Types.newParameterizedTypeWithOwner(Map.class, Entry.class, String.class, int[][].class); new EqualsTester() .addEqualityGroup(jvmType, ourType) .addEqualityGroup(new TypeCapture<Entry<String, String>>() {}.capture()) .addEqualityGroup(new TypeCapture<Map<String, Integer>>() {}.capture()) .testEquals(); assertEquals(jvmType.toString(), ourType.toString()); assertEquals(Map.class, ourType.getOwnerType()); assertEquals(Entry.class, ourType.getRawType()); assertThat(ourType.getActualTypeArguments()) .asList() .containsExactlyElementsIn(asList(jvmType.getActualTypeArguments())) .inOrder(); }