public <T> List<Class<? extends T>> findImplementations(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); if (!clazz.isInterface()) new IllegalArgumentException("class must be an interface"); classesNotLoaded.clear(); final String interfaceName = clazz.getName(); // Collect all interfaces extending the main interface (recursively) // Collect all implementations of interfaces // i.e. all *directly* implementing classes List<ClassInfo> infos = collectImplementations(interfaceName); // Collect all subclasses of implementations List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>(); for (ClassInfo info : infos) { try { final Class<? extends T> impl = (Class<? extends T>) info.get(); if (clazz.isAssignableFrom(impl)) { classes.add(impl); // Optimization: Don't need to call this method if parent class was already searched classes.addAll(_findSubclasses(impl)); } } catch (ClassNotFoundException e) { classesNotLoaded.add(info.getName()); } } return classes; }
public void visitEnd() { if (debug) System.out.println(" visitEnd()"); switch (state) { case INTERFACE: List<String> interfces = ((ClassInfo) info).getInterfaces(); int idx = interfces.size() - 1; String interfce = interfces.get(idx); interfce += ">"; interfces.set(idx, interfce); break; case FORMAL_TYPE_PARAM: String name = ((ClassInfo) info).name; if (name.contains("<")) { ((ClassInfo) info).name += ">"; } } state = GenericAwareInfoBuildingVisitor.STATE.END; }
public List<Class<?>> findClassesInPackage(String packageName, boolean recursive) { classesNotLoaded.clear(); List<Class<?>> classes = new ArrayList<Class<?>>(); for (ClassInfo classInfo : classInfos.values()) { try { if (recursive && classInfo.getPackageName().startsWith(packageName)){ classes.add(classInfo.get()); } else if (classInfo.getPackageName().equals(packageName)){ classes.add(classInfo.get()); } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } return classes; }
try { if(info instanceof ClassInfo){ classes.add(((ClassInfo) info).get()); try { String superType = classInfo.getSuperType(); for (Class clazz : classes) { if (superType.equals(clazz.getName())) { classes.add(classInfo.get()); tempClassInfos.remove(pos); annClassFound = true; List<String> interfces = classInfo.getInterfaces(); for (String interfce: interfces) { for (Class clazz : classes) { if (interfce.replaceFirst("<.*>","").equals(clazz.getName())) { classes.add(classInfo.get()); tempClassInfos.remove(pos); annClassFound = true; classesNotLoaded.add(classInfo.getName()); } catch (NoClassDefFoundError e) { classesNotLoaded.add(classInfo.getName());
try { if(info instanceof ClassInfo){ classes.add(((ClassInfo) info).get()); try { String superType = classInfo.getSuperType(); for (Class clazz : classes) { if (superType.equals(clazz.getName())) { classes.add(classInfo.get()); tempClassInfos.remove(pos); annClassFound = true; List<String> interfces = classInfo.getInterfaces(); for (String interfce: interfces) { for (Class clazz : classes) { if (interfce.replaceFirst("<.*>","").equals(clazz.getName())) { classes.add(classInfo.get()); tempClassInfos.remove(pos); annClassFound = true; classesNotLoaded.add(classInfo.getName()); } catch (NoClassDefFoundError e) { classesNotLoaded.add(classInfo.getName());
try { if(info instanceof ClassInfo){ classes.add(((ClassInfo) info).get()); try { String superType = classInfo.getSuperType(); for (Class clazz : classes) { if (superType.equals(clazz.getName())) { classes.add(classInfo.get()); tempClassInfos.remove(pos); annClassFound = true; List<String> interfces = classInfo.getInterfaces(); for (String interfce: interfces) { for (Class clazz : classes) { if (interfce.replaceFirst("<.*>","").equals(clazz.getName())) { classes.add(classInfo.get()); tempClassInfos.remove(pos); annClassFound = true; classesNotLoaded.add(classInfo.getName()); } catch (NoClassDefFoundError e) { classesNotLoaded.add(classInfo.getName());
ClassInfo classInfo = new ClassInfo(clazz); infos.add(classInfo); classInfos.put(clazz.getName(), classInfo);
ClassInfo classInfo = new ClassInfo(clazz); infos.add(classInfo); classInfos.put(clazz.getName(), classInfo);
public List<Field> findAnnotatedFields(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Field> fields = new ArrayList<Field>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof FieldInfo) { FieldInfo fieldInfo = (FieldInfo) info; ClassInfo classInfo = fieldInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Field field : clazz.getDeclaredFields()) { if (field.isAnnotationPresent(annotation)) { fields.add(field); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return fields; }
public List<Constructor> findAnnotatedConstructors(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Constructor> constructors = new ArrayList<Constructor>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && info.getName().equals("<init>")) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Constructor constructor : clazz.getConstructors()) { if (constructor.isAnnotationPresent(annotation)) { constructors.add(constructor); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return constructors; }
ClassInfo classInfo = new ClassInfo(clazz); infos.add(classInfo); classInfos.put(clazz.getName(), classInfo);
public <T> List<Class<? extends T>> findImplementations(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); if (!clazz.isInterface()) new IllegalArgumentException("class must be an interface"); classesNotLoaded.clear(); final String interfaceName = clazz.getName(); // Collect all interfaces extending the main interface (recursively) // Collect all implementations of interfaces // i.e. all *directly* implementing classes List<ClassInfo> infos = collectImplementations(interfaceName); // Collect all subclasses of implementations List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>(); for (ClassInfo info : infos) { try { final Class<? extends T> impl = (Class<? extends T>) info.get(); if (clazz.isAssignableFrom(impl)) { classes.add(impl); // Optimization: Don't need to call this method if parent class was already searched classes.addAll(_findSubclasses(impl)); } } catch (ClassNotFoundException e) { classesNotLoaded.add(info.getName()); } } return classes; }
public List<Field> findAnnotatedFields(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Field> fields = new ArrayList<Field>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof FieldInfo) { FieldInfo fieldInfo = (FieldInfo) info; ClassInfo classInfo = fieldInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Field field : clazz.getDeclaredFields()) { if (field.isAnnotationPresent(annotation)) { fields.add(field); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return fields; }
public List<Method> findAnnotatedMethods(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Method> methods = new ArrayList<Method>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && !info.getName().equals("<init>")) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(annotation)) { methods.add(method); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return methods; }
public List<Method> findAnnotatedMethods(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Method> methods = new ArrayList<Method>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && !info.getName().equals("<init>")) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(annotation)) { methods.add(method); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return methods; }
public List<Constructor> findAnnotatedConstructors(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Constructor> constructors = new ArrayList<Constructor>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && info.getName().equals("<init>")) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Constructor constructor : clazz.getConstructors()) { if (constructor.isAnnotationPresent(annotation)) { constructors.add(constructor); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return constructors; }
public List<Constructor> findAnnotatedConstructors(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Constructor> constructors = new ArrayList<Constructor>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && info.getName().equals("<init>")) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Constructor constructor : clazz.getConstructors()) { if (constructor.isAnnotationPresent(annotation)) { constructors.add(constructor); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return constructors; }
public <T> List<Class<? extends T>> findImplementations(Class<T> clazz) { if (clazz == null) throw new NullPointerException("class cannot be null"); if (!clazz.isInterface()) new IllegalArgumentException("class must be an interface"); classesNotLoaded.clear(); final String interfaceName = clazz.getName(); // Collect all interfaces extending the main interface (recursively) // Collect all implementations of interfaces // i.e. all *directly* implementing classes List<ClassInfo> infos = collectImplementations(interfaceName); // Collect all subclasses of implementations List<Class<? extends T>> classes = new ArrayList<Class<? extends T>>(); for (ClassInfo info : infos) { try { final Class<? extends T> impl = (Class<? extends T>) info.get(); if (clazz.isAssignableFrom(impl)) { classes.add(impl); // Optimization: Don't need to call this method if parent class was already searched classes.addAll(_findSubclasses(impl)); } } catch (ClassNotFoundException e) { classesNotLoaded.add(info.getName()); } } return classes; }
public List<Field> findAnnotatedFields(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Field> fields = new ArrayList<Field>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof FieldInfo) { FieldInfo fieldInfo = (FieldInfo) info; ClassInfo classInfo = fieldInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Field field : clazz.getDeclaredFields()) { if (field.isAnnotationPresent(annotation)) { fields.add(field); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return fields; }
public List<Method> findAnnotatedMethods(Class<? extends Annotation> annotation) { classesNotLoaded.clear(); List<ClassInfo> seen = new ArrayList<ClassInfo>(); List<Method> methods = new ArrayList<Method>(); List<Info> infos = getAnnotationInfos(annotation.getName()); for (Info info : infos) { if (info instanceof MethodInfo && !info.getName().equals("<init>")) { MethodInfo methodInfo = (MethodInfo) info; ClassInfo classInfo = methodInfo.getDeclaringClass(); if (seen.contains(classInfo)) continue; seen.add(classInfo); try { Class clazz = classInfo.get(); for (Method method : clazz.getDeclaredMethods()) { if (method.isAnnotationPresent(annotation)) { methods.add(method); } } } catch (ClassNotFoundException e) { classesNotLoaded.add(classInfo.getName()); } } } return methods; }