java.lang.reflect.Type

Here are the examples of the java api class java.lang.reflect.Type taken from open source projects.

1. Java8CallAdapterFactoryTest#responseType()

Project: retrofit
File: Java8CallAdapterFactoryTest.java
@Test
public void responseType() {
    Type bodyClass = new TypeToken<CompletableFuture<String>>() {
    }.getType();
    assertThat(factory.get(bodyClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type bodyWildcard = new TypeToken<CompletableFuture<? extends String>>() {
    }.getType();
    assertThat(factory.get(bodyWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type bodyGeneric = new TypeToken<CompletableFuture<List<String>>>() {
    }.getType();
    assertThat(factory.get(bodyGeneric, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(new TypeToken<List<String>>() {
    }.getType());
    Type responseClass = new TypeToken<CompletableFuture<Response<String>>>() {
    }.getType();
    assertThat(factory.get(responseClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type responseWildcard = new TypeToken<CompletableFuture<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(responseWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type resultClass = new TypeToken<CompletableFuture<Response<String>>>() {
    }.getType();
    assertThat(factory.get(resultClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type resultWildcard = new TypeToken<CompletableFuture<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(resultWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
}

2. GuavaCallAdapterFactoryTest#responseType()

Project: retrofit
File: GuavaCallAdapterFactoryTest.java
@Test
public void responseType() {
    Type bodyClass = new TypeToken<ListenableFuture<String>>() {
    }.getType();
    assertThat(factory.get(bodyClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type bodyWildcard = new TypeToken<ListenableFuture<? extends String>>() {
    }.getType();
    assertThat(factory.get(bodyWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type bodyGeneric = new TypeToken<ListenableFuture<List<String>>>() {
    }.getType();
    assertThat(factory.get(bodyGeneric, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(new TypeToken<List<String>>() {
    }.getType());
    Type responseClass = new TypeToken<ListenableFuture<Response<String>>>() {
    }.getType();
    assertThat(factory.get(responseClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type responseWildcard = new TypeToken<ListenableFuture<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(responseWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type resultClass = new TypeToken<ListenableFuture<Response<String>>>() {
    }.getType();
    assertThat(factory.get(resultClass, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
    Type resultWildcard = new TypeToken<ListenableFuture<Response<? extends String>>>() {
    }.getType();
    assertThat(factory.get(resultWildcard, NO_ANNOTATIONS, retrofit).responseType()).isEqualTo(String.class);
}

3. TypeUtilsTests#testWithWildcardTypes()

Project: spring-android
File: TypeUtilsTests.java
public void testWithWildcardTypes() throws Exception {
    ParameterizedType openObjectsType = (ParameterizedType) getClass().getField("openObjects").getGenericType();
    ParameterizedType openNumbersType = (ParameterizedType) getClass().getField("openNumbers").getGenericType();
    Type storableObjectListType = getClass().getField("storableObjectList").getGenericType();
    Type objectType = getClass().getField("object").getGenericType();
    Type numberType = getClass().getField("number").getGenericType();
    Type stringType = getClass().getField("string").getGenericType();
    // '?'
    Type openWildcard = openObjectsType.getActualTypeArguments()[0];
    // '? extends number'
    Type openNumbersWildcard = openNumbersType.getActualTypeArguments()[0];
    assertTrue(TypeUtils.isAssignable(openWildcard, objectType));
    assertTrue(TypeUtils.isAssignable(openNumbersWildcard, numberType));
    assertFalse(TypeUtils.isAssignable(openNumbersWildcard, stringType));
    assertFalse(TypeUtils.isAssignable(storableObjectListType, openObjectsType));
}

4. WildcardTypeTest#checkLowerBoundedParameter()

Project: j2objc
File: WildcardTypeTest.java
private void checkLowerBoundedParameter(Method method) {
    Type genericParameterType = method.getGenericParameterTypes()[0];
    assertInstanceOf(ParameterizedType.class, genericParameterType);
    ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    assertLenghtOne(actualTypeArguments);
    assertInstanceOf(WildcardType.class, actualTypeArguments[0]);
    WildcardType wildcardType = (WildcardType) actualTypeArguments[0];
    Type[] lowerBounds = wildcardType.getLowerBounds();
    assertLenghtOne(lowerBounds);
    Type lowerBound = lowerBounds[0];
    assertEquals(getTypeParameter(method), lowerBound);
    Type[] upperBounds = wildcardType.getUpperBounds();
    assertEquals(Object.class, upperBounds[0]);
}

5. TypeResolver#resolveParameterizedType()

Project: cdk
File: TypeResolver.java
private ParameterizedType resolveParameterizedType(ParameterizedType type) {
    Type owner = type.getOwnerType();
    Type resolvedOwner = (owner == null) ? null : resolveType(owner);
    Type resolvedRawType = resolveType(type.getRawType());
    Type[] vars = type.getActualTypeArguments();
    Type[] resolvedArgs = new Type[vars.length];
    for (int i = 0; i < vars.length; i++) {
        resolvedArgs[i] = resolveType(vars[i]);
    }
    return Types.newParameterizedTypeWithOwner(resolvedOwner, (Class<?>) resolvedRawType, resolvedArgs);
}

6. CallAdapterTest#rawTypes()

Project: retrofit
File: CallAdapterTest.java
@Test
public void rawTypes() throws NoSuchMethodException {
    assertThat(getRawType(String.class)).isSameAs(String.class);
    Type listOfString = new TypeToken<List<String>>() {
    }.getType();
    assertThat(getRawType(listOfString)).isSameAs(List.class);
    Type stringArray = new TypeToken<String[]>() {
    }.getType();
    assertThat(getRawType(stringArray)).isSameAs(String[].class);
    Type wild = ((ParameterizedType) new TypeToken<List<? extends CharSequence>>() {
    }.getType()).getActualTypeArguments()[0];
    assertThat(getRawType(wild)).isSameAs(CharSequence.class);
    Type wildParam = ((ParameterizedType) new TypeToken<List<? extends List<String>>>() {
    }.getType()).getActualTypeArguments()[0];
    assertThat(getRawType(wildParam)).isSameAs(List.class);
    Type typeVar = A.class.getDeclaredMethod("method").getGenericReturnType();
    assertThat(getRawType(typeVar)).isSameAs(Object.class);
}

7. GenericClassTest#testStable()

Project: openwebbeans
File: GenericClassTest.java
@Test
public void testStable() throws Exception {
    Type parameterizedPigStableType = this.getClass().getDeclaredField("parameterizedPigStable").getGenericType();
    Type parameterizedHorseStableType = this.getClass().getDeclaredField("parameterizedHorseStable").getGenericType();
    Assert.assertNotNull(parameterizedPigStableType);
    Assert.assertNotNull(parameterizedHorseStableType);
    Type pigStableType = this.getClass().getDeclaredField("pigStable").getType().getGenericSuperclass();
    Type horseStableType = this.getClass().getDeclaredField("horseStable").getType().getGenericSuperclass();
    Assert.assertTrue(GenericsUtil.satisfiesDependency(false, false, horseStableType, parameterizedHorseStableType));
    Assert.assertTrue(GenericsUtil.satisfiesDependency(false, false, parameterizedPigStableType, pigStableType));
}

8. GraphTaskManager#determineClassTypes()

Project: giraph
File: GraphTaskManager.java
/**
   * Set the concrete, user-defined choices about generic methods
   * (validated earlier in GiraphRunner) into the Configuration.
   * @param conf the Configuration object for this job run.
   */
public void determineClassTypes(Configuration conf) {
    ImmutableClassesGiraphConfiguration giraphConf = new ImmutableClassesGiraphConfiguration(conf);
    Class<? extends Vertex<I, V, E, M>> vertexClass = giraphConf.getVertexClass();
    List<Class<?>> classList = ReflectionUtils.<Vertex>getTypeArguments(Vertex.class, vertexClass);
    Type vertexIndexType = classList.get(0);
    Type vertexValueType = classList.get(1);
    Type edgeValueType = classList.get(2);
    Type messageValueType = classList.get(3);
    VERTEX_ID_CLASS.set(conf, (Class<WritableComparable>) vertexIndexType);
    VERTEX_VALUE_CLASS.set(conf, (Class<Writable>) vertexValueType);
    EDGE_VALUE_CLASS.set(conf, (Class<Writable>) edgeValueType);
    MESSAGE_VALUE_CLASS.set(conf, (Class<Writable>) messageValueType);
}

9. HierarchyDiscovery#resolveParameterizedType()

Project: deltaspike
File: HierarchyDiscovery.java
private Type resolveParameterizedType(ParameterizedType beanType, ParameterizedType parameterizedType) {
    Type rawType = parameterizedType.getRawType();
    Type[] actualTypes = parameterizedType.getActualTypeArguments();
    Type resolvedRawType = resolveType(beanType, beanType, rawType);
    Type[] resolvedActualTypes = new Type[actualTypes.length];
    for (int i = 0; i < actualTypes.length; i++) {
        resolvedActualTypes[i] = resolveType(beanType, beanType, actualTypes[i]);
    }
    // reconstruct ParameterizedType by types resolved TypeVariable.
    return new ParameterizedTypeImpl(resolvedRawType, resolvedActualTypes, parameterizedType.getOwnerType());
}

10. TypeUtilsTest#testGetRawType()

Project: commons-lang
File: TypeUtilsTest.java
@Test
public void testGetRawType() throws SecurityException, NoSuchFieldException {
    final Type stringParentFieldType = GenericTypeHolder.class.getDeclaredField("stringParent").getGenericType();
    final Type integerParentFieldType = GenericTypeHolder.class.getDeclaredField("integerParent").getGenericType();
    final Type foosFieldType = GenericTypeHolder.class.getDeclaredField("foos").getGenericType();
    final Type genericParentT = GenericParent.class.getTypeParameters()[0];
    Assert.assertEquals(GenericParent.class, TypeUtils.getRawType(stringParentFieldType, null));
    Assert.assertEquals(GenericParent.class, TypeUtils.getRawType(integerParentFieldType, null));
    Assert.assertEquals(List.class, TypeUtils.getRawType(foosFieldType, null));
    Assert.assertEquals(String.class, TypeUtils.getRawType(genericParentT, StringParameterizedChild.class));
    Assert.assertEquals(String.class, TypeUtils.getRawType(genericParentT, stringParentFieldType));
    Assert.assertEquals(Foo.class, TypeUtils.getRawType(Iterable.class.getTypeParameters()[0], foosFieldType));
    Assert.assertEquals(Foo.class, TypeUtils.getRawType(List.class.getTypeParameters()[0], foosFieldType));
    Assert.assertNull(TypeUtils.getRawType(genericParentT, GenericParent.class));
    Assert.assertEquals(GenericParent[].class, TypeUtils.getRawType(GenericTypeHolder.class.getDeclaredField("barParents").getGenericType(), null));
}

11. FindTheParameterizedType#main()

Project: tapestry5
File: FindTheParameterizedType.java
/**
     * @param args
     */
public static void main(String[] args) throws Exception {
    Method m = FindTheParameterizedType.class.getMethod("method", Map.class, List.class);
    out.println(m.toString());
    out.println(m.toGenericString());
    Type[] types = m.getGenericParameterTypes();
    ParameterizedType pt = (ParameterizedType) types[0];
    Type keyType = pt.getActualTypeArguments()[0];
    Type valueType = pt.getActualTypeArguments()[1];
    out.printf("   key type: %s\n", rawType(keyType));
    out.printf(" value type: %s\n", rawType(valueType));
    Type listType = types[1];
    out.printf("  list type: %s\n", rawType(listType));
}

12. FindTheParameterizedType#main()

Project: tapestry-5
File: FindTheParameterizedType.java
/**
     * @param args
     */
public static void main(String[] args) throws Exception {
    Method m = FindTheParameterizedType.class.getMethod("method", Map.class, List.class);
    out.println(m.toString());
    out.println(m.toGenericString());
    Type[] types = m.getGenericParameterTypes();
    ParameterizedType pt = (ParameterizedType) types[0];
    Type keyType = pt.getActualTypeArguments()[0];
    Type valueType = pt.getActualTypeArguments()[1];
    out.printf("   key type: %s\n", rawType(keyType));
    out.printf(" value type: %s\n", rawType(valueType));
    Type listType = types[1];
    out.printf("  list type: %s\n", rawType(listType));
}

13. HierarchyDiscovery#resolveParameterizedType()

Project: rewrite
File: HierarchyDiscovery.java
private Type resolveParameterizedType(ParameterizedType beanType, ParameterizedType parameterizedType) {
    Type rawType = parameterizedType.getRawType();
    Type[] actualTypes = parameterizedType.getActualTypeArguments();
    Type resolvedRawType = resolveType(beanType, beanType, rawType);
    Type[] resolvedActualTypes = new Type[actualTypes.length];
    for (int i = 0; i < actualTypes.length; i++) {
        resolvedActualTypes[i] = resolveType(beanType, beanType, actualTypes[i]);
    }
    // reconstruct ParameterizedType by types resolved TypeVariable.
    return new ParameterizedTypeImpl(resolvedRawType, resolvedActualTypes, parameterizedType.getOwnerType());
}

14. WildcardTypeTest#checkUpperBoundedParameter()

Project: j2objc
File: WildcardTypeTest.java
private void checkUpperBoundedParameter(Method method) {
    assertLenghtOne(method.getGenericParameterTypes());
    Type genericParameterType = method.getGenericParameterTypes()[0];
    assertInstanceOf(ParameterizedType.class, genericParameterType);
    ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    assertLenghtOne(actualTypeArguments);
    assertInstanceOf(WildcardType.class, actualTypeArguments[0]);
    WildcardType wildcardType = (WildcardType) actualTypeArguments[0];
    assertLenghtZero(wildcardType.getLowerBounds());
    Type[] upperBounds = wildcardType.getUpperBounds();
    assertLenghtOne(upperBounds);
    Type upperBound = upperBounds[0];
    assertEquals(getTypeParameter(method), upperBound);
}

15. AggregateConverter#getExactDirectSuperTypes()

Project: aries
File: AggregateConverter.java
public static ReifiedType[] getExactDirectSuperTypes(ReifiedType type) {
    Class<?> clazz = type.getRawClass();
    Type[] superInterfaces = clazz.getGenericInterfaces();
    Type superClass = clazz.getGenericSuperclass();
    // the only supertype of an interface without superinterfaces is Object
    if (superClass == null && superInterfaces.length == 0 && clazz.isInterface()) {
        return new ReifiedType[] { new GenericType(Object.class) };
    }
    ReifiedType[] result;
    int resultIndex;
    if (superClass == null) {
        result = new ReifiedType[superInterfaces.length];
        resultIndex = 0;
    } else {
        result = new ReifiedType[superInterfaces.length + 1];
        resultIndex = 1;
        result[0] = mapTypeParameters(superClass, type);
    }
    for (Type superInterface : superInterfaces) {
        result[resultIndex++] = mapTypeParameters(superInterface, type);
    }
    return result;
}

16. GenericTypeResolver#resolveReturnTypeArgument()

Project: Android-Next
File: GenericTypeResolver.java
/**
     * Resolve the single type argument of the given generic interface against the given
     * target method which is assumed to return the given interface or an implementation
     * of it.
     *
     * @param method     the target method to check the return type of
     * @param genericIfc the generic interface or superclass to resolve the type argument from
     * @return the resolved parameter type of the method return type, or {@code null}
     * if not resolvable or if the single argument is of type {@link WildcardType}.
     */
public static Class<?> resolveReturnTypeArgument(Method method, Class<?> genericIfc) {
    Assert.notNull(method, "method must not be null");
    Type returnType = method.getReturnType();
    Type genericReturnType = method.getGenericReturnType();
    if (returnType.equals(genericIfc)) {
        if (genericReturnType instanceof ParameterizedType) {
            ParameterizedType targetType = (ParameterizedType) genericReturnType;
            Type[] actualTypeArguments = targetType.getActualTypeArguments();
            Type typeArg = actualTypeArguments[0];
            if (!(typeArg instanceof WildcardType)) {
                return (Class<?>) typeArg;
            }
        } else {
            return null;
        }
    }
    return resolveTypeArgument((Class<?>) returnType, genericIfc);
}

17. FormMultivaluedMapProvider#isReadable()

Project: wink
File: FormMultivaluedMapProvider.java
public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
    // must be a multivalued map and parameterized with Strings
    if (!(MultivaluedMap.class == type) || !(genericType instanceof ParameterizedType)) {
        return false;
    }
    ParameterizedType pType = (ParameterizedType) genericType;
    Type[] actualTypeArguments = pType.getActualTypeArguments();
    Type type1 = actualTypeArguments[0];
    Type type2 = actualTypeArguments[1];
    if (!(type1 instanceof Class<?>) || !((Class<?>) type1).equals(String.class) || !(type2 instanceof Class<?>) || !((Class<?>) type2).equals(String.class)) {
        return false;
    }
    return true;
}

18. TypeTokenResolutionTest#testConextIsParameterizedType()

Project: guava
File: TypeTokenResolutionTest.java
public void testConextIsParameterizedType() throws Exception {
    class Context {

        // used by reflection
        @SuppressWarnings("unused")
        Map<String, Integer> returningMap() {
            throw new AssertionError();
        }
    }
    Type context = Context.class.getDeclaredMethod("returningMap").getGenericReturnType();
    Type keyType = Map.class.getTypeParameters()[0];
    Type valueType = Map.class.getTypeParameters()[1];
    // context is parameterized type
    assertEquals(String.class, TypeToken.of(context).resolveType(keyType).getType());
    assertEquals(Integer.class, TypeToken.of(context).resolveType(valueType).getType());
    // context is type variable
    assertEquals(keyType, TypeToken.of(keyType).resolveType(keyType).getType());
    assertEquals(valueType, TypeToken.of(valueType).resolveType(valueType).getType());
}

19. TypesTest#testNewArrayType()

Project: guava
File: TypesTest.java
public void testNewArrayType() {
    Type jvmType1 = new TypeCapture<List<String>[]>() {
    }.capture();
    GenericArrayType ourType1 = (GenericArrayType) Types.newArrayType(Types.newParameterizedType(List.class, String.class));
    Type jvmType2 = new TypeCapture<List[]>() {
    }.capture();
    Type ourType2 = Types.newArrayType(List.class);
    new EqualsTester().addEqualityGroup(jvmType1, ourType1).addEqualityGroup(jvmType2, ourType2).testEquals();
    assertEquals(new TypeCapture<List<String>>() {
    }.capture(), ourType1.getGenericComponentType());
    assertEquals(jvmType1.toString(), ourType1.toString());
    assertEquals(jvmType2.toString(), ourType2.toString());
}

20. ObjectMapper#registerTypeConverter()

Project: easybatch-framework
File: ObjectMapper.java
public void registerTypeConverter(final TypeConverter typeConverter) {
    //retrieve the target class name of the converter
    Class<? extends TypeConverter> typeConverterClass = typeConverter.getClass();
    Type[] genericInterfaces = typeConverterClass.getGenericInterfaces();
    Type genericInterface = genericInterfaces[0];
    if (!(genericInterface instanceof ParameterizedType)) {
        LOGGER.log(Level.WARNING, "The type converter {0} should be a parametrized type", typeConverterClass.getName());
        return;
    }
    ParameterizedType parameterizedType = (ParameterizedType) genericInterface;
    Type type = parameterizedType.getActualTypeArguments()[1];
    // register the converter
    try {
        Class clazz = Class.forName(getClassName(type));
        typeConverters.put(clazz, typeConverter);
    } catch (ClassNotFoundException e) {
        throw new TypeConverterRegistrationException("Unable to register custom type converter " + typeConverterClass.getName(), e);
    }
}

21. Mirror#getTypeParams()

Project: nutz
File: Mirror.java
/**
     * ??????????????????????????? null
     */
public static Type[] getTypeParams(Class<?> klass) {
    // TODO ???????????,????????
    if (klass == null || "java.lang.Object".equals(klass.getName()))
        return null;
    // ????
    Type superclass = klass.getGenericSuperclass();
    if (null != superclass && superclass instanceof ParameterizedType)
        return ((ParameterizedType) superclass).getActualTypeArguments();
    // ????
    Type[] interfaces = klass.getGenericInterfaces();
    for (Type inf : interfaces) {
        if (inf instanceof ParameterizedType) {
            return ((ParameterizedType) inf).getActualTypeArguments();
        }
    }
    return getTypeParams(klass.getSuperclass());
}

22. ParameterConvertersBehaviour#shouldConvertCommaSeparatedValuesToListOfStrings()

Project: jbehave-core
File: ParameterConvertersBehaviour.java
@Test
public void shouldConvertCommaSeparatedValuesToListOfStrings() throws IntrospectionException {
    ParameterConverter converter = new StringListConverter();
    Type listOfStrings = SomeSteps.methodFor("aMethodWithListOfStrings").getGenericParameterTypes()[0];
    Type listOfNumbers = SomeSteps.methodFor("aMethodWithListOfNumbers").getGenericParameterTypes()[0];
    Type setOfNumbers = SomeSteps.methodFor("aMethodWithSetOfNumbers").getGenericParameterTypes()[0];
    assertThat(converter.accept(listOfStrings), is(true));
    assertThat(converter.accept(listOfNumbers), is(false));
    assertThat(converter.accept(setOfNumbers), is(false));
    ensureValueIsConvertedToList(converter, listOfStrings, "a, string ", Arrays.asList("a", "string"));
    ensureValueIsConvertedToList(converter, listOfStrings, " ", Arrays.asList(new String[] {}));
}

23. WildcardTypeTest#checkReturnType()

Project: j2objc
File: WildcardTypeTest.java
@SuppressWarnings("unchecked")
private void checkReturnType(Method method) {
    Type genericReturnType = method.getGenericReturnType();
    assertEquals(getTypeParameter(method), genericReturnType);
    assertTrue(genericReturnType instanceof TypeVariable);
    TypeVariable<Method> returnTypeVariable = (TypeVariable<Method>) genericReturnType;
    assertEquals(method, returnTypeVariable.getGenericDeclaration());
    Type[] bounds = returnTypeVariable.getBounds();
    assertLenghtOne(bounds);
    Type bound = bounds[0];
    assertEquals(BoundedWildcardsGenericMethods.class, bound);
}

24. BoundedGenericMethodsTests#checkReturnType()

Project: j2objc
File: BoundedGenericMethodsTests.java
@SuppressWarnings("unchecked")
private void checkReturnType(Method method) {
    Type genericReturnType = method.getGenericReturnType();
    assertEquals(getTypeParameter(method), genericReturnType);
    assertTrue(genericReturnType instanceof TypeVariable);
    TypeVariable<Method> returnTypeVariable = (TypeVariable<Method>) genericReturnType;
    assertEquals(method, returnTypeVariable.getGenericDeclaration());
    Type[] bounds = returnTypeVariable.getBounds();
    assertLenghtOne(bounds);
    Type bound = bounds[0];
    assertEquals(BoundedGenericMethods.class, bound);
}

25. BoundedGenericMethodsTests#parameterType()

Project: j2objc
File: BoundedGenericMethodsTests.java
/**
     * Tests whether the specified method declares a parameter with the type of
     * the type parameter.
     *
     * @param method
     *            the declaring method
     */
private void parameterType(Method method) {
    TypeVariable<Method> typeParameter = getTypeParameter(method);
    assertLenghtOne(method.getGenericParameterTypes());
    Type genericParameterType = method.getGenericParameterTypes()[0];
    assertEquals(typeParameter, genericParameterType);
    assertTrue(genericParameterType instanceof TypeVariable);
    TypeVariable<?> typeVariable = (TypeVariable<?>) genericParameterType;
    assertEquals(method, typeVariable.getGenericDeclaration());
    Type[] paramBounds = typeVariable.getBounds();
    assertLenghtOne(paramBounds);
    Type paramBound = paramBounds[0];
    assertEquals(BoundedGenericMethods.class, paramBound);
}

26. TypeUtilsTests#testWithParameterizedTypes()

Project: spring-android
File: TypeUtilsTests.java
public void testWithParameterizedTypes() throws Exception {
    Type objectsType = getClass().getField("objects").getGenericType();
    Type openObjectsType = getClass().getField("openObjects").getGenericType();
    Type stringsType = getClass().getField("strings").getGenericType();
    assertTrue(TypeUtils.isAssignable(Object.class, objectsType));
    assertTrue(TypeUtils.isAssignable(Object.class, openObjectsType));
    assertTrue(TypeUtils.isAssignable(Object.class, stringsType));
    assertTrue(TypeUtils.isAssignable(List.class, objectsType));
    assertTrue(TypeUtils.isAssignable(List.class, openObjectsType));
    assertTrue(TypeUtils.isAssignable(List.class, stringsType));
    assertTrue(TypeUtils.isAssignable(objectsType, List.class));
    assertTrue(TypeUtils.isAssignable(openObjectsType, List.class));
    assertTrue(TypeUtils.isAssignable(stringsType, List.class));
    assertTrue(TypeUtils.isAssignable(objectsType, objectsType));
    assertTrue(TypeUtils.isAssignable(openObjectsType, openObjectsType));
    assertTrue(TypeUtils.isAssignable(stringsType, stringsType));
    assertTrue(TypeUtils.isAssignable(openObjectsType, objectsType));
    assertTrue(TypeUtils.isAssignable(openObjectsType, stringsType));
    assertFalse(TypeUtils.isAssignable(stringsType, objectsType));
    assertFalse(TypeUtils.isAssignable(objectsType, stringsType));
}

27. GenericTypeResolver#resolveReturnTypeArgument()

Project: spring-android
File: GenericTypeResolver.java
/**
	 * Resolve the single type argument of the given generic interface against the given
	 * target method which is assumed to return the given interface or an implementation
	 * of it.
	 * @param method the target method to check the return type of
	 * @param genericIfc the generic interface or superclass to resolve the type argument from
	 * @return the resolved parameter type of the method return type, or {@code null}
	 * if not resolvable or if the single argument is of type {@link WildcardType}.
	 */
public static Class<?> resolveReturnTypeArgument(Method method, Class<?> genericIfc) {
    Assert.notNull(method, "method must not be null");
    Type returnType = method.getReturnType();
    Type genericReturnType = method.getGenericReturnType();
    if (returnType.equals(genericIfc)) {
        if (genericReturnType instanceof ParameterizedType) {
            ParameterizedType targetType = (ParameterizedType) genericReturnType;
            Type[] actualTypeArguments = targetType.getActualTypeArguments();
            Type typeArg = actualTypeArguments[0];
            if (!(typeArg instanceof WildcardType)) {
                return (Class<?>) typeArg;
            }
        } else {
            return null;
        }
    }
    return resolveTypeArgument((Class<?>) returnType, genericIfc);
}

28. GenericTypeReflector#getExactParameterTypes()

Project: spock
File: GenericTypeReflector.java
public static Type[] getExactParameterTypes(Method m, Type type) {
    Type[] parameterTypes = m.getGenericParameterTypes();
    if (m.getDeclaringClass() == Object.class) {
        return parameterTypes;
    }
    Type exactDeclaringType = getExactSuperType(capture(type), m.getDeclaringClass());
    Type[] result = new Type[parameterTypes.length];
    for (int i = 0; i < parameterTypes.length; i++) {
        result[i] = mapTypeParameters(parameterTypes[i], exactDeclaringType);
    }
    return result;
}

29. TypesTest#testClassGenericTypeDiscovery()

Project: Resteasy
File: TypesTest.java
@Test
public void testClassGenericTypeDiscovery() throws Exception {
    Type[] types = Types.findParameterizedTypes(ClassFooBar.class, ClassBar.class);
    for (Type t : types) {
        System.out.println(t);
    }
    Assert.assertEquals(types[0], Float.class);
    types = Types.findParameterizedTypes(ClassSub.class, ClassBar.class);
    for (Type t : types) {
        System.out.println(t);
    }
    Assert.assertEquals(types[0], Float.class);
}

30. GenericsUtil#resolveTypeArguments()

Project: openwebbeans
File: GenericsUtil.java
private static Type[] resolveTypeArguments(Class<?> subclass, ParameterizedType parameterizedSupertype) {
    Type genericSuperclass = getGenericSuperclass(subclass, getRawType(parameterizedSupertype));
    if (!(genericSuperclass instanceof ParameterizedType)) {
        return subclass.getTypeParameters();
    }
    ParameterizedType parameterizedSuperclass = (ParameterizedType) genericSuperclass;
    Type[] typeParameters = subclass.getTypeParameters();
    Type[] actualTypeArguments = parameterizedSupertype.getActualTypeArguments();
    return resolveTypeArguments(parameterizedSuperclass, typeParameters, actualTypeArguments);
}

31. GenericTypeReflector#getExactParameterTypes()

Project: objectify
File: GenericTypeReflector.java
/**
	 * Returns the exact parameter types of the given method in the given type.
	 * This may be different from <tt>m.getGenericParameterTypes()</tt> when the method was declared in a superclass,
	 * or <tt>type</tt> has a type parameter that is used in one of the parameters, or <tt>type</tt> is a raw type.
	 */
public static Type[] getExactParameterTypes(Method m, Type type) {
    Type[] parameterTypes = m.getGenericParameterTypes();
    Type exactDeclaringType = getExactSuperType(capture(type), m.getDeclaringClass());
    if (// capture(type) is not a subtype of m.getDeclaringClass()
    exactDeclaringType == null) {
        throw new IllegalArgumentException("The method " + m + " is not a member of type " + type);
    }
    Type[] result = new Type[parameterTypes.length];
    for (int i = 0; i < parameterTypes.length; i++) {
        result[i] = mapTypeParameters(parameterTypes[i], exactDeclaringType);
    }
    return result;
}

32. Types#getContainerClass()

Project: buck
File: Types.java
/**
   * @return The raw type of the {@link Collection} a field represents, even if contained in an
   *    {@link Optional}, but without the ParameterizedType information.
   */
@SuppressWarnings("unchecked")
@Nullable
public static Class<? extends Collection<?>> getContainerClass(Field field) {
    Type type = getFirstNonOptionalType(field);
    if (!(type instanceof ParameterizedType)) {
        return null;
    }
    Type rawType = ((ParameterizedType) type).getRawType();
    if (!(rawType instanceof Class)) {
        return null;
    }
    Class<?> clazz = (Class<?>) rawType;
    if (!(Collection.class.isAssignableFrom(clazz))) {
        return null;
    }
    return (Class<? extends Collection<?>>) clazz;
}

33. CPPRuntimeTest#testType()

Project: BridJ
File: CPPRuntimeTest.java
@Test
public void testType() {
    int[] targsCount = new int[1];
    Object[] targsAndArgs = new Object[] { int.class, double.class };
    Type expected = CPPType.getCPPType(Temp.class, int.class, double.class);
    Type actual = runtime.getType(Temp.class, targsAndArgs, targsCount);
    assertEquals(expected, actual);
    assertEquals(2, targsCount[0]);
    actual = runtime.getType(Temp.class, targsAndArgs, null);
    assertEquals(expected, actual);
}

34. TypeUtils#isAssignable()

Project: bboss
File: TypeUtils.java
private static boolean isAssignable(WildcardType lhsType, Type rhsType) {
    Type[] upperBounds = lhsType.getUpperBounds();
    Type[] lowerBounds = lhsType.getLowerBounds();
    for (int size = upperBounds.length, i = 0; i < size; ++i) {
        if (!isAssignable(upperBounds[i], rhsType)) {
            return false;
        }
    }
    for (int size = lowerBounds.length, i = 0; i < size; ++i) {
        if (!isAssignable(rhsType, lowerBounds[i])) {
            return false;
        }
    }
    return true;
}

35. TypeUtils#isAssignable()

Project: bboss
File: TypeUtils.java
private static boolean isAssignable(ParameterizedType lhsType, ParameterizedType rhsType) {
    if (lhsType.equals(rhsType)) {
        return true;
    }
    Type[] lhsTypeArguments = lhsType.getActualTypeArguments();
    Type[] rhsTypeArguments = rhsType.getActualTypeArguments();
    if (lhsTypeArguments.length != rhsTypeArguments.length) {
        return false;
    }
    for (int size = lhsTypeArguments.length, i = 0; i < size; ++i) {
        Type lhsArg = lhsTypeArguments[i];
        Type rhsArg = rhsTypeArguments[i];
        if (!lhsArg.equals(rhsArg) && !(lhsArg instanceof WildcardType && isAssignable((WildcardType) lhsArg, rhsArg))) {
            return false;
        }
    }
    return true;
}

36. ReflectUtils#getClassGenricType()

Project: AutoLoadCache
File: ReflectUtils.java
/**
     * ?????????????
     * @param clazz ????
     * @param index ??
     */
public static Class<?> getClassGenricType(final Class<?> clazz, final int index) {
    Type genType = clazz.getGenericSuperclass();
    if (!(genType instanceof ParameterizedType)) {
        return Object.class;
    }
    Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    if (index >= params.length || index < 0) {
        return Object.class;
    }
    if (!(params[index] instanceof Class)) {
        return Object.class;
    }
    return (Class<?>) params[index];
}

37. PairParser#doParse()

Project: aurora
File: PairParser.java
@Override
Pair<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type leftType = typeParams.get(0);
    Parser<?> leftParser = parserOracle.get(TypeToken.of(leftType));
    Type rightType = typeParams.get(1);
    Parser<?> rightParser = parserOracle.get(TypeToken.of(rightType));
    List<String> parts = ImmutableList.copyOf(Parsers.MULTI_VALUE_SPLITTER.split(raw));
    checkArgument(parts.size() == 2, "Only two values may be specified for a pair, you gave " + parts.size());
    return Pair.of(leftParser.parse(parserOracle, leftType, parts.get(0)), rightParser.parse(parserOracle, rightType, parts.get(1)));
}

38. MultimapParser#doParse()

Project: aurora
File: MultimapParser.java
@SuppressWarnings("unchecked")
@Override
Multimap<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type keyType = typeParams.get(0);
    Parser<?> keyParser = parserOracle.get(TypeToken.of(keyType));
    Type valueType = typeParams.get(1);
    Parser<?> valueParser = parserOracle.get(TypeToken.of(valueType));
    ImmutableMultimap.Builder<Object, Object> multimapBuilder = ImmutableMultimap.builder();
    for (String keyAndValue : Parsers.MULTI_VALUE_SPLITTER.split(raw)) {
        List<String> fields = ImmutableList.copyOf(KEY_VALUE_SPLITTER.split(keyAndValue));
        checkArgument(fields.size() == 2, "Failed to parse key/value pair: " + keyAndValue);
        multimapBuilder.put(keyParser.parse(parserOracle, keyType, fields.get(0)), valueParser.parse(parserOracle, valueType, fields.get(1)));
    }
    return multimapBuilder.build();
}

39. MapParser#doParse()

Project: aurora
File: MapParser.java
@SuppressWarnings("unchecked")
@Override
Map<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type keyType = typeParams.get(0);
    Parser<?> keyParser = parserOracle.get(TypeToken.of(keyType));
    Type valueType = typeParams.get(1);
    Parser<?> valueParser = parserOracle.get(TypeToken.of(valueType));
    ImmutableMap.Builder<Object, Object> map = ImmutableMap.builder();
    for (String keyAndValue : Parsers.MULTI_VALUE_SPLITTER.split(raw)) {
        List<String> fields = ImmutableList.copyOf(KEY_VALUE_SPLITTER.split(keyAndValue));
        checkArgument(fields.size() == 2, "Failed to parse key/value pair " + keyAndValue);
        map.put(keyParser.parse(parserOracle, keyType, fields.get(0)), valueParser.parse(parserOracle, valueType, fields.get(1)));
    }
    return map.build();
}

40. AmountParser#doParse()

Project: aurora
File: AmountParser.java
@Override
Amount<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type valueType = typeParams.get(0);
    Parser<?> parser = parserOracle.get(TypeToken.of(valueType));
    Matcher matcher = AMOUNT_PATTERN.matcher(raw);
    checkArgument(matcher.matches(), "Value '" + raw + "' must be of the format 1ns, 4mb, etc.");
    Number number = (Number) parser.parse(parserOracle, valueType, matcher.group(1));
    String unitRaw = matcher.group(2);
    Type unitType = typeParams.get(1);
    @SuppressWarnings("rawtypes") Parser<Unit> unitParser = parserOracle.get(TypeToken.of(Unit.class));
    @SuppressWarnings("rawtypes") Unit unit = unitParser.parse(parserOracle, unitType, unitRaw);
    checkArgument(unit.getClass() == unitType, String.format("Unit type (%s) does not match argument type (%s).", unit.getClass(), unitType));
    return create(valueType, number, unit);
}

41. TypeUtils#isAssignable()

Project: Android-Next
File: TypeUtils.java
private static boolean isAssignable(ParameterizedType lhsType, ParameterizedType rhsType) {
    if (lhsType.equals(rhsType)) {
        return true;
    }
    Type[] lhsTypeArguments = lhsType.getActualTypeArguments();
    Type[] rhsTypeArguments = rhsType.getActualTypeArguments();
    if (lhsTypeArguments.length != rhsTypeArguments.length) {
        return false;
    }
    for (int size = lhsTypeArguments.length, i = 0; i < size; ++i) {
        Type lhsArg = lhsTypeArguments[i];
        Type rhsArg = rhsTypeArguments[i];
        if (!lhsArg.equals(rhsArg) && !(lhsArg instanceof WildcardType && isAssignable((WildcardType) lhsArg, rhsArg))) {
            return false;
        }
    }
    return true;
}

42. MapTypeAdapterFactory#create()

Project: android-lite-http
File: MapTypeAdapterFactory.java
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Type type = typeToken.getType();
    Class<? super T> rawType = typeToken.getRawType();
    if (!Map.class.isAssignableFrom(rawType)) {
        return null;
    }
    Class<?> rawTypeOfSrc = $Gson$Types.getRawType(type);
    Type[] keyAndValueTypes = $Gson$Types.getMapKeyAndValueTypes(type, rawTypeOfSrc);
    TypeAdapter<?> keyAdapter = getKeyAdapter(gson, keyAndValueTypes[0]);
    TypeAdapter<?> valueAdapter = gson.getAdapter(TypeToken.get(keyAndValueTypes[1]));
    ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);
    @SuppressWarnings({ "unchecked", "rawtypes" }) // we don't define a type parameter for the key or value types
    TypeAdapter<T> result = new Adapter(gson, keyAndValueTypes[0], keyAdapter, keyAndValueTypes[1], valueAdapter, constructor);
    return result;
}

43. CollectionTypeAdapterFactory#create()

Project: android-lite-http
File: CollectionTypeAdapterFactory.java
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Type type = typeToken.getType();
    Class<? super T> rawType = typeToken.getRawType();
    if (!Collection.class.isAssignableFrom(rawType)) {
        return null;
    }
    Type elementType = $Gson$Types.getCollectionElementType(type, rawType);
    TypeAdapter<?> elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType));
    ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);
    // create() doesn't define a type parameter
    @SuppressWarnings({ "unchecked", "rawtypes" }) TypeAdapter<T> result = new Adapter(gson, elementType, elementTypeAdapter, constructor);
    return result;
}

44. Accessor#getItemType()

Project: airline
File: Accessor.java
private static Class<?> getItemType(String name, Type type) {
    Class<?> rawClass = getRawType(type);
    if (rawClass == null) {
        throw new ParseException("Type of option %s be an exact type", name);
    }
    if (!Collection.class.isAssignableFrom(rawClass)) {
        return rawClass;
    }
    Type[] types = getTypeParameters(Collection.class, type);
    if ((types == null) || (types.length != 1)) {
        throw new ParseException("Unable to get item type of Collection option %s", name);
    }
    Type itemType = types[0];
    if (!(itemType instanceof Class)) {
        throw new ParseException("Collection type option %s must be an exact type", name);
    }
    return (Class<?>) itemType;
}

45. EventTypeMetadata#extractIterableType()

Project: airlift
File: EventTypeMetadata.java
private Class<?> extractIterableType(Method method) {
    Type[] types = getTypeParameters(Iterable.class, method.getGenericReturnType());
    if ((types == null) || (types.length != 1)) {
        addMethodError("Unable to get type parameter for iterable [%s]", method, method.getGenericReturnType());
        return null;
    }
    Type type = types[0];
    if (!(type instanceof Class)) {
        addMethodError("Iterable type parameter [%s] must be an exact type", method, type);
        return null;
    }
    if (isIterable((Class<?>) type)) {
        addMethodError("Iterable of iterable is not supported", method);
        return null;
    }
    return (Class<?>) type;
}

46. TypeResolver#resolveGenericType()

Project: wasync
File: TypeResolver.java
/**
     * Resolves the generic Type for the {@code targetType} by walking the type hierarchy upwards from
     * the {@code initialType}.
     */
public static Type resolveGenericType(Type initialType, Class<?> targetType) {
    Class<?> rawType;
    if (initialType instanceof ParameterizedType)
        rawType = (Class<?>) ((ParameterizedType) initialType).getRawType();
    else
        rawType = (Class<?>) initialType;
    if (targetType.equals(rawType))
        return initialType;
    Type result;
    if (targetType.isInterface()) {
        for (Type superInterface : rawType.getGenericInterfaces()) if (superInterface != null && !superInterface.equals(Object.class))
            if ((result = resolveGenericType(superInterface, targetType)) != null)
                return result;
    }
    Type superType = rawType.getGenericSuperclass();
    if (superType != null && !superType.equals(Object.class))
        if ((result = resolveGenericType(superType, targetType)) != null)
            return result;
    return null;
}

47. GsonBuilderWrapper#getAdapterType()

Project: vraptor4
File: GsonBuilderWrapper.java
private Class<?> getAdapterType(Object adapter) {
    final Class<?> klazz = extractRawTypeIfPossible(adapter.getClass());
    final Type[] genericInterfaces = klazz.getGenericInterfaces();
    final ParameterizedType type = (ParameterizedType) genericInterfaces[0];
    final Type actualType = type.getActualTypeArguments()[0];
    if (actualType instanceof ParameterizedType) {
        return (Class<?>) ((ParameterizedType) actualType).getRawType();
    } else {
        return (Class<?>) actualType;
    }
}

48. TypeToken#isSubtypeOfParameterizedType()

Project: voltdb
File: TypeToken.java
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++) {
        // String is then matched against <? extends CharSequence>.
        if (!resolveType(typeParams[i]).is(toTypeArgs[i])) {
            return false;
        }
    }
    return true;
}

49. PairParser#doParse()

Project: commons
File: PairParser.java
@Override
Pair<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type leftType = typeParams.get(0);
    Parser<?> leftParser = parserOracle.get(TypeToken.of(leftType));
    Type rightType = typeParams.get(1);
    Parser<?> rightParser = parserOracle.get(TypeToken.of(rightType));
    List<String> parts = ImmutableList.copyOf(Parsers.MULTI_VALUE_SPLITTER.split(raw));
    checkArgument(parts.size() == 2, "Only two values may be specified for a pair, you gave " + parts.size());
    return Pair.of(leftParser.parse(parserOracle, leftType, parts.get(0)), rightParser.parse(parserOracle, rightType, parts.get(1)));
}

50. MultimapParser#doParse()

Project: commons
File: MultimapParser.java
@SuppressWarnings("unchecked")
@Override
Multimap<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type keyType = typeParams.get(0);
    Parser<?> keyParser = parserOracle.get(TypeToken.of(keyType));
    Type valueType = typeParams.get(1);
    Parser<?> valueParser = parserOracle.get(TypeToken.of(valueType));
    ImmutableMultimap.Builder<Object, Object> multimapBuilder = ImmutableMultimap.builder();
    for (String keyAndValue : Parsers.MULTI_VALUE_SPLITTER.split(raw)) {
        List<String> fields = ImmutableList.copyOf(KEY_VALUE_SPLITTER.split(keyAndValue));
        checkArgument(fields.size() == 2, "Failed to parse key/value pair: " + keyAndValue);
        multimapBuilder.put(keyParser.parse(parserOracle, keyType, fields.get(0)), valueParser.parse(parserOracle, valueType, fields.get(1)));
    }
    return multimapBuilder.build();
}

51. MapParser#doParse()

Project: commons
File: MapParser.java
@SuppressWarnings("unchecked")
@Override
Map<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type keyType = typeParams.get(0);
    Parser<?> keyParser = parserOracle.get(TypeToken.of(keyType));
    Type valueType = typeParams.get(1);
    Parser<?> valueParser = parserOracle.get(TypeToken.of(valueType));
    ImmutableMap.Builder<Object, Object> map = ImmutableMap.builder();
    for (String keyAndValue : Parsers.MULTI_VALUE_SPLITTER.split(raw)) {
        List<String> fields = ImmutableList.copyOf(KEY_VALUE_SPLITTER.split(keyAndValue));
        checkArgument(fields.size() == 2, "Failed to parse key/value pair " + keyAndValue);
        map.put(keyParser.parse(parserOracle, keyType, fields.get(0)), valueParser.parse(parserOracle, valueType, fields.get(1)));
    }
    return map.build();
}

52. AmountParser#doParse()

Project: commons
File: AmountParser.java
@Override
Amount<?, ?> doParse(ParserOracle parserOracle, String raw, List<Type> typeParams) {
    Type valueType = typeParams.get(0);
    Parser<?> parser = parserOracle.get(TypeToken.of(valueType));
    Matcher matcher = AMOUNT_PATTERN.matcher(raw);
    checkArgument(matcher.matches(), "Value '" + raw + "' must be of the format 1ns, 4mb, etc.");
    Number number = (Number) parser.parse(parserOracle, valueType, matcher.group(1));
    String unitRaw = matcher.group(2);
    Type unitType = typeParams.get(1);
    @SuppressWarnings("rawtypes") Parser<Unit> unitParser = parserOracle.get(TypeToken.of(Unit.class));
    @SuppressWarnings("rawtypes") Unit unit = unitParser.parse(parserOracle, unitType, unitRaw);
    checkArgument(unit.getClass() == unitType, String.format("Unit type (%s) does not match argument type (%s).", unit.getClass(), unitType));
    return create(valueType, number, unit);
}

53. TypeToken#isAssignableToParameterizedType()

Project: cdk
File: TypeToken.java
private static boolean isAssignableToParameterizedType(Type from, ParameterizedType to) {
    Class<?> matchedClass = getRawType(to);
    if (!matchedClass.isAssignableFrom(getRawType(from))) {
        return false;
    }
    Type[] typeParams = matchedClass.getTypeParameters();
    Type[] toTypeArgs = to.getActualTypeArguments();
    TypeToken<?> fromTypeToken = of(from);
    for (int i = 0; i < typeParams.length; i++) {
        // If "to" is "List<? extends CharSequence>"
        // and "from" 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>.
        Type fromTypeArg = fromTypeToken.resolveType(typeParams[i]).runtimeType;
        if (!matchTypeArgument(fromTypeArg, toTypeArgs[i])) {
            return false;
        }
    }
    return true;
}

54. SparkProgramRuntimeProvider#createInstance()

Project: cdap
File: SparkProgramRuntimeProvider.java
/**
   * Create a new instance of the given {@link Type} from the given {@link Injector}. This method
   * is doing Guice injection manually through the @Inject constructor to avoid ClassLoader leakage
   * due to the just-in-time binding map inside the Guice Injector that holds a strong reference to the type,
   * hence the ClassLoader of that type
   *
   * @param injector The Guice Injector for acquiring CDAP system instances
   * @param type the {@link Class} of the instance to create
   * @return a new instance of the given {@link Type}
   */
private <T> T createInstance(Injector injector, Type type, ClassLoader sparkClassLoader) throws Exception {
    Key<?> typeKey = Key.get(type);
    @SuppressWarnings("unchecked") Class<T> rawType = (Class<T>) typeKey.getTypeLiteral().getRawType();
    Constructor<T> constructor = findInjectableConstructor(rawType);
    constructor.setAccessible(true);
    // Acquire the instances for each parameter for the constructor
    Type[] paramTypes = constructor.getGenericParameterTypes();
    Object[] args = new Object[paramTypes.length];
    int i = 0;
    for (Type paramType : paramTypes) {
        Key<?> paramTypeKey = Key.get(paramType);
        // instance manually instead of getting through the Guice Injector to avoid ClassLoader leakage
        if (paramTypeKey.getTypeLiteral().getRawType().getClassLoader() == sparkClassLoader) {
            args[i++] = createInstance(injector, paramType, sparkClassLoader);
        } else {
            args[i++] = injector.getInstance(paramTypeKey);
        }
    }
    return constructor.newInstance(args);
}

55. AbstractProgramTwillRunnable#createProgramRunner()

Project: cdap
File: AbstractProgramTwillRunnable.java
/**
   * Creates a {@link ProgramRunner} for the running the program in this {@link TwillRunnable}.
   */
protected ProgramRunner createProgramRunner(Injector injector) {
    Type type = TypeToken.of(getClass()).getSupertype(AbstractProgramTwillRunnable.class).getType();
    // Must be ParameterizedType
    Preconditions.checkState(type instanceof ParameterizedType, "Invalid ProgramTwillRunnable class %s. Expected to be a ParameterizedType.", getClass());
    Type programRunnerType = ((ParameterizedType) type).getActualTypeArguments()[0];
    // the ProgramRunnerType must be a Class
    Preconditions.checkState(programRunnerType instanceof Class, "ProgramRunner type is not a class: %s", programRunnerType);
    @SuppressWarnings("unchecked") Class<ProgramRunner> programRunnerClass = (Class<ProgramRunner>) programRunnerType;
    return injector.getInstance(programRunnerClass);
}

56. TypeToken#isAssignableToParameterizedType()

Project: cdap
File: TypeToken.java
private static boolean isAssignableToParameterizedType(Type from, ParameterizedType to) {
    Class<?> matchedClass = getRawType(to);
    if (!matchedClass.isAssignableFrom(getRawType(from))) {
        return false;
    }
    Type[] typeParams = matchedClass.getTypeParameters();
    Type[] toTypeArgs = to.getActualTypeArguments();
    TypeToken<?> fromTypeToken = of(from);
    for (int i = 0; i < typeParams.length; i++) {
        // If "to" is "List<? extends CharSequence>"
        // and "from" 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>.
        Type fromTypeArg = fromTypeToken.resolveType(typeParams[i]).runtimeType;
        if (!matchTypeArgument(fromTypeArg, toTypeArgs[i])) {
            return false;
        }
    }
    return true;
}

57. ApiSurface#addExposedTypes()

Project: incubator-beam
File: ApiSurface.java
/**
   * Adds any types exposed to this set. These will come from the (possibly absent) bounds on the
   * wildcard.
   */
private void addExposedTypes(WildcardType type, Class<?> cause) {
    visit(type);
    for (Type lowerBound : type.getLowerBounds()) {
        logger.debug("Adding exposed types from {}, which is a type lower bound on wildcard type {}", lowerBound, type);
        addExposedTypes(lowerBound, cause);
    }
    for (Type upperBound : type.getUpperBounds()) {
        logger.debug("Adding exposed types from {}, which is a type upper bound on wildcard type {}", upperBound, type);
        addExposedTypes(upperBound, cause);
    }
}

58. Types#getParameterUpperBound()

Project: HttpService
File: Types.java
public static Type getParameterUpperBound(int index, ParameterizedType type) {
    Type[] types = type.getActualTypeArguments();
    if (types.length <= index) {
        throw new IllegalArgumentException("Expected at least " + index + " type argument(s) but got: " + Arrays.toString(types));
    }
    Type paramType = types[index];
    if (paramType instanceof WildcardType) {
        return ((WildcardType) paramType).getUpperBounds()[0];
    }
    return paramType;
}

59. TypeReference#getSuperclassTypeParameter()

Project: mybatis-3
File: TypeReference.java
Type getSuperclassTypeParameter(Class<?> clazz) {
    Type genericSuperclass = clazz.getGenericSuperclass();
    if (genericSuperclass instanceof Class) {
        // try to climb up the hierarchy until meet something useful
        if (TypeReference.class != genericSuperclass) {
            return getSuperclassTypeParameter(clazz.getSuperclass());
        }
        throw new TypeException("'" + getClass() + "' extends TypeReference but misses the type parameter. " + "Remove the extension or add a type parameter to it.");
    }
    Type rawType = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0];
    // TODO remove this when Reflector is fixed to return Types
    if (rawType instanceof ParameterizedType) {
        rawType = ((ParameterizedType) rawType).getRawType();
    }
    return rawType;
}

60. TypeParameterResolver#resolveParameterizedType()

Project: mybatis-3
File: TypeParameterResolver.java
private static ParameterizedType resolveParameterizedType(ParameterizedType parameterizedType, Type srcType, Class<?> declaringClass) {
    Class<?> rawType = (Class<?>) parameterizedType.getRawType();
    Type[] typeArgs = parameterizedType.getActualTypeArguments();
    Type[] args = new Type[typeArgs.length];
    for (int i = 0; i < typeArgs.length; i++) {
        if (typeArgs[i] instanceof TypeVariable) {
            args[i] = resolveTypeVar((TypeVariable<?>) typeArgs[i], srcType, declaringClass);
        } else if (typeArgs[i] instanceof ParameterizedType) {
            args[i] = resolveParameterizedType((ParameterizedType) typeArgs[i], srcType, declaringClass);
        } else if (typeArgs[i] instanceof WildcardType) {
            args[i] = resolveWildcardType((WildcardType) typeArgs[i], srcType, declaringClass);
        } else {
            args[i] = typeArgs[i];
        }
    }
    return new ParameterizedTypeImpl(rawType, null, args);
}

61. TypeParameterResolver#resolveGenericArrayType()

Project: mybatis-3
File: TypeParameterResolver.java
private static Type resolveGenericArrayType(GenericArrayType genericArrayType, Type srcType, Class<?> declaringClass) {
    Type componentType = genericArrayType.getGenericComponentType();
    Type resolvedComponentType = null;
    if (componentType instanceof TypeVariable) {
        resolvedComponentType = resolveTypeVar((TypeVariable<?>) componentType, srcType, declaringClass);
    } else if (componentType instanceof GenericArrayType) {
        resolvedComponentType = resolveGenericArrayType((GenericArrayType) componentType, srcType, declaringClass);
    } else if (componentType instanceof ParameterizedType) {
        resolvedComponentType = resolveParameterizedType((ParameterizedType) componentType, srcType, declaringClass);
    }
    if (resolvedComponentType instanceof Class) {
        return Array.newInstance((Class<?>) resolvedComponentType, 0).getClass();
    } else {
        return new GenericArrayTypeImpl(resolvedComponentType);
    }
}

62. TypeReference#getSuperclassTypeParameter()

Project: mybatis
File: TypeReference.java
Type getSuperclassTypeParameter(Class<?> clazz) {
    //????T?????
    Type genericSuperclass = clazz.getGenericSuperclass();
    //???? ????Class?
    if (genericSuperclass instanceof Class) {
        // try to climb up the hierarchy until meet something useful
        if (TypeReference.class != genericSuperclass) {
            return getSuperclassTypeParameter(clazz.getSuperclass());
        }
        throw new TypeException("'" + getClass() + "' extends TypeReference but misses the type parameter. " + "Remove the extension or add a type parameter to it.");
    }
    Type rawType = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0];
    // TODO remove this when Reflector is fixed to return Types
    if (rawType instanceof ParameterizedType) {
        rawType = ((ParameterizedType) rawType).getRawType();
    }
    return rawType;
}

63. GenericsUtils#getSuperClassGenricType()

Project: MousePaint
File: GenericsUtils.java
/**
	 * ????,????Class??????????????. ?public BookManager extends
	 * GenricManager<Book>
	 * 
	 * @param clazz
	 *            clazz The class to introspect
	 * @param index
	 *            the Index of the generic ddeclaration,start from 0.
	 */
public static Class getSuperClassGenricType(Class clazz, int index) throws IndexOutOfBoundsException {
    Type genType = clazz.getGenericSuperclass();
    if (!(genType instanceof ParameterizedType)) {
        return Object.class;
    }
    Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    if (index >= params.length || index < 0) {
        return Object.class;
    }
    if (!(params[index] instanceof Class)) {
        return Object.class;
    }
    return (Class) params[index];
}

64. TypesTest#newParameterizedTypeObjectMethods()

Project: moshi
File: TypesTest.java
@Test
public void newParameterizedTypeObjectMethods() throws Exception {
    Type mapOfStringIntegerType = TypesTest.class.getDeclaredField("mapOfStringInteger").getGenericType();
    ParameterizedType newMapType = Types.newParameterizedType(Map.class, String.class, Integer.class);
    assertThat(newMapType).isEqualTo(mapOfStringIntegerType);
    assertThat(newMapType.hashCode()).isEqualTo(mapOfStringIntegerType.hashCode());
    assertThat(newMapType.toString()).isEqualTo(mapOfStringIntegerType.toString());
    Type arrayListOfMapOfStringIntegerType = TypesTest.class.getDeclaredField("arrayListOfMapOfStringInteger").getGenericType();
    ParameterizedType newListType = Types.newParameterizedType(ArrayList.class, newMapType);
    assertThat(newListType).isEqualTo(arrayListOfMapOfStringIntegerType);
    assertThat(newListType.hashCode()).isEqualTo(arrayListOfMapOfStringIntegerType.hashCode());
    assertThat(newListType.toString()).isEqualTo(arrayListOfMapOfStringIntegerType.toString());
}

65. TypeResolver#resolveGenericType()

Project: modelmapper
File: TypeResolver.java
/**
   * Resolves the generic Type for the {@code targetType} by walking the type hierarchy upwards from
   * the {@code initialType}.
   */
public static Type resolveGenericType(Type initialType, Class<?> targetType) {
    Class<?> rawType;
    if (initialType instanceof ParameterizedType)
        rawType = (Class<?>) ((ParameterizedType) initialType).getRawType();
    else
        rawType = (Class<?>) initialType;
    if (targetType.equals(rawType))
        return initialType;
    Type result;
    if (targetType.isInterface()) {
        for (Type superInterface : rawType.getGenericInterfaces()) if (superInterface != null && !superInterface.equals(Object.class))
            if ((result = resolveGenericType(superInterface, targetType)) != null)
                return result;
    }
    Type superType = rawType.getGenericSuperclass();
    if (superType != null && !superType.equals(Object.class))
        if ((result = resolveGenericType(superType, targetType)) != null)
            return result;
    return null;
}

66. TypeUtil#isParameterizedAssignable()

Project: logging-log4j2
File: TypeUtil.java
private static boolean isParameterizedAssignable(final ParameterizedType lhs, final ParameterizedType rhs) {
    if (lhs.equals(rhs)) {
        // that was easy
        return true;
    }
    final Type[] lhsTypeArguments = lhs.getActualTypeArguments();
    final Type[] rhsTypeArguments = rhs.getActualTypeArguments();
    final int size = lhsTypeArguments.length;
    if (rhsTypeArguments.length != size) {
        // clearly incompatible types
        return false;
    }
    for (int i = 0; i < size; i++) {
        // verify all type arguments are assignable
        final Type lhsArgument = lhsTypeArguments[i];
        final Type rhsArgument = rhsTypeArguments[i];
        if (!lhsArgument.equals(rhsArgument) && !(lhsArgument instanceof WildcardType && isWildcardAssignable((WildcardType) lhsArgument, rhsArgument))) {
            return false;
        }
    }
    return true;
}

67. GenericsUtils#getMethodGenericParameterTypes()

Project: light-task-scheduler
File: GenericsUtils.java
/**  
     * ????,?????????index?????????????????. ?: public void add(Map<String, Buyer> maps, List<String> names){}
     *  
     * @param method ??
     * @param index ???????
     * @return ????????????????, ??????ParameterizedType???????????????????
     */
public static List<Class> getMethodGenericParameterTypes(Method method, int index) {
    List<Class> results = new ArrayList<Class>();
    Type[] genericParameterTypes = method.getGenericParameterTypes();
    if (index >= genericParameterTypes.length || index < 0) {
        throw new IllegalArgumentException("index " + (index < 0 ? " must > 0 " : " over total arguments"));
    }
    Type genericParameterType = genericParameterTypes[index];
    if (genericParameterType instanceof ParameterizedType) {
        ParameterizedType aType = (ParameterizedType) genericParameterType;
        Type[] parameterArgTypes = aType.getActualTypeArguments();
        for (Type parameterArgType : parameterArgTypes) {
            Class parameterArgClass = (Class) parameterArgType;
            results.add(parameterArgClass);
        }
        return results;
    }
    return results;
}

68. GenericsUtils#getSuperClassGenericType()

Project: light-task-scheduler
File: GenericsUtils.java
/**  
     * ????,??????????????????. ?BuyerServiceBean extends DaoSupport<Buyer>  
     *  
     * @param clazz clazz ??????,??????????
     * @param index ????????,?0??.  
     * @return ?????????, ??????ParameterizedType????????????????<code>Object.class</code>
     */
public static Class getSuperClassGenericType(Class clazz, int index) {
    //??????  
    Type genType = clazz.getGenericSuperclass();
    if (!(genType instanceof ParameterizedType)) {
        return Object.class;
    }
    //??????????????Type?????,????????????Class, ?BuyerServiceBean extends DaoSupport<Buyer,Contact>???Buyer?Contact??   
    Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    if (index >= params.length || index < 0) {
        throw new IllegalArgumentException("index " + (index < 0 ? " must > 0 " : " over total arguments"));
    }
    if (!(params[index] instanceof Class)) {
        return Object.class;
    }
    return (Class) params[index];
}

69. OnColumnsRowRenderer#findRenderererInterfaceType()

Project: libreplan
File: OnColumnsRowRenderer.java
private static ParameterizedType findRenderererInterfaceType(ICellForDetailItemRenderer<?, ?> renderer) {
    Type[] genericInterfaces = renderer.getClass().getGenericInterfaces();
    for (Type type : genericInterfaces) {
        if (isTypeForInterface(type, ICellForDetailItemRenderer.class)) {
            if (type instanceof ParameterizedType) {
                return (ParameterizedType) type;
            } else {
                informCannotBeInferred(renderer);
            }
        }
    }
    throw new RuntimeException("shouldn't reach here. Uncovered case for " + renderer);
}

70. OnColumnsRowRenderer#inferGenericType()

Project: libreplan
File: OnColumnsRowRenderer.java
private static <T> Class<T> inferGenericType(ICellForDetailItemRenderer<?, T> renderer) {
    ParameterizedType parametrizedType = findRenderererInterfaceType(renderer);
    Type[] actualTypeArguments = parametrizedType.getActualTypeArguments();
    final int genericTypePosition = 1;
    Type type = actualTypeArguments[genericTypePosition];
    if (!isActualType(type)) {
        informCannotBeInferred(renderer);
    }
    return (Class<T>) actualTypeArguments[genericTypePosition];
}

71. ArrayIT#arraysCanBeMultiDimensional()

Project: jsonschema2pojo
File: ArrayIT.java
@Test
public void arraysCanBeMultiDimensional() throws NoSuchMethodException {
    Method getterMethod = classWithArrayProperties.getMethod("getMultiDimensionalArray");
    // assert List
    assertThat(getterMethod.getReturnType().getName(), is(List.class.getName()));
    assertThat(getterMethod.getGenericReturnType(), is(instanceOf(ParameterizedType.class)));
    // assert List<List>
    Type genericType = ((ParameterizedType) getterMethod.getGenericReturnType()).getActualTypeArguments()[0];
    assertThat(genericType, is(instanceOf(ParameterizedType.class)));
    assertThat(((Class<?>) ((ParameterizedType) genericType).getRawType()).getName(), is(List.class.getName()));
    // assert List<List<Object>>
    Type itemsType = ((ParameterizedType) genericType).getActualTypeArguments()[0];
    assertThat(itemsType, is(instanceOf(Class.class)));
    assertThat(((Class<?>) itemsType).getName(), is(Object.class.getName()));
}

72. JohnzonParameterizedType#findUserParameterizedType()

Project: johnzon
File: JohnzonParameterizedType.java
private ParameterizedType findUserParameterizedType() {
    final Type genericSuperclass = getClass().getGenericSuperclass();
    if (!ParameterizedType.class.isInstance(genericSuperclass)) {
        throw new IllegalArgumentException("raw can be null only for children classes");
    }
    // our type, then unwrap it
    final ParameterizedType pt = ParameterizedType.class.cast(genericSuperclass);
    final Type userType = pt.getActualTypeArguments()[0];
    if (!ParameterizedType.class.isInstance(userType)) {
        throw new IllegalArgumentException("You need to pass a parameterized type to Johnzon*Types");
    }
    return ParameterizedType.class.cast(userType);
}

73. ParameterConvertersBehaviour#shouldConvertCommaSeparatedValuesToListOfNumbersWithDefaultFormat()

Project: jbehave-core
File: ParameterConvertersBehaviour.java
@SuppressWarnings("unchecked")
@Test
public void shouldConvertCommaSeparatedValuesToListOfNumbersWithDefaultFormat() throws ParseException, IntrospectionException {
    ParameterConverter converter = new NumberListConverter();
    Type listOfNumbers = SomeSteps.methodFor("aMethodWithListOfNumbers").getGenericParameterTypes()[0];
    Type setOfNumbers = SomeSteps.methodFor("aMethodWithSetOfNumbers").getGenericParameterTypes()[0];
    assertThat(converter.accept(listOfNumbers), is(true));
    assertThat(converter.accept(setOfNumbers), is(false));
    List<Number> list = (List<Number>) converter.convertValue("3, 0.5, 6.1f, 8.00", listOfNumbers);
    NumberFormat numberFormat = NumberFormat.getInstance(ParameterConverters.DEFAULT_NUMBER_FORMAT_LOCAL);
    assertThat(list.get(0), equalTo(numberFormat.parse("3")));
    assertThat(list.get(1), equalTo(numberFormat.parse("0.5")));
    assertThat(list.get(2), equalTo(numberFormat.parse("6.1f")));
    assertThat(list.get(3), equalTo(numberFormat.parse("8.00")));
}

74. TypeResolver#resolveGenericType()

Project: typetools
File: TypeResolver.java
/**
   * Returns the generic {@code type} using type variable information from the {@code subType} else {@code null} if the
   * generic type cannot be resolved.
   * 
   * @param type to resolve generic type for
   * @param subType to extract type variable information from
   * @return generic {@code type} else {@code null} if it cannot be resolved
   */
public static Type resolveGenericType(Class<?> type, Type subType) {
    Class<?> rawType;
    if (subType instanceof ParameterizedType)
        rawType = (Class<?>) ((ParameterizedType) subType).getRawType();
    else
        rawType = (Class<?>) subType;
    if (type.equals(rawType))
        return subType;
    Type result;
    if (type.isInterface()) {
        for (Type superInterface : rawType.getGenericInterfaces()) if (superInterface != null && !superInterface.equals(Object.class))
            if ((result = resolveGenericType(type, superInterface)) != null)
                return result;
    }
    Type superClass = rawType.getGenericSuperclass();
    if (superClass != null && !superClass.equals(Object.class))
        if ((result = resolveGenericType(type, superClass)) != null)
            return result;
    return null;
}

75. AbstractServiceCreator#findParameterizedTypeFromGenericType()

Project: tapestry5
File: AbstractServiceCreator.java
/**
     * "Sniffs" a generic type to find the underlying parameterized type. If the Type is a class, then Object.class is
     * returned. Otherwise, the type must be a ParameterizedType. We check to make sure it has the correct number of a
     * actual types (1 for a Collection or List, 2 for a Map). The actual types must be classes (wildcards just aren't
     * supported)
     *
     * @param type      a Class or ParameterizedType to inspect
     * @param typeIndex the index within the ParameterizedType to extract
     * @return the actual type, or Object.class if the input type is not generic, or null if any other pre-condition is
     *         not met
     */
private static Class findParameterizedTypeFromGenericType(Type type, int typeIndex) {
    if (type instanceof Class)
        return Object.class;
    if (!(type instanceof ParameterizedType))
        return null;
    ParameterizedType pt = (ParameterizedType) type;
    Type[] types = pt.getActualTypeArguments();
    Type actualType = types[typeIndex];
    return actualType instanceof Class ? (Class) actualType : null;
}

76. AbstractServiceCreator#findParameterizedTypeFromGenericType()

Project: tapestry-5
File: AbstractServiceCreator.java
/**
     * "Sniffs" a generic type to find the underlying parameterized type. If the Type is a class, then Object.class is
     * returned. Otherwise, the type must be a ParameterizedType. We check to make sure it has the correct number of a
     * actual types (1 for a Collection or List, 2 for a Map). The actual types must be classes (wildcards just aren't
     * supported)
     *
     * @param type      a Class or ParameterizedType to inspect
     * @param typeIndex the index within the ParameterizedType to extract
     * @return the actual type, or Object.class if the input type is not generic, or null if any other pre-condition is
     *         not met
     */
private static Class findParameterizedTypeFromGenericType(Type type, int typeIndex) {
    if (type instanceof Class)
        return Object.class;
    if (!(type instanceof ParameterizedType))
        return null;
    ParameterizedType pt = (ParameterizedType) type;
    Type[] types = pt.getActualTypeArguments();
    Type actualType = types[typeIndex];
    return actualType instanceof Class ? (Class) actualType : null;
}

77. OptionalTypeAdapterFactory#create()

Project: tahrir
File: OptionalTypeAdapterFactory.java
@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Type type = typeToken.getType();
    if (typeToken.getRawType() != Optional.class || !(type instanceof ParameterizedType)) {
        return null;
    }
    Type elementType = ((ParameterizedType) type).getActualTypeArguments()[0];
    TypeAdapter<?> elementAdapter = gson.getAdapter(TypeToken.get(elementType));
    return (TypeAdapter<T>) newOptionalAdapter(elementAdapter);
}

78. Reflections#getClassGenricType()

Project: springside4
File: Reflections.java
/**
	 * ????, ??Class????????????????. ?????, ??Object.class.
	 * 
	 * ?public UserDao extends HibernateDao<User,Long>
	 * 
	 * @param clazz clazz The class to introspect
	 * @param index the Index of the generic ddeclaration,start from 0.
	 * @return the index generic declaration, or Object.class if cannot be determined
	 */
public static Class getClassGenricType(final Class clazz, final int index) {
    Type genType = clazz.getGenericSuperclass();
    if (!(genType instanceof ParameterizedType)) {
        logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
        return Object.class;
    }
    Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    if ((index >= params.length) || (index < 0)) {
        logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " + params.length);
        return Object.class;
    }
    if (!(params[index] instanceof Class)) {
        logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
        return Object.class;
    }
    return (Class) params[index];
}

79. TypeUtilsTests#testWithGenericArrayTypes()

Project: spring-android
File: TypeUtilsTests.java
public void testWithGenericArrayTypes() throws Exception {
    Type arrayType = getClass().getField("array").getGenericType();
    Type openArrayType = getClass().getField("openArray").getGenericType();
    assertTrue(TypeUtils.isAssignable(Object.class, arrayType));
    assertTrue(TypeUtils.isAssignable(Object.class, openArrayType));
    assertTrue(TypeUtils.isAssignable(List[].class, arrayType));
    assertTrue(TypeUtils.isAssignable(List[].class, openArrayType));
    assertTrue(TypeUtils.isAssignable(arrayType, List[].class));
    assertTrue(TypeUtils.isAssignable(openArrayType, List[].class));
    assertTrue(TypeUtils.isAssignable(arrayType, arrayType));
    assertTrue(TypeUtils.isAssignable(openArrayType, openArrayType));
    assertTrue(TypeUtils.isAssignable(openArrayType, arrayType));
}

80. TypeUtils#isAssignable()

Project: spring-android
File: TypeUtils.java
private static boolean isAssignable(ParameterizedType lhsType, ParameterizedType rhsType) {
    if (lhsType.equals(rhsType)) {
        return true;
    }
    Type[] lhsTypeArguments = lhsType.getActualTypeArguments();
    Type[] rhsTypeArguments = rhsType.getActualTypeArguments();
    if (lhsTypeArguments.length != rhsTypeArguments.length) {
        return false;
    }
    for (int size = lhsTypeArguments.length, i = 0; i < size; ++i) {
        Type lhsArg = lhsTypeArguments[i];
        Type rhsArg = rhsTypeArguments[i];
        if (!lhsArg.equals(rhsArg) && !(lhsArg instanceof WildcardType && isAssignable((WildcardType) lhsArg, rhsArg))) {
            return false;
        }
    }
    return true;
}

81. GenericTypeReflector#getArrayExactDirectSuperTypes()

Project: spock
File: GenericTypeReflector.java
private static Type[] getArrayExactDirectSuperTypes(Type arrayType) {
    // see http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.10.3
    Type typeComponent = getArrayComponentType(arrayType);
    Type[] result;
    int resultIndex;
    if (typeComponent instanceof Class && ((Class<?>) typeComponent).isPrimitive()) {
        resultIndex = 0;
        result = new Type[3];
    } else {
        Type[] componentSupertypes = getExactDirectSuperTypes(typeComponent);
        result = new Type[componentSupertypes.length + 3];
        for (resultIndex = 0; resultIndex < componentSupertypes.length; resultIndex++) {
            result[resultIndex] = GenericArrayTypeImpl.createArrayType(componentSupertypes[resultIndex]);
        }
    }
    result[resultIndex++] = Object.class;
    result[resultIndex++] = Cloneable.class;
    result[resultIndex++] = Serializable.class;
    return result;
}

82. MapTypeAdapterFactory#create()

Project: socialize-sdk-android
File: MapTypeAdapterFactory.java
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Type type = typeToken.getType();
    Class<? super T> rawType = typeToken.getRawType();
    if (!Map.class.isAssignableFrom(rawType)) {
        return null;
    }
    Class<?> rawTypeOfSrc = $Gson$Types.getRawType(type);
    Type[] keyAndValueTypes = $Gson$Types.getMapKeyAndValueTypes(type, rawTypeOfSrc);
    TypeAdapter<?> keyAdapter = getKeyAdapter(gson, keyAndValueTypes[0]);
    TypeAdapter<?> valueAdapter = gson.getAdapter(TypeToken.get(keyAndValueTypes[1]));
    ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);
    @SuppressWarnings({ "unchecked", "rawtypes" }) // we don't define a type parameter for the key or value types
    TypeAdapter<T> result = new Adapter(gson, keyAndValueTypes[0], keyAdapter, keyAndValueTypes[1], valueAdapter, constructor);
    return result;
}

83. CollectionTypeAdapterFactory#create()

Project: socialize-sdk-android
File: CollectionTypeAdapterFactory.java
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
    Type type = typeToken.getType();
    Class<? super T> rawType = typeToken.getRawType();
    if (!Collection.class.isAssignableFrom(rawType)) {
        return null;
    }
    Type elementType = $Gson$Types.getCollectionElementType(type, rawType);
    TypeAdapter<?> elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType));
    ObjectConstructor<T> constructor = constructorConstructor.get(typeToken);
    // create() doesn't define a type parameter
    @SuppressWarnings({ "unchecked", "rawtypes" }) TypeAdapter<T> result = new Adapter(gson, elementType, elementTypeAdapter, constructor);
    return result;
}

84. Generics#isArraySupertype()

Project: sitebricks
File: Generics.java
private static boolean isArraySupertype(Type arraySuperType, Type subType) {
    Type superTypeComponent = getArrayComponentType(arraySuperType);
    assert superTypeComponent != null;
    Type subTypeComponent = getArrayComponentType(subType);
    if (subTypeComponent == null) // subType is not an array type
    {
        return false;
    } else {
        return isSuperType(superTypeComponent, subTypeComponent);
    }
}

85. MvelEvaluatorCompiler#resolveEgressType()

Project: sitebricks
File: MvelEvaluatorCompiler.java
public Type resolveEgressType(String expression) throws ExpressionCompileException {
    // try to get the type from the cache
    Type type = egressTypes.get(expression);
    if (type != null) {
        return type;
    }
    CompiledExpression compiled = compileExpression(expression);
    final Class<?> egressClass = compiled.getKnownEgressType();
    final Type[] parameters = getParserContext().getLastTypeParameters();
    if (parameters == null) {
        // the class is not parameterised (generic)
        type = egressClass;
    } else {
        // reconstruct the Type from mvel's generics details
        type = new ParameterizedTypeImpl(egressClass, parameters, egressClass.getEnclosingClass());
    }
    egressTypes.put(expression, type);
    return type;
}

86. RxJavaCallAdapterFactoryTest#rawResultTypeThrows()

Project: retrofit
File: RxJavaCallAdapterFactoryTest.java
@Test
public void rawResultTypeThrows() {
    Type observableType = new TypeToken<Observable<Result>>() {
    }.getType();
    try {
        factory.get(observableType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>");
    }
    Type singleType = new TypeToken<Single<Result>>() {
    }.getType();
    try {
        factory.get(singleType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Result must be parameterized as Result<Foo> or Result<? extends Foo>");
    }
}

87. RxJavaCallAdapterFactoryTest#rawResponseTypeThrows()

Project: retrofit
File: RxJavaCallAdapterFactoryTest.java
@Test
public void rawResponseTypeThrows() {
    Type observableType = new TypeToken<Observable<Response>>() {
    }.getType();
    try {
        factory.get(observableType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
    }
    Type singleType = new TypeToken<Single<Response>>() {
    }.getType();
    try {
        factory.get(singleType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Response must be parameterized as Response<Foo> or Response<? extends Foo>");
    }
}

88. RxJavaCallAdapterFactoryTest#rawBodyTypeThrows()

Project: retrofit
File: RxJavaCallAdapterFactoryTest.java
@Test
public void rawBodyTypeThrows() {
    Type observableType = new TypeToken<Observable>() {
    }.getType();
    try {
        factory.get(observableType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Observable return type must be parameterized as Observable<Foo> or Observable<? extends Foo>");
    }
    Type singleType = new TypeToken<Single>() {
    }.getType();
    try {
        factory.get(singleType, NO_ANNOTATIONS, retrofit);
        fail();
    } catch (IllegalStateException e) {
        assertThat(e).hasMessage("Single return type must be parameterized as Single<Foo> or Single<? extends Foo>");
    }
}

89. Java8CallAdapterFactory#get()

Project: retrofit
File: Java8CallAdapterFactory.java
@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != CompletableFuture.class) {
        return null;
    }
    if (!(returnType instanceof ParameterizedType)) {
        throw new IllegalStateException("CompletableFuture return type must be parameterized" + " as CompletableFuture<Foo> or CompletableFuture<? extends Foo>");
    }
    Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType);
    if (getRawType(innerType) != Response.class) {
        // Generic type is not Response<T>. Use it for body-only adapter.
        return new BodyCallAdapter(innerType);
    }
    // Generic type is Response<T>. Extract T and create the Response version of the adapter.
    if (!(innerType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized" + " as Response<Foo> or Response<? extends Foo>");
    }
    Type responseType = getParameterUpperBound(0, (ParameterizedType) innerType);
    return new ResponseCallAdapter(responseType);
}

90. GuavaCallAdapterFactory#get()

Project: retrofit
File: GuavaCallAdapterFactory.java
@Override
public CallAdapter<?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    if (getRawType(returnType) != ListenableFuture.class) {
        return null;
    }
    if (!(returnType instanceof ParameterizedType)) {
        throw new IllegalStateException("ListenableFuture return type must be parameterized" + " as ListenableFuture<Foo> or ListenableFuture<? extends Foo>");
    }
    Type innerType = getParameterUpperBound(0, (ParameterizedType) returnType);
    if (getRawType(innerType) != Response.class) {
        // Generic type is not Response<T>. Use it for body-only adapter.
        return new BodyCallAdapter(innerType);
    }
    // Generic type is Response<T>. Extract T and create the Response version of the adapter.
    if (!(innerType instanceof ParameterizedType)) {
        throw new IllegalStateException("Response must be parameterized" + " as Response<Foo> or Response<? extends Foo>");
    }
    Type responseType = getParameterUpperBound(0, (ParameterizedType) innerType);
    return new ResponseCallAdapter(responseType);
}

91. Utils#getParameterUpperBound()

Project: retrofit
File: Utils.java
static Type getParameterUpperBound(int index, ParameterizedType type) {
    Type[] types = type.getActualTypeArguments();
    if (index < 0 || index >= types.length) {
        throw new IllegalArgumentException("Index " + index + " not in range [0," + types.length + ") for " + type);
    }
    Type paramType = types[index];
    if (paramType instanceof WildcardType) {
        return ((WildcardType) paramType).getUpperBounds()[0];
    }
    return paramType;
}

92. ResteasyProviderFactory#addStringParameterUnmarshaller()

Project: Resteasy
File: ResteasyProviderFactory.java
public void addStringParameterUnmarshaller(Class<? extends StringParameterUnmarshaller> provider) {
    if (stringParameterUnmarshallers == null) {
        stringParameterUnmarshallers = new ConcurrentHashMap<Class<?>, Class<? extends StringParameterUnmarshaller>>();
        stringParameterUnmarshallers.putAll(parent.getStringParameterUnmarshallers());
    }
    Type[] intfs = provider.getGenericInterfaces();
    for (Type type : intfs) {
        if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            if (pt.getRawType().equals(StringParameterUnmarshaller.class)) {
                Class<?> aClass = Types.getRawType(pt.getActualTypeArguments()[0]);
                stringParameterUnmarshallers.put(aClass, provider);
            }
        }
    }
}

93. JavaConfigurationBuilderImpl#bindSetEntry()

Project: reef
File: JavaConfigurationBuilderImpl.java
@SuppressWarnings("unchecked")
@Override
public <T> JavaConfigurationBuilder bindSetEntry(final Class<? extends Name<Set<T>>> iface, final Class<? extends T> impl) throws BindException {
    final Node n = getNode(iface);
    final Node m = getNode(impl);
    if (!(n instanceof NamedParameterNode)) {
        throw new BindException("BindSetEntry got an interface that resolved to " + n + "; expected a NamedParameter");
    }
    final Type setType = ReflectionUtilities.getInterfaceTarget(Name.class, iface);
    if (!ReflectionUtilities.getRawClass(setType).equals(Set.class)) {
        throw new BindException("BindSetEntry got a NamedParameter that takes a " + setType + "; expected Set<...>");
    }
    final Type valType = ReflectionUtilities.getInterfaceTarget(Set.class, setType);
    if (!ReflectionUtilities.getRawClass(valType).isAssignableFrom(impl)) {
        throw new BindException("BindSetEntry got implementation " + impl + " that is incompatible with expected type " + valType);
    }
    super.bindSetEntry((NamedParameterNode<Set<T>>) n, m);
    return this;
}

94. GenericsUtil#fillTypeHierarchy()

Project: openwebbeans
File: GenericsUtil.java
private static void fillTypeHierarchy(Set<Type> set, Type type, Type actualType) {
    if (type == null) {
        return;
    }
    Type resolvedType = GenericsUtil.resolveType(type, actualType, newSeenList());
    set.add(resolvedType);
    Class<?> resolvedClass = GenericsUtil.getRawType(resolvedType, actualType);
    if (resolvedClass.getSuperclass() != null) {
        fillTypeHierarchy(set, resolvedClass.getGenericSuperclass(), resolvedType);
    }
    for (Type interfaceType : resolvedClass.getGenericInterfaces()) {
        fillTypeHierarchy(set, interfaceType, resolvedType);
    }
}

95. GenericsUtil#isAssignableFrom()

Project: openwebbeans
File: GenericsUtil.java
/**
     * CDI 1.1 Spec. 5.2.4, third bullet point
     */
private static boolean isAssignableFrom(boolean isDelegateOrEvent, WildcardType injectionPointType, TypeVariable<?> beanType) {
    for (Type upperBound : injectionPointType.getUpperBounds()) {
        for (Type bound : beanType.getBounds()) {
            if (!isAssignableFrom(isDelegateOrEvent, false, upperBound, bound) && !isAssignableFrom(isDelegateOrEvent, false, bound, upperBound)) {
                return false;
            }
        }
    }
    for (Type lowerBound : injectionPointType.getLowerBounds()) {
        for (Type bound : beanType.getBounds()) {
            if (!isAssignableFrom(isDelegateOrEvent, false, bound, lowerBound)) {
                return false;
            }
        }
    }
    return true;
}

96. GenericsUtil#isAssignableFrom()

Project: openwebbeans
File: GenericsUtil.java
private static boolean isAssignableFrom(boolean isDelegateOrEvent, boolean isProducer, ParameterizedType injectionPointType, TypeVariable<?> beanType) {
    final Type[] types = beanType.getBounds();
    if (isNotBound(types)) {
        return true;
    }
    for (final Type bounds : types) {
        if (isAssignableFrom(isDelegateOrEvent, isProducer, injectionPointType, bounds)) {
            return true;
        }
    }
    return false;
}

97. GenericsUtil#isAssignableFrom()

Project: openwebbeans
File: GenericsUtil.java
private static boolean isAssignableFrom(boolean isDelegateOrEvent, Type injectionPointType, WildcardType beanType) {
    for (Type bounds : beanType.getLowerBounds()) {
        if (!isAssignableFrom(isDelegateOrEvent, false, bounds, injectionPointType)) {
            return false;
        }
    }
    for (Type bounds : beanType.getUpperBounds()) {
        if (isAssignableFrom(isDelegateOrEvent, false, injectionPointType, bounds)) {
            return true;
        }
    }
    return false;
}

98. ClassUtil#checkParametrizedType()

Project: openwebbeans
File: ClassUtil.java
/**
     * Return true if it does not contain type variable for wildcard type
     * false otherwise.
     * 
     * @param pType parameterized type
     * @return true if it does not contain type variable for wildcard type
     */
public static boolean checkParametrizedType(ParameterizedType pType) {
    Asserts.assertNotNull(pType, "pType");
    Type[] types = pType.getActualTypeArguments();
    for (Type type : types) {
        if (type instanceof ParameterizedType) {
            return checkParametrizedType((ParameterizedType) type);
        } else if ((type instanceof TypeVariable) || (type instanceof WildcardType)) {
            return false;
        }
    }
    return true;
}

99. TypeInfo#getItemType()

Project: openjdk
File: TypeInfo.java
public TypeInfo getItemType() {
    if (type instanceof Class && ((Class) type).isArray() && !byte[].class.equals(type)) {
        Type componentType = ((Class) type).getComponentType();
        Type genericComponentType = null;
        if (genericType != null && genericType instanceof GenericArrayType) {
            GenericArrayType arrayType = (GenericArrayType) type;
            genericComponentType = arrayType.getGenericComponentType();
            componentType = arrayType.getGenericComponentType();
        }
        TypeInfo ti = new TypeInfo(tagName, componentType, annotations);
        if (genericComponentType != null)
            ti.setGenericType(genericComponentType);
        for (Annotation anno : annotations) if (anno instanceof XmlElementWrapper)
            ti.wrapperType = this;
        return ti;
    }
    //        if (type instanceof Class && java.util.Collection.class.isAssignableFrom((Class)type)) {
    Type t = (genericType != null) ? genericType : type;
    Type base = Utils.REFLECTION_NAVIGATOR.getBaseClass(t, Collection.class);
    if (base != null) {
        return new TypeInfo(tagName, Utils.REFLECTION_NAVIGATOR.getTypeArgument(base, 0), annotations);
    }
    return null;
}

100. ClassUtils#getSuperClassGenricType()

Project: Oceanus
File: ClassUtils.java
/**
	 * ????,????Class??????????????. ?????, ??Object.class.
	 * 
	 * ?public UserDao extends HibernateDao<UserEntity,Long>
	 * 
	 * @param clazz
	 *            clazz The class to introspect
	 * @param index
	 *            the Index of the generic ddeclaration,start from 0.
	 * @return the index generic declaration, or Object.class if cannot be
	 *         determined
	 */
@SuppressWarnings({ "rawtypes" })
public static Class getSuperClassGenricType(final Class clazz, final int index) {
    Type genType = clazz.getGenericSuperclass();
    if (!(genType instanceof ParameterizedType)) {
        logger.warn(clazz.getSimpleName() + "'s superclass not ParameterizedType");
        return Object.class;
    }
    Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
    if (index >= params.length || index < 0) {
        logger.warn("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: " + params.length);
        return Object.class;
    }
    if (!(params[index] instanceof Class)) {
        logger.warn(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
        return Object.class;
    }
    return (Class) params[index];
}