io.smallrye.config.ConfigMappings Maven / Gradle / Ivy

Go to download
package io.smallrye.config;

import static io.smallrye.config.ConfigMappingLoader.getConfigMappingClass;

import java.io.Serializable;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.eclipse.microprofile.config.inject.ConfigProperties;
import org.eclipse.microprofile.config.spi.ConfigSource;

public final class ConfigMappings implements Serializable {
    private static final long serialVersionUID = -7790784345796818526L;

    private final ConcurrentMap, Map> mappings;

    ConfigMappings() {
        this.mappings = new ConcurrentHashMap<>();
    }

    void registerConfigMappings(final Map, Map> mappings) {
        this.mappings.putAll(mappings);
    }

    public static void registerConfigMappings(final SmallRyeConfig config, final Set mappings)
            throws ConfigValidationException {
        final ConfigMappingProvider.Builder builder = ConfigMappingProvider.builder().validateUnknown(false);
        for (ConfigMappingWithPrefix mapping : mappings) {
            builder.addRoot(mapping.getPrefix(), mapping.getKlass());
        }

        registerConfigMappings(config, builder.build());
    }

    public static void registerConfigMappings(final SmallRyeConfig config, final ConfigMappingProvider mappingProvider)
            throws ConfigValidationException {
        for (ConfigSource configSource : config.getConfigSources()) {
            if (configSource instanceof DefaultValuesConfigSource) {
                final DefaultValuesConfigSource defaultValuesConfigSource = (DefaultValuesConfigSource) configSource;
                defaultValuesConfigSource.registerDefaults(mappingProvider.getDefaultValues());
            }
        }

        mappingProvider.mapConfiguration(config);
    }

     T getConfigMapping(Class type) {
        final String prefix = Optional.ofNullable(type.getAnnotation(ConfigMapping.class))
                .map(ConfigMapping::prefix)
                .orElseGet(() -> Optional.ofNullable(type.getAnnotation(ConfigProperties.class)).map(ConfigProperties::prefix)
                        .orElse(""));

        return getConfigMapping(type, prefix);
    }

     T getConfigMapping(Class type, String prefix) {
        if (prefix == null) {
            return getConfigMapping(type);
        }

        final Map mappingsForType = mappings.get(getConfigMappingClass(type));
        if (mappingsForType == null) {
            throw ConfigMessages.msg.mappingNotFound(type.getName());
        }

        final ConfigMappingObject configMappingObject = mappingsForType.get(prefix);
        if (configMappingObject == null) {
            throw ConfigMessages.msg.mappingPrefixNotFound(type.getName(), prefix);
        }

        if (configMappingObject instanceof ConfigMappingClassMapper) {
            return type.cast(((ConfigMappingClassMapper) configMappingObject).map());
        }

        return type.cast(configMappingObject);
    }

    static String getPrefix(Class type) {
        final ConfigMapping configMapping = type.getAnnotation(ConfigMapping.class);
        return configMapping != null ? configMapping.prefix() : "";
    }

    public static final class ConfigMappingWithPrefix {
        private final Class klass;
        private final String prefix;

        public ConfigMappingWithPrefix(final Class klass, final String prefix) {
            this.klass = klass;
            this.prefix = prefix;
        }

        public Class getKlass() {
            return klass;
        }

        public String getPrefix() {
            return prefix;
        }

        public static ConfigMappingWithPrefix configMappingWithPrefix(final Class klass, final String prefix) {
            return new ConfigMappingWithPrefix(klass, prefix);
        }
    }
}