/** * Returns a configuration with the same content as this configuration, but * with all variables replaced by their actual values. This method tries to * clone the configuration and then perform interpolation on all properties. * So property values of the form <code>${var}</code> will be resolved as * far as possible (if a variable cannot be resolved, it remains unchanged). * This operation is useful if the content of a configuration is to be * exported or processed by an external component that does not support * variable interpolation. * * @return a configuration with all variables interpolated * @throws org.apache.commons.configuration2.ex.ConfigurationRuntimeException if this * configuration cannot be cloned * @since 1.5 */ public Configuration interpolatedConfiguration() { // first clone this configuration final AbstractConfiguration c = (AbstractConfiguration) ConfigurationUtils .cloneConfiguration(this); // now perform interpolation c.setListDelimiterHandler(new DisabledListDelimiterHandler()); for (final Iterator<String> it = getKeys(); it.hasNext();) { final String key = it.next(); c.setProperty(key, getList(key)); } c.setListDelimiterHandler(getListDelimiterHandler()); return c; }
setDetailEvents(false); boolean useIterator = true; try final Iterator<String> it = getKeys(); while (it.hasNext()) if (useIterator && containsKey(key)) clearProperty(key); setDetailEvents(true);
@Override public boolean getBoolean(final String key, final boolean defaultValue) { return getBoolean(key, Boolean.valueOf(defaultValue)).booleanValue(); }
/** * {@inheritDoc} This implementation ensures that the in memory * configuration is correctly initialized. */ @Override public void setListDelimiterHandler( final ListDelimiterHandler listDelimiterHandler) { if (inMemoryConfiguration instanceof AbstractConfiguration) { ((AbstractConfiguration) inMemoryConfiguration) .setListDelimiterHandler(listDelimiterHandler); } super.setListDelimiterHandler(listDelimiterHandler); }
/** * {@inheritDoc} This implementation delegates to {@link #getString(String)} * in order to obtain the value of the passed in key. This value is passed * to the decoder. Because {@code getString()} is used behind the scenes all * standard features like handling of missing keys and interpolation work as * expected. */ @Override public String getEncodedString(final String key, final ConfigurationDecoder decoder) { if (decoder == null) { throw new IllegalArgumentException( "ConfigurationDecoder must not be null!"); } final String value = getString(key); return (value != null) ? decoder.decode(value) : null; }
public boolean enabledWorloadBalancing() { boolean result = false; if (clusterConfiguration.containsKey(ENABLE_WORLOAD_BALANCING)) { result = clusterConfiguration.getBoolean(ENABLE_WORLOAD_BALANCING); } return result; }
protected static Map<String, String> configurationToMap(AbstractConfiguration configuration) { Iterator<String> keysIterator = configuration.getKeys(); Map<String, String> result = new HashMap<>(); while (keysIterator.hasNext()) { String key = keysIterator.next(); result.put(key, configuration.getString(key)); } return result; }
import org.apache.logging.log4j.core.LoggerContext; import org.apache.logging.log4j.core.config.AbstractConfiguration; ... public static void changeLoggerLevel(final String module, final Level level) { String moduleRenamed = module.replaceAll("/", "."); LoggerContext ctx = (LoggerContext)LogManager.getContext(false); AbstractConfiguration configuration = (AbstractConfiguration) ctx .getConfiguration(); if (configuration.getLogger(moduleRenamed) != null) { LoggerConfig loggerConfig = configuration.getLoggerConfig(moduleRenamed); loggerConfig.setLevel(level); } else { LoggerConfig loggerConfig = new LoggerConfig(moduleRenamed, level, true); configuration.addLogger(moduleRenamed, loggerConfig); } ctx.updateLoggers(configuration); }
@Override public double getDouble(final String key, final double defaultValue) { return getDouble(key, Double.valueOf(defaultValue)).doubleValue(); }
@Override public int getInt(final String key, final int defaultValue) { return getInteger(key, Integer.valueOf(defaultValue)).intValue(); }
@Override public long getLong(final String key, final long defaultValue) { return getLong(key, Long.valueOf(defaultValue)).longValue(); }
@Override public void onEvent(final ConfigurationErrorEvent event) { getLogger().warn("Internal error", event.getCause()); } });
/** * {@inheritDoc} If the parent configuration extends * {@link AbstractConfiguration}, the list delimiter handler is passed to * the parent. */ @Override public void setListDelimiterHandler( final ListDelimiterHandler listDelimiterHandler) { if (parent instanceof AbstractConfiguration) { ((AbstractConfiguration) parent) .setListDelimiterHandler(listDelimiterHandler); } else { super.setListDelimiterHandler(listDelimiterHandler); } }
public String getNotificationPager() { return clusterConfiguration.getString(NOTIFICATION_PAGER, ""); } }
public boolean enabledDeadbrokerReplacement() { boolean result = false; if (clusterConfiguration.containsKey(BROKER_REPLACEMENT_ENABLE)) { result = clusterConfiguration.getBoolean(BROKER_REPLACEMENT_ENABLE); } return result; }
public double getNetworkInLimitInMb() { return clusterConfiguration.getDouble(NETWORK_IN_LIMIT_MB); }
public int getUnderReplicatedAlertTimeInSeconds() { return clusterConfiguration.getInteger(UNDER_REPLICTED_ALERT_IN_SECS, DEFAULT_UNDER_REPLICTED_ALERT_IN_SECS); }
public long getRestartIntervalInSeconds() { return drkafkaConfiguration.getLong(RESTART_INTERVAL_SECONDS); }
((AbstractConfiguration)configuration).setListDelimiterHandler(new DefaultListDelimiterHandler(config.listDelimiter));
public String getDoctorKafkaZkurl() { return drkafkaConfiguration.getString(DOCTORKAFKA_ZKURL); }