/** * Get all superclasses and interfaces recursively. * * @param clazz The class to start the search with. * * @return List of all super classes and interfaces of {@code clazz}. The list contains the class itself! The empty * list is returned if {@code clazz} is {@code null}. */ public static List<Class<?>> computeClassHierarchy(Class<?> clazz) { List<Class<?>> classes = new ArrayList<Class<?>>(); computeClassHierarchy(clazz, classes); return classes; }
/** * Get all superclasses and interfaces recursively. * * @param clazz The class to start the search with. * @param classes List of classes to which to add all found super classes and interfaces. */ private static void computeClassHierarchy(Class<?> clazz, List<Class<?>> classes) { for (Class<?> current = clazz; current != null; current = current.getSuperclass()) { if (classes.contains(current)) { return; } classes.add(current); for (Class<?> currentInterface : current.getInterfaces()) { computeClassHierarchy(currentInterface, classes); } } }
private Set<Class<?>> getSuperClasses(Class<?> clazz) { Set<Class<?>> transitive = new HashSet<Class<?>>(); List<Class<?>> classes = computeClassHierarchy(clazz); for (Class<?> superclass : classes) { if (shouldAdd(superclass)) { transitive.add(superclass); } } return transitive; }
public void add(Class<?> clazz) { List<Class<?>> classes = Reflections.computeClassHierarchy(clazz); for (Class<?> aClass : classes) { List<Class<?>> enclosings = Reflections.computeEnclosingClasses(clazz); for (Class<?> enclosing : enclosings) { if (shouldAdd(enclosing)) { dependencies.add(enclosing); } } if (shouldAdd(aClass)) { dependencies.add(aClass); } dependencies.addAll(getTransitiveDependencies(aClass)); } }