/** * Handles a method invocation on the associated builder's configuration * object. * * @param method the method to be invoked * @param args method arguments * @return the return value of the method * @throws Exception if an error occurs */ private Object handleConfigurationInvocation(final Method method, final Object[] args) throws Exception { return method.invoke(builder.getConfiguration(), args); }
@Override public <T extends Event> void addEventListener( final EventType<T> eventType, final EventListener<? super T> listener) { builder.addEventListener(eventType, listener); }
@Override public <T extends Event> boolean removeEventListener( final EventType<T> eventType, final EventListener<? super T> listener) { return builder.removeEventListener(eventType, listener); } }
/** * Returns the configuration containing the definition of the combined * configuration to be created. This method only returns a defined result * during construction of the result configuration. The definition * configuration is obtained from the definition builder at first access and * then stored temporarily to ensure that during result construction always * the same configuration instance is used. (Otherwise, it would be possible * that the definition builder returns a different instance when queried * multiple times.) * * @return the definition configuration * @throws ConfigurationException if an error occurs */ protected HierarchicalConfiguration<?> getDefinitionConfiguration() throws ConfigurationException { if (definitionConfiguration == null) { definitionConfiguration = getDefinitionBuilder().getConfiguration(); } return definitionConfiguration; }
/** * Adds a listener at the given definition builder which resets this builder * when a reset of the definition builder happens. This way it is ensured * that this builder produces a new combined configuration when its * definition configuration changes. * * @param defBuilder the definition builder */ private void addDefinitionBuilderChangeListener( final ConfigurationBuilder<? extends HierarchicalConfiguration<?>> defBuilder) { defBuilder.addEventListener(ConfigurationBuilderEvent.RESET, new EventListener<ConfigurationBuilderEvent>() { @Override public void onEvent(final ConfigurationBuilderEvent event) { synchronized (CombinedConfigurationBuilder.this) { reset(); definitionBuilder = defBuilder; } } }); }
/** * Frees resources used by this object and performs clean up. This * method is called when the owning builder is reset. */ public void cleanUp() { for (final ConfigurationBuilder<?> b : getChildBuilders()) { b.removeEventListener(ConfigurationBuilderEvent.RESET, changeListener); } namedBuilders.clear(); }
/** * Creates a new configuration using the specified builder and adds it * to the resulting combined configuration. * * @param ccResult the resulting combined configuration * @param decl the current {@code ConfigurationDeclaration} * @param builder the configuration builder * @throws ConfigurationException if an error occurs */ private void addChildConfiguration(final CombinedConfiguration ccResult, final ConfigurationDeclaration decl, final ConfigurationBuilder<? extends Configuration> builder) throws ConfigurationException { try { ccResult.addConfiguration( builder.getConfiguration(), decl.getName(), decl.getAt()); } catch (final ConfigurationException cex) { // ignore exceptions for optional configurations if (!decl.isOptional()) { throw cex; } } }
/** * Creates a configuration builder based on a source declaration in the * definition configuration. * * @param decl the current {@code ConfigurationDeclaration} * @return the newly created builder * @throws ConfigurationException if an error occurs */ private ConfigurationBuilder<? extends Configuration> createConfigurationBuilder( final ConfigurationDeclaration decl) throws ConfigurationException { final ConfigurationBuilderProvider provider = providerForTag(decl.getConfiguration().getRootElementName()); if (provider == null) { throw new ConfigurationException( "Unsupported configuration source: " + decl.getConfiguration().getRootElementName()); } final ConfigurationBuilder<? extends Configuration> builder = provider.getConfigurationBuilder(decl); if (decl.getName() != null) { namedBuilders.put(decl.getName(), builder); } allBuilders.add(builder); builder.addEventListener(ConfigurationBuilderEvent.RESET, changeListener); return builder; }
/** * The singleton map os not entirely awesome, but this allows our legacy code to * benefit from live reloads for configuration while the application is running * * @param configFile the path to the config file which should be loaded * @return configuration file */ public static INIConfiguration parseConfig(String configFile) { if (!MAP.containsKey(configFile)) { ReloadingFileBasedConfigurationBuilder<INIConfiguration> builder = new ReloadingFileBasedConfigurationBuilder<>( INIConfiguration.class).configure(new Parameters().properties().setFileName(configFile)); PeriodicReloadingTrigger trigger = new PeriodicReloadingTrigger(builder.getReloadingController(), null, 1, TimeUnit.MINUTES); trigger.start(); MAP.put(configFile, builder); } try { return MAP.get(configFile).getConfiguration(); } catch (ConfigurationException ex) { throw new RuntimeException("Could not read " + configFile); } }