Examples with MethodParameterInfo org.jboss.jandex.MethodParameterInfo used on opensource projects

Example 1 with MethodParameterInfo

use of org.jboss.jandex.MethodParameterInfo in project wildfly by wildfly.

the class ServletContainerInitializerDeploymentProcessor method processHandlesType.

private Set<ClassInfo> processHandlesType(DotName typeName, Class<?> type, CompositeIndex index, CompositeIndex parent) throws DeploymentUnitProcessingException {
    Set<ClassInfo> classes = new HashSet<ClassInfo>();
    if (type.isAnnotation()) {
        List<AnnotationInstance> instances = index.getAnnotations(typeName);
        for (AnnotationInstance instance : instances) {
            AnnotationTarget annotationTarget = instance.target();
            if (annotationTarget instanceof ClassInfo) {
                classes.add((ClassInfo) annotationTarget);
            } else if (annotationTarget instanceof FieldInfo) {
                classes.add(((FieldInfo) annotationTarget).declaringClass());
            } else if (annotationTarget instanceof MethodInfo) {
                classes.add(((MethodInfo) annotationTarget).declaringClass());
            } else if (annotationTarget instanceof MethodParameterInfo) {
                classes.add(((MethodParameterInfo) annotationTarget).method().declaringClass());
            }
        }
    } else {
        classes.addAll(index.getAllKnownSubclasses(typeName));
        classes.addAll(index.getAllKnownImplementors(typeName));
        if (parent != null) {
            Set<ClassInfo> parentImplementors = new HashSet<>();
            parentImplementors.addAll(parent.getAllKnownImplementors(typeName));
            parentImplementors.addAll(parent.getAllKnownSubclasses(typeName));
            for (ClassInfo pc : parentImplementors) {
                classes.addAll(index.getAllKnownSubclasses(pc.name()));
                classes.addAll(index.getAllKnownImplementors(pc.name()));
            }
        }
    }
    return classes;
}

Example 2 with MethodParameterInfo

use of org.jboss.jandex.MethodParameterInfo in project wildfly by wildfly.

the class ClassAnnotationInformationFactory method createAnnotationInformation.

public Map<String, ClassAnnotationInformation<A, T>> createAnnotationInformation(final CompositeIndex index, final PropertyReplacer propertyReplacer) {
    final List<TargetAnnotation> annotations = new ArrayList<TargetAnnotation>();
    if (multiAnnotationDotName != null) {
        for (AnnotationInstance multiInstance : index.getAnnotations(multiAnnotationDotName)) {
            annotations.addAll(fromMultiAnnotation(multiInstance));
        }
    }
    final List<AnnotationInstance> simpleAnnotations = index.getAnnotations(annotationDotName);
    if (simpleAnnotations != null) {
        for (AnnotationInstance annotation : simpleAnnotations) {
            annotations.add(new TargetAnnotation(annotation, annotation.target()));
        }
    }
    final Map<DotName, List<TargetAnnotation>> classLevel = new HashMap<DotName, List<TargetAnnotation>>();
    final Map<DotName, List<TargetAnnotation>> methodLevel = new HashMap<DotName, List<TargetAnnotation>>();
    final Map<DotName, List<TargetAnnotation>> fieldLevel = new HashMap<DotName, List<TargetAnnotation>>();
    for (TargetAnnotation instance : annotations) {
        final DotName targetClass = getAnnotationClass(instance.target()).name();
        if (instance.target() instanceof ClassInfo) {
            List<TargetAnnotation> data = classLevel.get(targetClass);
            if (data == null)
                classLevel.put(targetClass, data = new ArrayList<TargetAnnotation>(1));
            data.add(instance);
        } else if (instance.target() instanceof MethodInfo) {
            List<TargetAnnotation> data = methodLevel.get(targetClass);
            if (data == null)
                methodLevel.put(targetClass, data = new ArrayList<TargetAnnotation>(1));
            data.add(instance);
        } else if (instance.target() instanceof FieldInfo) {
            List<TargetAnnotation> data = fieldLevel.get(targetClass);
            if (data == null)
                fieldLevel.put(targetClass, data = new ArrayList<TargetAnnotation>(1));
            data.add(instance);
        } else if (instance.target() instanceof MethodParameterInfo) {
        // ignore for now
        } else {
            throw EeLogger.ROOT_LOGGER.unknownAnnotationTargetType(instance.target());
        }
    }
    final Map<String, ClassAnnotationInformation<A, T>> ret = new HashMap<String, ClassAnnotationInformation<A, T>>();
    final Set<DotName> allClasses = new HashSet<DotName>(classLevel.keySet());
    allClasses.addAll(methodLevel.keySet());
    allClasses.addAll(fieldLevel.keySet());
    for (DotName clazz : allClasses) {
        final List<TargetAnnotation> classAnnotations = classLevel.get(clazz);
        final List<T> classData;
        if (classAnnotations == null) {
            classData = Collections.emptyList();
        } else {
            classData = new ArrayList<T>(classAnnotations.size());
            for (TargetAnnotation instance : classAnnotations) {
                classData.add(fromAnnotation(instance.instance(), propertyReplacer));
            }
        }
        final List<TargetAnnotation> fieldAnnotations = fieldLevel.get(clazz);
        final Map<String, List<T>> fieldData;
        // field level annotations
        if (fieldAnnotations == null) {
            fieldData = Collections.emptyMap();
        } else {
            fieldData = new HashMap<String, List<T>>();
            for (TargetAnnotation instance : fieldAnnotations) {
                final String name = ((FieldInfo) instance.target()).name();
                List<T> data = fieldData.get(name);
                if (data == null) {
                    fieldData.put(name, data = new ArrayList<T>(1));
                }
                data.add(fromAnnotation(instance.instance(), propertyReplacer));
            }
        }
        final List<TargetAnnotation> methodAnnotations = methodLevel.get(clazz);
        final Map<MethodIdentifier, List<T>> methodData;
        // method level annotations
        if (methodAnnotations == null) {
            methodData = Collections.emptyMap();
        } else {
            methodData = new HashMap<MethodIdentifier, List<T>>();
            for (TargetAnnotation instance : methodAnnotations) {
                final MethodIdentifier identifier = getMethodIdentifier(instance.target());
                List<T> data = methodData.get(identifier);
                if (data == null) {
                    methodData.put(identifier, data = new ArrayList<T>(1));
                }
                data.add(fromAnnotation(instance.instance(), propertyReplacer));
            }
        }
        ClassAnnotationInformation<A, T> information = new ClassAnnotationInformation<A, T>(annotationType, classData, methodData, fieldData);
        ret.put(clazz.toString(), information);
    }
    return ret;
}