Java ConfigObject.toConfig方法代碼示例

import com.typesafe.config.ConfigObject; //導入方法依賴的package包/類
public List<ModuleDescription> getRpcModules() {
    if (this.moduleDescriptions != null) {
        return this.moduleDescriptions;
    }

    List<ModuleDescription> modules = new ArrayList<>();

    if (!configFromFiles.hasPath("rpc.modules")) {
        return modules;
    }

    List<? extends ConfigObject> list = configFromFiles.getObjectList("rpc.modules");

    for (ConfigObject configObject : list) {
        Config configElement = configObject.toConfig();
        String name = configElement.getString("name");
        String version = configElement.getString("version");
        boolean enabled = configElement.getBoolean("enabled");
        List<String> enabledMethods = null;
        List<String> disabledMethods = null;

        if (configElement.hasPath("methods.enabled")) {
            enabledMethods = configElement.getStringList("methods.enabled");
        }

        if (configElement.hasPath("methods.disabled")) {
            disabledMethods = configElement.getStringList("methods.disabled");
        }

        modules.add(new ModuleDescription(name, version, enabled, enabledMethods, disabledMethods));
    }

    this.moduleDescriptions = modules;

    return modules;
}
 

import com.typesafe.config.ConfigObject; //導入方法依賴的package包/類
/**
 * Get the instruments from a configuration object.
 *
 * @param config a configuration object
 * @param path the path expression
 * @return the instruments
 * @throws ConfigException if a configuration error occurs
 */
public static Instruments fromConfig(Config config, String path) {
    ConfigObject root = config.getObject(path);

    Config rootConfig = root.toConfig();

    int priceIntegerDigits = getInt(rootConfig, "price-integer-digits", 1);
    int sizeIntegerDigits  = getInt(rootConfig, "size-integer-digits",  1);

    Set<String> instruments = root.keySet();

    instruments.remove("price-integer-digits");
    instruments.remove("size-integer-digits");

    List<Instrument> values = new ArrayList<>();

    for (String instrument : instruments)
        values.add(Instrument.fromConfig(rootConfig, instrument));

    int maxPriceFractionDigits = max(values, Instrument::getPriceFractionDigits);
    int maxSizeFractionDigits  = max(values, Instrument::getSizeFractionDigits);

    for (Instrument value : values) {
        value.setPriceFormat(priceIntegerDigits, maxPriceFractionDigits);
        value.setSizeFormat(sizeIntegerDigits, maxSizeFractionDigits);
    }

    return new Instruments(values, priceIntegerDigits, maxPriceFractionDigits,
            sizeIntegerDigits, maxSizeFractionDigits);
}
 

import com.typesafe.config.ConfigObject; //導入方法依賴的package包/類
private void groupPanels() {

        Config config = Lookup.getConfig();
        ConfigObject groups = config.getObject("vars.query.column.groups");
        Config groupsConfig = groups.toConfig();

        List<AbstractValuePanel> vps = new ArrayList<>(valuePanels);
        List<AbstractValuePanel> used = new ArrayList<>();

        Set<String> groupNames = groups.keySet();
        for (String name : groupNames) {
            formLayout.addHeader(name);
            List<String> columns = groupsConfig.getStringList(name);
            List<AbstractValuePanel> matchingVps = vps.stream()
                    .filter(vp -> columns.contains(vp.getValueName()))
                    .sorted((vp1, vp2) ->
                            vp1.getValueName().toUpperCase().compareTo(vp2.getValueName().toUpperCase()))
                    .collect(Collectors.toList());

            matchingVps.stream().forEach(vp ->
                        formLayout.add(new EditorFormRow<>(vp.getTitle(), vp)));

            used.addAll(matchingVps);
        }

        vps.removeAll(used);
        if (!vps.isEmpty()) {
            formLayout.addHeader("Other");
            vps.stream().forEach(vp -> formLayout.add(new EditorFormRow<>(vp.getTitle(), vp)));
        }

    }
 

import com.typesafe.config.ConfigObject; //導入方法依賴的package包/類
public static BenchmarkPlan parseConfiguration(String configurationFile) throws InvalidConfigurationException {
    try {
        Config config = ConfigFactory.parseFile(new File(configurationFile));
        ConfigObject elasticsearchConfig = config.getObject("elasticsearch");
        List<? extends ConfigObject> stepsConfig = config.getObjectList("steps");

        ObjectMapper objectMapper = new ObjectMapper();

        // Parse elasticsearch configuration
        ElasticsearchConfiguration esConfig = objectMapper.convertValue(elasticsearchConfig.unwrapped(), ElasticsearchConfiguration.class);
        esConfig.validateConfig();

        // Build initial benchmark plan
        BenchmarkPlan benchmarkPlan = new BenchmarkPlan(esConfig);

        for (ConfigObject currConfigObject: stepsConfig) {

            Config currConfig = currConfigObject.toConfig();

            long duration = currConfig.getDuration("duration").toMillis();
            BenchmarkStep step = new BenchmarkStep(duration);

            if (currConfig.hasPath("indexing")) {
                IndexingConfiguration indexingConfig = objectMapper.convertValue(currConfig.getObject("indexing").unwrapped(), IndexingConfiguration.class);
                indexingConfig.validateConfig();
                step.addController(new IndexingController(indexingConfig, benchmarkPlan.getEsController()));
            }

            if (currConfig.hasPath("search")) {
                SearchConfiguration searchConfig = objectMapper.convertValue(currConfig.getObject("search").unwrapped(), SearchConfiguration.class);
                searchConfig.validateConfig();
                step.addController(new SearchController(searchConfig, benchmarkPlan.getEsController()));
            }

            if (currConfig.hasPath("optimize")) {
                OptimizeConfiguration optimizeConfig = objectMapper.convertValue(currConfig.getObject("optimize").unwrapped(), OptimizeConfiguration.class);
                optimizeConfig.validateConfig();
                step.addController(new OptimizeController(optimizeConfig, benchmarkPlan.getEsController()));
            }

            if (currConfig.hasPath("noop")) {
                step.addController(new NoopController());
            }

            // Adding the final step
            benchmarkPlan.addStep(step);
        }

        return benchmarkPlan;

    } catch (ConfigException e) {
        throw new RuntimeException("Could not parse configuration file!", e);
    }
}
 

import com.typesafe.config.ConfigObject; //導入方法依賴的package包/類
public CodableClassInfo(@Nonnull Class<?> clazz,
                        @Nonnull Config globalDefaults,
                        @Nonnull PluginRegistry pluginRegistry) {

    // skip native classes
    if (Fields.isNative(clazz) || clazz.isArray()) {
        classData = ImmutableSortedMap.of();
        baseClass = clazz;
        pluginMap = PluginMap.EMPTY;
        fieldDefaults = ConfigFactory.empty();
        return;
    }

    // find any parent class (or itself) with a Pluggable annotation
    Class<?> findBaseClass = clazz;
    PluginMap findPluginMap = PluginMap.EMPTY;

    Class<?> ptr = clazz;
    while (ptr != null) {
        if (pluginRegistry.byClass().containsKey(ptr)) {
            findPluginMap = pluginRegistry.byClass().get(ptr);
            findBaseClass = ptr;
            break;
        }
        Pluggable pluggable = ptr.getAnnotation(Pluggable.class);
        if (pluggable != null) {
            String category = pluggable.value();
            findPluginMap = pluginRegistry.asMap().get(category);
            findBaseClass = ptr;
            if (findPluginMap == null) {
                log.warn("missing plugin map for {}, reached from {}", ptr, clazz);
                findPluginMap = PluginMap.EMPTY;
            }
            break;
        }
        ptr = ptr.getSuperclass();
    }
    pluginMap = findPluginMap;
    baseClass = findBaseClass;

    // find all fields in the class and its parent classes, and aggregate any defaults
    Map<String, Field> fields = new HashMap<>();
    // slower than using unwrapped, mutable conversions but this preserves origins
    ConfigObject buildDefaults = ConfigFactory.empty().root();

    Class<?> ptrForFields = clazz;
    while (ptrForFields != null) {
        String canonicalClassName = ptrForFields.getCanonicalName();
        ConfigObject classDefaults;
        if ((canonicalClassName != null) && globalDefaults.hasPath(canonicalClassName)) {
            classDefaults = globalDefaults.getObject(canonicalClassName);
        } else {
            classDefaults = ConfigFactory.empty().root();
        }
        for (Field field : ptrForFields.getDeclaredFields()) {
            if (fields.get(field.getName()) == null) {
                fields.put(field.getName(), field);
            } else {
                classDefaults = classDefaults.withoutKey(field.getName());
                log.debug("({}) ignoring field in parent class ({}) with duplicate name ({})",
                          clazz, ptrForFields, field.getName());
            }
        }
        for (Map.Entry<String, ConfigValue> pair : classDefaults.entrySet()) {
            if (!buildDefaults.containsKey(pair.getKey())) {
                buildDefaults = buildDefaults.withValue(pair.getKey(), pair.getValue());
            }
        }
        ptrForFields = ptrForFields.getSuperclass();
    }
    fieldDefaults = buildDefaults.toConfig();

    // turn all the found fields into CodableFieldInfo objects
    Map<String, CodableFieldInfo> buildClassData = buildFieldInfoMap(fields.values());
    classData = ImmutableSortedMap.<String, CodableFieldInfo>naturalOrder()
                                  .putAll(buildClassData).build();
}