io.helidon.config.ConfigProvider Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of helidon-config Show documentation
Configuration Core module.
The newest version!
/*
 * Copyright (c) 2022, 2024 Oracle and/or its affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package io.helidon.config;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Supplier;

import io.helidon.common.config.Config;
import io.helidon.common.config.ConfigException;
import io.helidon.common.config.ConfigValue;
import io.helidon.common.config.GlobalConfig;
import io.helidon.config.spi.ConfigFilter;
import io.helidon.config.spi.ConfigMapperProvider;
import io.helidon.config.spi.ConfigParser;
import io.helidon.config.spi.ConfigSource;
import io.helidon.service.registry.Service;

@Service.Provider
@Service.ExternalContracts(Config.class)
class ConfigProvider implements Config {
    private final Config config;

    ConfigProvider(Supplier metaConfig,
                   Supplier> configSources,
                   Supplier> configParsers,
                   Supplier> configFilters,
                   Supplier> configMappers) {
        if (GlobalConfig.configured()) {
            config = GlobalConfig.config();
        } else {
            config = io.helidon.config.Config.builder()
                    .config(metaConfig.get().metaConfiguration())
                    .update(it -> configSources.get()
                            .forEach(it::addSource))
                    .disableParserServices()
                    .update(it -> configParsers.get()
                            .forEach(it::addParser))
                    .disableFilterServices()
                    .update(it -> configFilters.get()
                            .forEach(it::addFilter))
                    .disableMapperServices()
                    .update(it -> configMappers.get()
                            .forEach(it::addMapper))
                    .build();
        }
    }

    @Override
    public Key key() {
        return config.key();
    }

    @Override
    public Config root() {
        return config.root();
    }

    @Override
    public Config get(String key) throws ConfigException {
        return config.get(key);
    }

    @Override
    public Config detach() throws ConfigException {
        return config.detach();
    }

    @Override
    public boolean exists() {
        return config.exists();
    }

    @Override
    public boolean isLeaf() {
        return config.isLeaf();
    }

    @Override
    public boolean isObject() {
        return config.isObject();
    }

    @Override
    public boolean isList() {
        return config.isList();
    }

    @Override
    public boolean hasValue() {
        return config.hasValue();
    }

    @Override
    public  ConfigValue as(Class type) {
        return config.as(type);
    }

    @Override
    public  ConfigValue map(Function mapper) {
        return config.map(mapper);
    }

    @Override
    public  ConfigValue> asList(Class type) throws ConfigException {
        return config.asList(type);
    }

    @Override
    public  ConfigValue> mapList(Function mapper) throws ConfigException {
        return config.mapList(mapper);
    }

    @Override
    public  ConfigValue> asNodeList() throws ConfigException {
        return config.asNodeList();
    }

    @Override
    public ConfigValue> asMap() throws ConfigException {
        return config.asMap();
    }
}