private boolean computeIsMethodValidated()

in bval-jsr/src/main/java/org/apache/bval/cdi/BValInterceptor.java [243:295]
43 lines of code
10 McCabe index (conditional complexity)

    private <T> boolean computeIsMethodValidated(Class<T> targetClass, Method method) {
        final Signature signature = Signature.of(method);

        AnnotatedMethod<?> declaringMethod = null;

        for (final Class<?> c : Reflection.hierarchy(targetClass, Interfaces.INCLUDE)) {
            final AnnotatedType<?> annotatedType = CDI.current().getBeanManager().createAnnotatedType(c);

            final AnnotatedMethod<?> annotatedMethod = annotatedType.getMethods().stream()
                .filter(am -> Signature.of(am.getJavaMember()).equals(signature)).findFirst().orElse(null);

            if (annotatedMethod != null) {
                declaringMethod = annotatedMethod;
            }
        }
        if (declaringMethod == null) {
            return false;
        }
        final Collection<ExecutableType> declaredExecutableTypes;

        if (declaringMethod.isAnnotationPresent(ValidateOnExecution.class)) {
            final List<ExecutableType> validatedTypesOnMethod =
                Arrays.asList(declaringMethod.getAnnotation(ValidateOnExecution.class).type());

            // implicit directly on method -> early return:
            if (validatedTypesOnMethod.contains(ExecutableType.IMPLICIT)) {
                return true;
            }
            declaredExecutableTypes = validatedTypesOnMethod;
        } else {
            final AnnotatedType<?> declaringType = declaringMethod.getDeclaringType();
            if (declaringType.isAnnotationPresent(ValidateOnExecution.class)) {
                // IMPLICIT is meaningless at class level:
                declaredExecutableTypes =
                    removeFrom(Arrays.asList(declaringType.getAnnotation(ValidateOnExecution.class).type()),
                        ExecutableType.IMPLICIT);
            } else {
                final Package pkg = declaringType.getJavaClass().getPackage();
                if (pkg != null && pkg.isAnnotationPresent(ValidateOnExecution.class)) {
                    // presumably IMPLICIT is likewise meaningless at package level:
                    declaredExecutableTypes = removeFrom(
                        Arrays.asList(pkg.getAnnotation(ValidateOnExecution.class).type()), ExecutableType.IMPLICIT);
                } else {
                    declaredExecutableTypes = null;
                }
            }
        }
        final ExecutableType methodType =
            Methods.isGetter(method) ? ExecutableType.GETTER_METHODS : ExecutableType.NON_GETTER_METHODS;

        return Optional.ofNullable(declaredExecutableTypes).map(ExecutableTypes::interpret)
            .orElse(globalConfiguration.getGlobalExecutableTypes()).contains(methodType);
    }