/** * Return the underlying Java {@link Class} being managed, if available; * otherwise {@code null}. */ @Nullable public Class<?> getRawClass() { if (this.type == this.resolved) { return this.resolved; } Type rawType = this.type; if (rawType instanceof ParameterizedType) { rawType = ((ParameterizedType) rawType).getRawType(); } return (rawType instanceof Class ? (Class<?>) rawType : null); }
@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())); }
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); }
@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 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); }
@Test public void testSpr12701() throws Exception { ResolvableType resolvableType = ResolvableType.forClassWithGenerics(Callable.class, String.class); Type type = resolvableType.getType(); assertThat(type, is(instanceOf(ParameterizedType.class))); assertThat(((ParameterizedType) type).getRawType(), is(equalTo(Callable.class))); assertThat(((ParameterizedType) type).getActualTypeArguments().length, is(equalTo(1))); assertThat(((ParameterizedType) type).getActualTypeArguments()[0], is(equalTo(String.class))); }
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 testResolveToGenericArrayType() { GenericArrayType arrayType = (GenericArrayType) new Holder<List<int[][]>[]>() {}.getContentType(); ParameterizedType listType = (ParameterizedType) arrayType.getGenericComponentType(); assertEquals(List.class, listType.getRawType()); assertEquals(Types.newArrayType(int[].class), listType.getActualTypeArguments()[0]); }
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); }
@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_genericSubtypeOfGenericTypeWithFewerParameters() { TypeToken<List<String>> supertype = new TypeToken<List<String>>() {}; TypeToken<MySpecialList<String, ?>> subtype = new TypeToken<MySpecialList<String, ?>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(MySpecialList.class, actualSubtype.getRawType()); assertThat(actualSubtype.getActualTypeArguments()[0]).isEqualTo(String.class); assertThat(actualSubtype.getActualTypeArguments()[1]).isInstanceOf(TypeVariable.class); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
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_baseClassWithLessTypeArgs() { class SingleGenericExtendsBase<T> extends Base {} class DoubleGenericExtendsSingleGeneric<T1, TUnused> extends SingleGenericExtendsBase<T1> {} TypeToken<SingleGenericExtendsBase<?>> supertype = new TypeToken<SingleGenericExtendsBase<?>>() {}; TypeToken<DoubleGenericExtendsSingleGeneric<String, Integer>> subtype = new TypeToken<DoubleGenericExtendsSingleGeneric<String, Integer>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(DoubleGenericExtendsSingleGeneric.class, actualSubtype.getRawType()); assertThat(actualSubtype.getActualTypeArguments()[0]).isInstanceOf(WildcardType.class); }
public void testGetSubtype_genericSubtypeOfNonGenericType() { TypeToken<Serializable> supertype = new TypeToken<Serializable>() {}; TypeToken<ArrayList<String>> subtype = new TypeToken<ArrayList<String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(ArrayList.class, actualSubtype.getRawType()); assertThat(actualSubtype.getActualTypeArguments()[0]).isInstanceOf(TypeVariable.class); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
public void testGetSubtype_baseClassWithNoTypeArgs() { class SingleGenericExtendsBase<T> extends Base {} TypeToken<Base> supertype = new TypeToken<Base>() {}; TypeToken<SingleGenericExtendsBase<String>> subtype = new TypeToken<SingleGenericExtendsBase<String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(SingleGenericExtendsBase.class, actualSubtype.getRawType()); }
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 testConstructor_returnType_hasTypeParameter() throws Exception { @SuppressWarnings("rawtypes") // Foo.class for Foo<T> is always raw type Class<WithConstructorAndTypeParameter> type = WithConstructorAndTypeParameter.class; @SuppressWarnings("rawtypes") // Foo.class Constructor<WithConstructorAndTypeParameter> constructor = type.getDeclaredConstructor(); Invokable<?, ?> factory = Invokable.from(constructor); assertThat(factory.getTypeParameters()).hasLength(2); assertEquals(type.getTypeParameters()[0], factory.getTypeParameters()[0]); assertEquals(constructor.getTypeParameters()[0], factory.getTypeParameters()[1]); ParameterizedType returnType = (ParameterizedType) factory.getReturnType().getType(); assertEquals(type, returnType.getRawType()); assertEquals( ImmutableList.copyOf(type.getTypeParameters()), ImmutableList.copyOf(returnType.getActualTypeArguments())); }
public void testGetSubtype_baseClassInGenericClassWithNoTypeArgs() { class SingleGenericExtendsBase<T> implements GenericClass.Base {} TypeToken<GenericClass.Base> supertype = new TypeToken<GenericClass.Base>() {}; TypeToken<SingleGenericExtendsBase<String>> subtype = new TypeToken<SingleGenericExtendsBase<String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(SingleGenericExtendsBase.class, actualSubtype.getRawType()); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
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(); }