/**
* get types annotated with a given annotation, both classes and annotations
*
* <p>{@link Inherited} is honored according to given honorInherited.
*
* <p>when honoring @Inherited, meta-annotation should only effect annotated super classes and
* it's sub types
*
* <p>when not honoring @Inherited, meta annotation effects all subtypes, including annotations
* interfaces and classes
*
* <p><i>Note that this (@Inherited) meta-annotation type has no effect if the annotated type is
* used for anything other then a class. Also, this meta-annotation causes annotations to be
* inherited only from superclasses; annotations on implemented interfaces have no effect.</i>
*
* <p>depends on TypeAnnotationsScanner and SubTypesScanner configured
*/
public Set<Class<?>> getTypesAnnotatedWith(
final Class<? extends Annotation> annotation, boolean honorInherited) {
Iterable<String> annotated =
store.get(index(TypeAnnotationsScanner.class), annotation.getName());
Iterable<String> classes =
getAllAnnotated(annotated, annotation.isAnnotationPresent(Inherited.class), honorInherited);
return Sets.newHashSet(concat(forNames(annotated, loaders()), forNames(classes, loaders())));
}
private void expandSupertypes(Multimap<String, String> mmap, String key, Class<?> type) {
for (Class<?> supertype : ReflectionUtils.getSuperTypes(type)) {
if (mmap.put(supertype.getName(), key)) {
if (log != null) log.debug("expanded subtype {} -> {}", supertype.getName(), key);
expandSupertypes(mmap, supertype.getName(), supertype);
}
}
}
/**
* get all fields annotated with a given annotation
*
* <p>depends on FieldAnnotationsScanner configured
*/
public Set<Field> getFieldsAnnotatedWith(final Class<? extends Annotation> annotation) {
final Set<Field> result = Sets.newHashSet();
for (String annotated : store.get(index(FieldAnnotationsScanner.class), annotation.getName())) {
result.add(getFieldFromString(annotated, loaders()));
}
return result;
}
private static String index(Class<? extends Scanner> scannerClass) {
return scannerClass.getSimpleName();
}
/** get constructors with any parameter annotated with given annotation */
public Set<Constructor> getConstructorsWithAnyParamAnnotated(
Class<? extends Annotation> annotation) {
return getConstructorsFromDescriptors(
store.get(index(MethodParameterScanner.class), annotation.getName()), loaders());
}
/**
* get all constructors annotated with a given annotation
*
* <p>depends on MethodAnnotationsScanner configured
*/
public Set<Constructor> getConstructorsAnnotatedWith(
final Class<? extends Annotation> annotation) {
Iterable<String> methods =
store.get(index(MethodAnnotationsScanner.class), annotation.getName());
return getConstructorsFromDescriptors(methods, loaders());
}
/**
* gets all sub types in hierarchy of a given type
*
* <p>depends on SubTypesScanner configured
*/
public <T> Set<Class<? extends T>> getSubTypesOf(final Class<T> type) {
return Sets.newHashSet(
ReflectionUtils.<T>forNames(
store.getAll(index(SubTypesScanner.class), Arrays.asList(type.getName())), loaders()));
}