@Override public boolean shouldSkipField(FieldAttributes f) { Type fieldType = f.getDeclaredType(); Class<?> fieldClass = ReflectionUtil.getClassOfType(fieldType); if (Map.class.isAssignableFrom(fieldClass)) { Type mapKeyType = ReflectionUtil.getTypeParameter(fieldType, 0); return String.class != mapKeyType; } return false; }
private static <T> void addClassToInheritanceTree(Class<? extends T> element, Class<T> baseClass, Set<Class<? extends T>> result) { for (Class<?> interfaceType : element.getInterfaces()) { if (baseClass.isAssignableFrom(interfaceType)) { addInterfaceToInheritanceTree((Class<? extends T>) interfaceType, baseClass, result); } } if (element.getSuperclass() != null && baseClass.isAssignableFrom(element.getSuperclass())) { addClassToInheritanceTree((Class<? extends T>) element.getSuperclass(), baseClass, result); } result.add(element); }
ReflectionFieldAccessor(Field field, Class<U> fieldType) { this.field = field; getter = ReflectionUtil.findGetter(field.getName(), field.getDeclaringClass(), fieldType); setter = ReflectionUtil.findSetter(field.getName(), field.getDeclaringClass(), fieldType); if (getter == null || setter == null) { field.setAccessible(true); } }
public static <T> Class<?> getTypeParameterForSuper(Type target, Class<T> superClass, int index) { Class targetClass = getClassOfType(target); Preconditions.checkArgument(superClass.isAssignableFrom(targetClass), "Target must be a child of superClass"); if (superClass.isInterface()) { return getTypeParameterForSuperInterface(target, superClass, index); } else { return getTypeParameterForSuperClass(target, superClass, index); } }
private boolean isCollectionOf(Class<?> targetType, Type genericType) { return (Collection.class.isAssignableFrom(getType()) && ReflectionUtil.getTypeParameter(genericType, 0).equals(targetType)) || (Map.class.isAssignableFrom(getType()) && ReflectionUtil.getTypeParameter(genericType, 1).equals(targetType)); } }
@Test public void testGetParameterForBuriedGenericInterface() throws Exception { assertEquals(Integer.class, ReflectionUtil.getTypeParameterForSuper(Subclass.class, CopyStrategy.class, 0)); }
private static <T> Class<?> getTypeParameterForSuperInterface(Type target, Class<T> superClass, int index) { Class targetClass = getClassOfType(target); for (Type superType : targetClass.getGenericInterfaces()) { if (superType instanceof ParameterizedType) { if (((ParameterizedType) superType).getRawType().equals(superClass)) { Type boundType = ((ParameterizedType) superType).getActualTypeArguments()[index]; if (boundType instanceof Class) { return (Class<?>) boundType; } else { return null; } } } } return getTypeParameterForSuperInterface(targetClass.getGenericSuperclass(), superClass, index); }
private static <T> Class<?> getTypeParameterForSuperClass(Type target, Class<T> superClass, int index) { Class targetClass = getClassOfType(target); if (superClass.equals(getClassOfType(targetClass.getGenericSuperclass()))) { Type superType = targetClass.getGenericSuperclass(); if (superType instanceof ParameterizedType) { if (((ParameterizedType) superType).getRawType().equals(superClass)) { Type boundType = ((ParameterizedType) superType).getActualTypeArguments()[index]; if (boundType instanceof Class) { return (Class<?>) boundType; } else { return null; } } } } return getTypeParameterForSuperClass(targetClass.getGenericSuperclass(), superClass, index); }
private List<Class<? extends UIWidget>> getInheritanceTree(Class<? extends UIWidget> element) { List<Class<? extends UIWidget>> classes = cachedInheritanceTree.get(element); if (classes == null) { classes = ReflectionUtil.getInheritanceTree(element, UIWidget.class); cachedInheritanceTree.put(element, classes); } return classes; } }
public static Method findSetter(String propertyName, Class<?> beanClass, Class<?> propertyType) { String setterName = "set" + propertyName.substring(0, 1).toUpperCase(Locale.ENGLISH) + propertyName.substring(1); Method result = findMethod(beanClass, setterName, propertyType); if (result != null) { result.setAccessible(true); } return result; }
public static Method findGetter(String propertyName, Class<?> beanClass, Class<?> propertyType) { Method result = findGetter(propertyName, beanClass); if (result != null && propertyType.equals(result.getReturnType())) { return result; } return null; }
private static <T> void addInterfaceToInheritanceTree(Class<? extends T> interfaceType, Class<T> baseClass, Set<Class<? extends T>> result) { for (Class<?> parentInterface : interfaceType.getInterfaces()) { if (UIWidget.class.isAssignableFrom(parentInterface)) { addInterfaceToInheritanceTree((Class<? extends T>) parentInterface, baseClass, result); } } result.add(interfaceType); }
public static Method findSetter(Field field) { return findSetter(field.getName(), field.getDeclaringClass(), field.getType()); }
private List<ComponentFieldUri> determineAnimationPoolUris() { final List<ComponentFieldUri> animationSetUris = Lists.newArrayList(); for (ComponentMetadata<?> componentMetadata : componentLibrary.iterateComponentMetadata()) { SimpleUri uri = componentMetadata.getUri(); for (FieldMetadata<?, ?> fieldMetadata : componentMetadata.getFields()) { if (fieldMetadata.getType().isAssignableFrom(List.class)) { Type fieldType = fieldMetadata.getField().getGenericType(); if (fieldType instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) fieldType; Type[] typeArguments = parameterizedType.getActualTypeArguments(); if (typeArguments.length == 1) { Class<?> typeClass = ReflectionUtil.getClassOfType(typeArguments[0]); if (typeClass.isAssignableFrom(MeshAnimation.class)) { animationSetUris.add(new ComponentFieldUri(uri, fieldMetadata.getName())); } } } } } } return animationSetUris; }
@Test public void testGetParameterForField() throws Exception { assertEquals(EntityRef.class, ReflectionUtil.getTypeParameter(LocationComponent.class.getDeclaredField("children").getGenericType(), 0)); }
@Test public void testGetParameterForUnboundGenericInterface() throws Exception { assertEquals(null, ReflectionUtil.getTypeParameterForSuper(UnboundInterfaceImplementor.class, CopyStrategy.class, 0)); }
private UIStyleFamily buildFamily(String family, UIStyle defaultStyle) { UIStyle baseStyle = new UIStyle(defaultStyle); if (!family.isEmpty()) { UIStyleFragment fragment = baseStyles.get(family); fragment.applyTo(baseStyle); } Map<Class<? extends UIWidget>, Table<String, String, UIStyle>> familyStyles = Maps.newHashMap(); Map<StyleKey, UIStyleFragment> styleLookup = elementStyles.row(family); Map<StyleKey, UIStyleFragment> baseStyleLookup = (family.isEmpty()) ? Maps.<StyleKey, UIStyleFragment>newHashMap() : elementStyles.row(""); for (StyleKey styleKey : Sets.union(styleLookup.keySet(), baseStyleKeys)) { UIStyle elementStyle = new UIStyle(baseStyle); List<Class<? extends UIWidget>> inheritanceTree = ReflectionUtil.getInheritanceTree(styleKey.element, UIWidget.class); applyStylesForInheritanceTree(inheritanceTree, "", "", elementStyle, styleLookup, baseStyleLookup); if (!styleKey.part.isEmpty()) { applyStylesForInheritanceTree(inheritanceTree, styleKey.part, "", elementStyle, styleLookup, baseStyleLookup); } if (!styleKey.mode.isEmpty()) { applyStylesForInheritanceTree(inheritanceTree, styleKey.part, styleKey.mode, elementStyle, styleLookup, baseStyleLookup); } Table<String, String, UIStyle> elementTable = familyStyles.get(styleKey.element); if (elementTable == null) { elementTable = HashBasedTable.create(); familyStyles.put(styleKey.element, elementTable); } elementTable.put(styleKey.part, styleKey.mode, elementStyle); } return new UIStyleFamily(baseStyle, familyStyles); }
public static Method findGetter(String propertyName, Class<?> beanClass) { Method result = findMethod(beanClass, "get" + propertyName.substring(0, 1).toUpperCase(Locale.ENGLISH) + propertyName.substring(1)); if (result != null) { result.setAccessible(true); return result; } result = findMethod(beanClass, "is" + propertyName.substring(0, 1).toUpperCase(Locale.ENGLISH) + propertyName.substring(1)); if (result != null) { result.setAccessible(true); return result; } return null; }
public static Method findGetter(Field field) { return findGetter(field.getName(), field.getDeclaringClass(), field.getType()); }
public CopyStrategy<?> getStrategy(Type genericType) { Class<?> typeClass = ReflectionUtil.getClassOfType(genericType); if (typeClass == null) { logger.error("Cannot obtain class for type {}, using default strategy", genericType); Type parameter = ReflectionUtil.getTypeParameter(genericType, 0); if (parameter != null) { CopyStrategy<?> contentStrategy = getStrategy(parameter); Type parameter = ReflectionUtil.getTypeParameter(genericType, 0); if (parameter != null) { CopyStrategy<?> contentStrategy = getStrategy(parameter); Type keyParameter = ReflectionUtil.getTypeParameter(genericType, 0); CopyStrategy<?> keyStrategy; if (keyParameter != null) { Type valueParameter = ReflectionUtil.getTypeParameter(genericType, 1); CopyStrategy<?> valueStrategy; if (valueParameter != null) {