/** @Param args null means don't match args */ public static Method findMethod(Class<?> clazz, String methodName, Object[] args) { if (clazz==null || methodName==null) { return null; } for (Method method: clazz.getDeclaredMethods()) { if (method.getName().equals(methodName)) { if (argsMatch(method, args)) { return method; } } } if (clazz.getSuperclass()!=null) { return findMethod(clazz.getSuperclass(), methodName, args); } return null; }
public static List<Field> getNonStaticFieldsRecursive(Class< ? > type) { List<Field> fieldCollector = new ArrayList<>(); collectNonStaticFieldsRecursive(type, fieldCollector); return fieldCollector; }
public static Map<TypeVariable, Type> getTypeArgsMap(Type type) { Type[] typeArgs = getTypeArgs(type); if (typeArgs==null) { return null; } Class<?> rawClass = getRawClass(type); Map<TypeVariable,Type> typeVariables = new HashMap<>(); TypeVariable<?>[] typeParameters = rawClass.getTypeParameters(); for (int i=0; i<typeArgs.length; i++) { typeVariables.put(typeParameters[i], typeArgs[i]); } return typeVariables; }
throw new IllegalArgumentException("type may not be null"); Class<?> clazz = Reflection.getRawClass(type); Map<TypeVariable,Type> typeArgs = Reflection.getTypeArgsMap(type); Field[] declaredFields = clazz.getDeclaredFields(); if (declaredFields!=null) { Type supertype = Reflection.getSuperclass(type); if (supertype!=null) { scanFields(fieldMappings, supertype);
public static String getSimpleName(Type type) { if (type==null) { return "null"; } if (type instanceof Class) { return ((Class)type).getSimpleName(); } if (type instanceof ParameterizedType) { ParameterizedType parameterizedType = (ParameterizedType) type; StringBuilder name = new StringBuilder(); String rawname = getRawClass(parameterizedType.getRawType()).getSimpleName(); name.append(rawname); Type[] typeArgs = parameterizedType.getActualTypeArguments(); if (typeArgs!=null) { name.append("<"); for (int i = 0; i < typeArgs.length; i++) { if (i!=0) { name.append(","); } name.append(getSimpleName(typeArgs[i])); } name.append(">"); } return name.toString(); } return type.toString(); }
public DataTypeImpl getDataTypeByValue(Type type) { Class< ? > rawClass = Reflection.getRawClass(type); if (rawClass==List.class) { Type elementType = Reflection.getTypeArg(type, 0); DataTypeImpl elementDataType = getDataTypeByValue(elementType); return new ListTypeImpl(elementDataType); } return getDataTypeByValue(rawClass); }
public TypeMapping(Type type) { this.type = type; this.rawClass = Reflection.getRawClass(type); }
public static Method findMethod(Class<?> clazz, String methodName) { return findMethod(clazz, methodName, null); }
@Override public JsonTypeMapper createTypeMapper(Type type, Class< ? > clazz, Mappings mappings) { if (clazz!=null && Map.class.isAssignableFrom(clazz)) { Type valuesType = Reflection.getTypeArg(type, 1); JsonTypeMapper valuesMapper = mappings.getTypeMapper(valuesType); return new MapMapper(valuesMapper); } return null; } }
public String toString() { return Reflection.getSimpleName(field)+"->"+jsonTypeMapper; } }
public Object instantiate() { return Reflection.instantiate(rawClass); }
public static Type getSuperclass(Type type) { return getRawClass(type).getGenericSuperclass(); }
public static void invokeSetter(Object object, String propertyName, Object value) { String setterName = "set"+propertyName.substring(0, 1).toUpperCase()+propertyName.substring(1); try { Method method = Reflection.findMethod(object.getClass(), setterName); method.invoke(object, new Object[]{value}); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException("Couldn't invoke "+setterName+": "+e.getMessage(), e); } } }
public BindingMapper(TypeMapping typeMapping) { super(typeMapping); if (typeMapping.isParameterized()) { Type typeArg = Reflection.getTypeArg(typeMapping.getType(), 0); if (typeArg!=null && typeArg!=Object.class) { isParameterized = true; } } }
public String toString() { return "TypeMapping<"+Reflection.getSimpleName(type)+">"; }
/** finds the most concrete polymorphic mapping that matches the given type. */ public PolymorphicMapping getPolymorphicMapping(Type type) { Class<?> clazz = Reflection.getRawClass(type); PolymorphicMapping polymorphicMapping = polymorphicMappings.get(clazz); while (polymorphicMapping==null && clazz!=null && clazz!=Object.class) { clazz = clazz.getSuperclass(); polymorphicMapping = polymorphicMappings.get(clazz); } return polymorphicMapping; }
public static Object invokeGetter(Object object, String propertyName) { String getterName = "get"+propertyName.substring(0, 1).toUpperCase()+propertyName.substring(1); try { Method method = Reflection.findMethod(object.getClass(), getterName); return method.invoke(object); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException("Couldn't invoke "+getterName+": "+e.getMessage(), e); } }
@Override public JsonTypeMapper createTypeMapper(Type type, Class< ? > clazz, Mappings mappings) { if (clazz!=null && Collection.class.isAssignableFrom(clazz)) { Type elementType = Reflection.getTypeArg(type, 0); JsonTypeMapper elementMapper = mappings.getTypeMapper(elementType); if (List.class.isAssignableFrom(clazz)) { return new CollectionMapper(elementMapper, ArrayList.class); } else if (Set.class.isAssignableFrom(clazz)) { return new CollectionMapper(elementMapper, LinkedHashSet.class); } } return null; } }
public BeanMapper(TypeMapping typeMapping) { super(Reflection.getSimpleName(typeMapping.getType())); this.typeMapping = typeMapping; }
static void collectNonStaticFieldsRecursive(Class< ? > type, List<Field> fieldCollector) { Field[] fields = type.getDeclaredFields(); if (fields!=null) { for (Field field: fields) { if (!Modifier.isStatic(field.getModifiers())) { fieldCollector.add(field); } } } Class< ? > superclass = type.getSuperclass(); if (superclass!=null && superclass!=Object.class) { collectNonStaticFieldsRecursive(superclass, fieldCollector); } }