void registerReflectiveClasses()

in extensions/js-dsl/deployment/src/main/java/org/apache/camel/quarkus/dsl/js/deployment/JavaScriptDslProcessor.java [128:217]
74 lines of code
17 McCabe index (conditional complexity)

    void registerReflectiveClasses(
            BuildProducer<ReflectiveClassBuildItem> reflectiveClass,
            BuildProducer<ReflectiveMethodBuildItem> reflectiveMethods,
            CombinedIndexBuildItem combinedIndexBuildItem) {

        IndexView view = combinedIndexBuildItem.getIndex();

        for (Class<?> type : CAMEL_REFLECTIVE_CLASSES) {
            DotName name = DotName.createSimple(type.getName());

            if (type.isInterface()) {
                for (ClassInfo info : view.getAllKnownImplementors(name)) {
                    reflectiveClass.produce(
                            ReflectiveClassBuildItem.builder(info.name().toString()).methods().build());
                }
            } else {
                for (ClassInfo info : view.getAllKnownSubclasses(name)) {
                    reflectiveClass.produce(
                            ReflectiveClassBuildItem.builder(info.name().toString()).methods().build());
                }
            }

            reflectiveClass.produce(
                    ReflectiveClassBuildItem.builder(type)
                            .constructors(true)
                            .methods(true)
                            .fields(type.isEnum())
                            .build());
        }

        for (Class<?> type : JAVA_CLASSES) {
            reflectiveClass.produce(ReflectiveClassBuildItem.builder(type).methods().build());
        }

        reflectiveClass.produce(ReflectiveClassBuildItem.builder(Components.class).methods().build());
        reflectiveClass.produce(ReflectiveClassBuildItem.builder(JavaScriptDSL.class).fields().build());
        reflectiveClass.produce(ReflectiveClassBuildItem.builder("org.apache.camel.converter.jaxp.XmlConverter").methods()
                .build());

        Set<String> existingComponents = view.getAllKnownImplementors(Component.class)
                .stream()
                .map(JavaScriptDslProcessor::extractName)
                .collect(Collectors.toSet());

        Set<Class<?>> types = new HashSet<>();
        // Register all public methods of JavaScriptDSL for reflection to be accessible in native mode from a JavaScript resource
        for (Method method : JavaScriptDSL.class.getMethods()) {
            Class<?> declaringClass = method.getDeclaringClass();
            if (!declaringClass.equals(Object.class)) {
                String declaringClassName = declaringClass.getSimpleName();
                // Keep only the methods that are not from builder classes or that are from builder classes of included
                // components
                if (!declaringClassName.endsWith(BUILDER_CLASS_SUFFIX) || existingComponents.contains(
                        declaringClassName.substring(0, declaringClassName.length() - BUILDER_CLASS_SUFFIX.length()))) {
                    Class<?> returnType = method.getReturnType();
                    types.add(returnType);
                    reflectiveMethods.produce(new ReflectiveMethodBuildItem(method));
                    if (declaringClassName.endsWith(BUILDER_CLASS_SUFFIX)) {
                        // Add the return type of the advanced method if any
                        Arrays.stream(returnType.getMethods())
                                .filter(m -> m.getName().equals("advanced") && m.getParameterTypes().length == 0)
                                .findAny()
                                .ifPresent(m -> types.add(m.getReturnType()));
                    }
                }
            }
        }
        // Register all the Camel return types of public methods of the camel reflective classes for reflection to
        // be accessible in native mode from a JavaScript resource
        for (Class<?> c : CAMEL_REFLECTIVE_CLASSES) {
            for (Method method : c.getMethods()) {
                if (!method.getDeclaringClass().equals(Object.class)) {
                    Class<?> returnType = method.getReturnType();
                    if (returnType.getPackageName().startsWith("org.apache.camel.")
                            && !CAMEL_REFLECTIVE_CLASSES.contains(returnType)) {
                        types.add(returnType);
                    }
                }
            }
        }
        // Allow access to methods by reflection to be accessible in native mode from a JavaScript resource
        reflectiveClass.produce(ReflectiveClassBuildItem.builder(types.toArray(new Class<?>[0])).constructors(false)
                .methods().build());
        // Register for reflection the runtime implementation of the main functional interfaces.
        reflectiveClass.produce(
                ReflectiveClassBuildItem.builder(JavaScriptDslBiConsumer.class, JavaScriptDslBiFunction.class,
                        JavaScriptDslBiPredicate.class, JavaScriptDslConsumer.class, JavaScriptDslFunction.class,
                        JavaScriptDslPredicate.class, org.apache.camel.quarkus.dsl.js.runtime.JavaScriptDslProcessor.class,
                        JavaScriptDslSupplier.class).build());
    }