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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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]; }