Configuration Mapper

implementation/pom.xml

@@ -61,6 +61,10 @@
       <groupId>io.smallrye.common</groupId>
       <artifactId>smallrye-common-constraint</artifactId>
     </dependency>
+    <dependency>
+      <groupId>io.smallrye.common</groupId>
+      <artifactId>smallrye-common-classloader</artifactId>
+    </dependency>
 
     <dependency>
       <groupId>org.jboss.logging</groupId>
@@ -75,6 +79,11 @@
       <artifactId>jboss-logging-processor</artifactId>
     </dependency>
 
+    <dependency>
+      <groupId>org.ow2.asm</groupId>
+      <artifactId>asm</artifactId>
+    </dependency>
+
     <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter</artifactId>

implementation/src/main/java/io/smallrye/config/ConfigMapping.java

@@ -0,0 +1,14 @@
+package io.smallrye.config;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ConfigMapping {
+    String value();
+}

implementation/src/main/java/io/smallrye/config/ConfigMappingContext.java

@@ -0,0 +1,223 @@
+package io.smallrye.config;
+
+import static io.smallrye.config.ConfigMappingInterface.LeafProperty;
+import static io.smallrye.config.ConfigMappingInterface.MapProperty;
+import static io.smallrye.config.ConfigMappingInterface.PrimitiveProperty;
+import static io.smallrye.config.ConfigMappingInterface.Property;
+import static io.smallrye.config.ConfigMappingInterface.getConfigurationInterface;
+import static io.smallrye.config.ConfigMappingInterface.rawTypeOf;
+import static io.smallrye.config.ConfigMappingInterface.typeOfParameter;
+import static io.smallrye.config.ConfigValidationException.Problem;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.UndeclaredThrowableException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+import org.eclipse.microprofile.config.spi.Converter;
+
+/**
+ * A mapping context. This is used by generated classes during configuration mapping, and is released once the configuration
+ * mapping has completed.
+ */
+public final class ConfigMappingContext {
+
+    private final Map<Class<?>, Map<String, Map<Object, Object>>> enclosedThings = new IdentityHashMap<>();
+    private final Map<Class<?>, Map<String, ConfigMappingObject>> roots = new IdentityHashMap<>();
+    private final Map<Class<?>, Map<String, Converter<?>>> convertersByTypeAndField = new IdentityHashMap<>();
+    private final List<Map<Class<?>, Map<String, Converter<?>>>> keyConvertersByDegreeTypeAndField = new ArrayList<>();
+    private final Map<Class<?>, Converter<?>> converterInstances = new IdentityHashMap<>();
+    private final List<ConfigMappingObject> allInstances = new ArrayList<>();
+    private final SmallRyeConfig config;
+    private final StringBuilder stringBuilder = new StringBuilder();
+    private final ArrayList<Problem> problems = new ArrayList<>();
+
+    ConfigMappingContext(final SmallRyeConfig config) {
+        this.config = config;
+    }
+
+    public ConfigMappingObject getRoot(Class<?> rootType, String rootPath) {
+        return roots.getOrDefault(rootType, Collections.emptyMap()).get(rootPath);
+    }
+
+    public void registerRoot(Class<?> rootType, String rootPath, ConfigMappingObject root) {
+        roots.computeIfAbsent(rootType, x -> new HashMap<>()).put(rootPath, root);
+    }
+
+    public Object getEnclosedField(Class<?> enclosingType, String key, Object enclosingObject) {
+        return enclosedThings
+                .getOrDefault(enclosingType, Collections.emptyMap())
+                .getOrDefault(key, Collections.emptyMap())
+                .get(enclosingObject);
+    }
+
+    public void registerEnclosedField(Class<?> enclosingType, String key, Object enclosingObject, Object value) {
+        enclosedThings
+                .computeIfAbsent(enclosingType, x -> new HashMap<>())
+                .computeIfAbsent(key, x -> new IdentityHashMap<>())
+                .put(enclosingObject, value);
+    }
+
+    public <T> T constructGroup(Class<T> interfaceType) {
+        Constructor<? extends ConfigMappingObject> constructor = getConfigurationInterface(interfaceType).getConstructor();
+        ConfigMappingObject instance;
+        try {
+            instance = constructor.newInstance(this);
+        } catch (InstantiationException e) {
+            throw new InstantiationError(e.getMessage());
+        } catch (IllegalAccessException e) {
+            throw new IllegalAccessError(e.getMessage());
+        } catch (InvocationTargetException e) {
+            try {
+                throw e.getCause();
+            } catch (RuntimeException | Error e2) {
+                throw e2;
+            } catch (Throwable t) {
+                throw new UndeclaredThrowableException(t);
+            }
+        }
+        allInstances.add(instance);
+        return interfaceType.cast(instance);
+    }
+
+    @SuppressWarnings({ "unchecked", "unused" })
+    public <T> Converter<T> getValueConverter(Class<?> enclosingType, String field) {
+        return (Converter<T>) convertersByTypeAndField
+                .computeIfAbsent(enclosingType, x -> new HashMap<>())
+                .computeIfAbsent(field, x -> {
+                    ConfigMappingInterface ci = getConfigurationInterface(enclosingType);
+                    Property property = ci.getProperty(field);
+                    boolean optional = property.isOptional();
+                    if (property.isLeaf() || optional && property.asOptional().getNestedProperty().isLeaf()) {
+                        LeafProperty leafProperty = optional ? property.asOptional().getNestedProperty().asLeaf()
+                                : property.asLeaf();
+                        if (leafProperty.hasConvertWith()) {
+                            Class<? extends Converter<?>> convertWith = leafProperty.getConvertWith();
+                            // todo: generics
+                            return getConverterInstance(convertWith);
+                        } else {
+                            // todo: replace with generic converter lookup
+                            Class<?> valueRawType = leafProperty.getValueRawType();
+                            if (valueRawType == List.class) {
+                                return Converters.newCollectionConverter(
+                                        config.getConverter(rawTypeOf(typeOfParameter(leafProperty.getValueType(), 0))),
+                                        ArrayList::new);
+                            } else if (valueRawType == Set.class) {
+                                return Converters.newCollectionConverter(
+                                        config.getConverter(rawTypeOf(typeOfParameter(leafProperty.getValueType(), 0))),
+                                        HashSet::new);
+                            } else {
+                                return config.getConverter(valueRawType);
+                            }
+                        }
+                    } else if (property.isPrimitive()) {
+                        PrimitiveProperty primitiveProperty = property.asPrimitive();
+                        if (primitiveProperty.hasConvertWith()) {
+                            return getConverterInstance(primitiveProperty.getConvertWith());
+                        } else {
+                            return config.getConverter(primitiveProperty.getBoxType());
+                        }
+                    } else {
+                        throw new IllegalStateException();
+                    }
+                });
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> Converter<T> getKeyConverter(Class<?> enclosingType, String field, int degree) {
+        List<Map<Class<?>, Map<String, Converter<?>>>> list = this.keyConvertersByDegreeTypeAndField;
+        while (list.size() <= degree) {
+            list.add(new IdentityHashMap<>());
+        }
+        Map<Class<?>, Map<String, Converter<?>>> map = list.get(degree);
+        return (Converter<T>) map
+                .computeIfAbsent(enclosingType, x -> new HashMap<>())
+                .computeIfAbsent(field, x -> {
+                    ConfigMappingInterface ci = getConfigurationInterface(enclosingType);
+                    MapProperty property = ci.getProperty(field).asMap();
+                    while (degree + 1 > property.getLevels()) {
+                        property = property.getValueProperty().asMap();
+                    }
+                    if (property.hasKeyConvertWith()) {
+                        return getConverterInstance(property.getKeyConvertWith());
+                    } else {
+                        // todo: replace with generic converter lookup
+                        Class<?> valueRawType = property.getKeyRawType();
+                        if (valueRawType == List.class) {
+                            return Converters.newCollectionConverter(
+                                    config.getConverter(rawTypeOf(typeOfParameter(property.getKeyType(), 0))), ArrayList::new);
+                        } else if (valueRawType == Set.class) {
+                            return Converters.newCollectionConverter(
+                                    config.getConverter(rawTypeOf(typeOfParameter(property.getKeyType(), 0))), HashSet::new);
+                        } else {
+                            return config.getConverter(valueRawType);
+                        }
+                    }
+                });
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> Converter<T> getConverterInstance(Class<? extends Converter<? extends T>> converterType) {
+        return (Converter<T>) converterInstances.computeIfAbsent(converterType, t -> {
+            try {
+                return (Converter<T>) t.getConstructor().newInstance();
+            } catch (InstantiationException e) {
+                throw new InstantiationError(e.getMessage());
+            } catch (IllegalAccessException e) {
+                throw new IllegalAccessError(e.getMessage());
+            } catch (InvocationTargetException e) {
+                try {
+                    throw e.getCause();
+                } catch (RuntimeException | Error e2) {
+                    throw e2;
+                } catch (Throwable t2) {
+                    throw new UndeclaredThrowableException(t2);
+                }
+            } catch (NoSuchMethodException e) {
+                throw new NoSuchMethodError(e.getMessage());
+            }
+        });
+    }
+
+    public NoSuchElementException noSuchElement(Class<?> type) {
+        return new NoSuchElementException("A required configuration group of type " + type.getName() + " was not provided");
+    }
+
+    public void unknownConfigElement(final String propertyName) {
+        problems.add(new Problem(propertyName + " does not map to any root"));
+    }
+
+    void fillInOptionals() {
+        for (ConfigMappingObject instance : allInstances) {
+            instance.fillInOptionals(this);
+        }
+    }
+
+    public SmallRyeConfig getConfig() {
+        return config;
+    }
+
+    public StringBuilder getStringBuilder() {
+        return stringBuilder;
+    }
+
+    public void reportProblem(RuntimeException problem) {
+        problems.add(new Problem(problem.toString()));
+    }
+
+    ArrayList<Problem> getProblems() {
+        return problems;
+    }
+
+    Map<Class<?>, Map<String, ConfigMappingObject>> getRootsMap() {
+        return roots;
+    }
+}