public void execute()

in arthur-impl/src/main/java/org/apache/geronimo/arthur/impl/nativeimage/generator/extension/AnnotationExtension.java [49:112]
62 lines of code
5 McCabe index (conditional complexity)

    public void execute(final Context context) {
        ofNullable(context.getProperty("extension.annotation.custom.annotations.class"))
                .ifPresent(names -> Stream.of(names.split(","))
                        .map(String::trim)
                        .filter(it -> !it.isEmpty())
                        .forEach(config -> { // syntax is: <annotation fqn>:<RegisterClass method=true|false>, if only fqn then all=true is supposed
                            final int sep = config.indexOf(':');
                            final String fqn = sep < 0 ? config : config.substring(0, sep);
                            final RegisterClass registerClass = newRegisterClass(sep < 0 ? "all=true" : config.substring(sep + 1));
                            context.findAnnotatedClasses(context.loadClass(fqn.trim()).asSubclass(Annotation.class)).stream()
                                    .flatMap(clazz -> register(clazz, registerClass))
                                    .forEach(context::register);
                        }));
        ofNullable(context.getProperty("extension.annotation.custom.annotations.properties"))
                .ifPresent(names -> Stream.of(names.split(","))
                        .map(String::trim)
                        .filter(it -> !it.isEmpty())
                        .forEach(config -> { // syntax is: <annotation fqn>:<RegisterClass method=true|false>, if only fqn then all=true is supposed
                            final int sep = config.indexOf(':');
                            final String fqn = sep < 0 ? config : config.substring(0, sep);
                            final RegisterClass registerClass = newRegisterClass(sep < 0 ? "all=true" : config.substring(sep + 1));
                            final Class<? extends Annotation> annot = context.loadClass(fqn.trim()).asSubclass(Annotation.class);
                            Stream.concat(
                                    context.findAnnotatedMethods(annot).stream().map(Method::getDeclaringClass),
                                    context.findAnnotatedFields(annot).stream().map(Field::getDeclaringClass))
                                    .distinct()
                                    .flatMap(clazz -> register(clazz, registerClass))
                                    .forEach(context::register);
                        }));

        context.findAnnotatedClasses(RegisterClass.class).stream()
                .flatMap(clazz -> register(clazz, clazz.getAnnotation(RegisterClass.class)))
                .forEach(context::register);

        final Collection<RegisterResource> resources = context.findAnnotatedClasses(RegisterResource.class).stream()
                .flatMap(clazz -> Stream.of(clazz.getAnnotation(RegisterResource.class)))
                .collect(toList());
        resources.stream()
                .flatMap(rr -> Stream.of(rr.patterns()))
                .map(pattern -> {
                    final ResourceModel resourceModel = new ResourceModel();
                    resourceModel.setPattern(pattern);
                    return resourceModel;
                })
                .distinct()
                .forEach(context::register);
        resources.stream()
                .flatMap(rr -> Stream.of(rr.bundles()))
                .map(name -> {
                    final ResourceBundleModel bundleModel = new ResourceBundleModel();
                    bundleModel.setName(name);
                    return bundleModel;
                })
                .distinct()
                .forEach(context::register);
        context.findAnnotatedClasses(RegisterClasses.Entry.class).stream()
                .map(it -> it.getAnnotation(RegisterClasses.Entry.class))
                .flatMap(entry -> doRegisterEntry(context, entry))
                .forEach(context::register);
        context.findAnnotatedClasses(RegisterClasses.class).stream()
                .flatMap(it -> Stream.of(it.getAnnotation(RegisterClasses.class).value()))
                .flatMap(entry -> doRegisterEntry(context, entry))
                .forEach(context::register);
    }