Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.commons.configuration; import java.io.File; import java.io.InputStream; import java.io.OutputStream; import java.io.Reader; import java.io.Writer; import java.net.URL; import java.util.Collection; import java.util.Iterator; import java.util.List; import org.apache.commons.configuration.event.ConfigurationEvent; import org.apache.commons.configuration.event.ConfigurationListener; import org.apache.commons.configuration.reloading.ReloadingStrategy; /** * <p>Base class for implementing file based hierarchical configurations.</p> * <p>This class serves an analogous purpose as the * <code>{@link AbstractFileConfiguration}</code> class for non hierarchical * configurations. It behaves in exactly the same way, so please refer to the * documentation of <code>AbstractFileConfiguration</code> for further details.</p> * * @since 1.2 * * @author Emmanuel Bourg * @version $Revision: 712405 $, $Date: 2008-11-08 17:37:48 +0100 (Sa, 08 Nov 2008) $ */ public abstract class AbstractHierarchicalFileConfiguration extends HierarchicalConfiguration implements FileConfiguration, ConfigurationListener { /** Stores the delegate used for implementing functionality related to the * <code>FileConfiguration</code> interface. */ private FileConfigurationDelegate delegate; /** * Creates a new instance of * <code>AbstractHierarchicalFileConfiguration</code>. */ protected AbstractHierarchicalFileConfiguration() { initialize(); } /** * Creates a new instance of * <code>AbstractHierarchicalFileConfiguration</code> and copies the * content of the specified configuration into this object. * * @param c the configuration to copy * @since 1.4 */ protected AbstractHierarchicalFileConfiguration(HierarchicalConfiguration c) { super(c); initialize(); } /** * Creates and loads the configuration from the specified file. * * @param fileName The name of the plist file to load. * @throws ConfigurationException Error while loading the file */ public AbstractHierarchicalFileConfiguration(String fileName) throws ConfigurationException { this(); // store the file name delegate.setFileName(fileName); // load the file load(); } /** * Creates and loads the configuration from the specified file. * * @param file The configuration file to load. * @throws ConfigurationException Error while loading the file */ public AbstractHierarchicalFileConfiguration(File file) throws ConfigurationException { this(); // set the file and update the url, the base path and the file name setFile(file); // load the file if (file.exists()) { load(); } } /** * Creates and loads the configuration from the specified URL. * * @param url The location of the configuration file to load. * @throws ConfigurationException Error while loading the file */ public AbstractHierarchicalFileConfiguration(URL url) throws ConfigurationException { this(); // set the URL and update the base path and the file name setURL(url); // load the file load(); } /** * Initializes this instance, mainly the internally used delegate object. */ private void initialize() { delegate = createDelegate(); initDelegate(delegate); } protected void addPropertyDirect(String key, Object obj) { super.addPropertyDirect(key, obj); delegate.possiblySave(); } public void clearProperty(String key) { super.clearProperty(key); delegate.possiblySave(); } public void clearTree(String key) { super.clearTree(key); delegate.possiblySave(); } public void setProperty(String key, Object value) { super.setProperty(key, value); delegate.possiblySave(); } public void load() throws ConfigurationException { delegate.load(); } public void load(String fileName) throws ConfigurationException { delegate.load(fileName); } public void load(File file) throws ConfigurationException { delegate.load(file); } public void load(URL url) throws ConfigurationException { delegate.load(url); } public void load(InputStream in) throws ConfigurationException { delegate.load(in); } public void load(InputStream in, String encoding) throws ConfigurationException { delegate.load(in, encoding); } public void save() throws ConfigurationException { delegate.save(); } public void save(String fileName) throws ConfigurationException { delegate.save(fileName); } public void save(File file) throws ConfigurationException { delegate.save(file); } public void save(URL url) throws ConfigurationException { delegate.save(url); } public void save(OutputStream out) throws ConfigurationException { delegate.save(out); } public void save(OutputStream out, String encoding) throws ConfigurationException { delegate.save(out, encoding); } public String getFileName() { return delegate.getFileName(); } public void setFileName(String fileName) { delegate.setFileName(fileName); } public String getBasePath() { return delegate.getBasePath(); } public void setBasePath(String basePath) { delegate.setBasePath(basePath); } public File getFile() { return delegate.getFile(); } public void setFile(File file) { delegate.setFile(file); } public URL getURL() { return delegate.getURL(); } public void setURL(URL url) { delegate.setURL(url); } public void setAutoSave(boolean autoSave) { delegate.setAutoSave(autoSave); } public boolean isAutoSave() { return delegate.isAutoSave(); } public ReloadingStrategy getReloadingStrategy() { return delegate.getReloadingStrategy(); } public void setReloadingStrategy(ReloadingStrategy strategy) { delegate.setReloadingStrategy(strategy); } public void reload() { setDetailEvents(false); try { delegate.reload(); } finally { setDetailEvents(true); } } public String getEncoding() { return delegate.getEncoding(); } public void setEncoding(String encoding) { delegate.setEncoding(encoding); } public boolean containsKey(String key) { reload(); return super.containsKey(key); } public Iterator getKeys() { reload(); return super.getKeys(); } public Iterator getKeys(String prefix) { reload(); return super.getKeys(prefix); } public Object getProperty(String key) { reload(); return super.getProperty(key); } public boolean isEmpty() { reload(); return super.isEmpty(); } /** * Directly adds sub nodes to this configuration. This implementation checks * whether auto save is necessary after executing the operation. * * @param key the key where the nodes are to be added * @param nodes a collection with the nodes to be added * @since 1.5 */ public void addNodes(String key, Collection nodes) { super.addNodes(key, nodes); delegate.possiblySave(); } /** * Fetches a list of nodes, which are selected by the specified key. This * implementation will perform a reload if necessary. * * @param key the key * @return a list with the selected nodes */ protected List fetchNodeList(String key) { reload(); return super.fetchNodeList(key); } /** * Reacts on changes of an associated subnode configuration. If the auto * save mechanism is active, the configuration must be saved. * * @param event the event describing the change * @since 1.5 */ protected void subnodeConfigurationChanged(ConfigurationEvent event) { delegate.possiblySave(); super.subnodeConfigurationChanged(event); } /** * Creates the file configuration delegate, i.e. the object that implements * functionality required by the <code>FileConfiguration</code> interface. * This base implementation will return an instance of the * <code>FileConfigurationDelegate</code> class. Derived classes may * override it to create a different delegate object. * * @return the file configuration delegate */ protected FileConfigurationDelegate createDelegate() { return new FileConfigurationDelegate(); } /** * Helper method for initializing the file configuration delegate. * * @param del the delegate */ private void initDelegate(FileConfigurationDelegate del) { del.addConfigurationListener(this); } /** * Reacts on configuration change events triggered by the delegate. These * events are passed to the registered configuration listeners. * * @param event the triggered event * @since 1.3 */ public void configurationChanged(ConfigurationEvent event) { // deliver reload events to registered listeners setDetailEvents(true); try { fireEvent(event.getType(), event.getPropertyName(), event.getPropertyValue(), event.isBeforeUpdate()); } finally { setDetailEvents(false); } } /** * Returns the file configuration delegate. * * @return the delegate */ protected FileConfigurationDelegate getDelegate() { return delegate; } /** * Allows to set the file configuration delegate. * @param delegate the new delegate */ protected void setDelegate(FileConfigurationDelegate delegate) { this.delegate = delegate; } /** * A special implementation of the <code>FileConfiguration</code> interface that is * used internally to implement the <code>FileConfiguration</code> methods * for hierarchical configurations. */ protected class FileConfigurationDelegate extends AbstractFileConfiguration { public void load(Reader in) throws ConfigurationException { AbstractHierarchicalFileConfiguration.this.load(in); } public void save(Writer out) throws ConfigurationException { AbstractHierarchicalFileConfiguration.this.save(out); } public void clear() { AbstractHierarchicalFileConfiguration.this.clear(); } } }