Coverage Report - org.apache.commons.configuration.AbstractHierarchicalFileConfiguration
 
Classes in this File Line Coverage Branch Coverage Complexity
AbstractHierarchicalFileConfiguration
96%
94/98
60%
3/5
1,021
AbstractHierarchicalFileConfiguration$FileConfigurationDelegate
100%
7/7
N/A
1,021
 
 1  
 /*
 2  
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3  
  * contributor license agreements.  See the NOTICE file distributed with
 4  
  * this work for additional information regarding copyright ownership.
 5  
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6  
  * (the "License"); you may not use this file except in compliance with
 7  
  * the License.  You may obtain a copy of the License at
 8  
  *
 9  
  *     http://www.apache.org/licenses/LICENSE-2.0
 10  
  *
 11  
  * Unless required by applicable law or agreed to in writing, software
 12  
  * distributed under the License is distributed on an "AS IS" BASIS,
 13  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  * See the License for the specific language governing permissions and
 15  
  * limitations under the License.
 16  
  */
 17  
 
 18  
 package org.apache.commons.configuration;
 19  
 
 20  
 import java.io.Reader;
 21  
 import java.io.Writer;
 22  
 import java.io.File;
 23  
 import java.io.InputStream;
 24  
 import java.io.OutputStream;
 25  
 import java.net.URL;
 26  
 import java.util.Iterator;
 27  
 
 28  
 import org.apache.commons.configuration.event.ConfigurationEvent;
 29  
 import org.apache.commons.configuration.event.ConfigurationListener;
 30  
 import org.apache.commons.configuration.reloading.ReloadingStrategy;
 31  
 
 32  
 /**
 33  
  * <p>Base class for implementing file based hierarchical configurations.</p>
 34  
  * <p>This class serves an analogous purpose as the
 35  
  * <code>{@link AbstractFileConfiguration}</code> class for non hierarchical
 36  
  * configurations. It behaves in exactly the same way, so please refer to the
 37  
  * documentation of <code>AbstractFileConfiguration</code> for further details.</p>
 38  
  *
 39  
  * @since 1.2
 40  
  *
 41  
  * @author Emmanuel Bourg
 42  
  * @version $Revision: 439648 $, $Date: 2006-09-02 22:42:10 +0200 (Sa, 02 Sep 2006) $
 43  
  */
 44  
 public abstract class AbstractHierarchicalFileConfiguration
 45  
 extends HierarchicalConfiguration
 46  
 implements FileConfiguration, ConfigurationListener
 47  
 {
 48  
     /** Stores the delegate used for implementing functionality related to the
 49  
      * <code>FileConfiguration</code> interface.
 50  
      */
 51  
     private FileConfigurationDelegate delegate;
 52  
 
 53  
     protected AbstractHierarchicalFileConfiguration()
 54  412
     {
 55  412
         delegate = createDelegate();
 56  412
         initDelegate(delegate);
 57  412
     }
 58  
 
 59  
     /**
 60  
      * Creates and loads the configuration from the specified file.
 61  
      *
 62  
      * @param fileName The name of the plist file to load.
 63  
      * @throws ConfigurationException Error while loading the file
 64  
      */
 65  
     public AbstractHierarchicalFileConfiguration(String fileName) throws ConfigurationException
 66  
     {
 67  1
         this();
 68  
         // store the file name
 69  1
         delegate.setFileName(fileName);
 70  
 
 71  
         // load the file
 72  1
         load();
 73  1
     }
 74  
 
 75  
     /**
 76  
      * Creates and loads the configuration from the specified file.
 77  
      *
 78  
      * @param file The configuration file to load.
 79  
      * @throws ConfigurationException Error while loading the file
 80  
      */
 81  
     public AbstractHierarchicalFileConfiguration(File file) throws ConfigurationException
 82  
     {
 83  83
         this();
 84  
         // set the file and update the url, the base path and the file name
 85  83
         setFile(file);
 86  
 
 87  
         // load the file
 88  83
         if (file.exists())
 89  
         {
 90  82
             load();
 91  
         }
 92  83
     }
 93  
 
 94  
     /**
 95  
      * Creates and loads the configuration from the specified URL.
 96  
      *
 97  
      * @param url The location of the configuration file to load.
 98  
      * @throws ConfigurationException Error while loading the file
 99  
      */
 100  
     public AbstractHierarchicalFileConfiguration(URL url) throws ConfigurationException
 101  
     {
 102  1
         this();
 103  
         // set the URL and update the base path and the file name
 104  1
         setURL(url);
 105  
 
 106  
         // load the file
 107  1
         load();
 108  1
     }
 109  
 
 110  
     protected void addPropertyDirect(String key, Object obj)
 111  
     {
 112  66
         super.addPropertyDirect(key, obj);
 113  66
         delegate.possiblySave();
 114  66
     }
 115  
 
 116  
     public void clearProperty(String key)
 117  
     {
 118  198
         super.clearProperty(key);
 119  198
         delegate.possiblySave();
 120  198
     }
 121  
 
 122  
     public void clearTree(String key)
 123  
     {
 124  1
         super.clearTree(key);
 125  1
         delegate.possiblySave();
 126  1
     }
 127  
 
 128  
     public void setProperty(String key, Object value)
 129  
     {
 130  20
         super.setProperty(key, value);
 131  20
         delegate.possiblySave();
 132  20
     }
 133  
 
 134  
     public void load() throws ConfigurationException
 135  
     {
 136  240
         delegate.load();
 137  231
     }
 138  
 
 139  
     public void load(String fileName) throws ConfigurationException
 140  
     {
 141  2
         delegate.load(fileName);
 142  2
     }
 143  
 
 144  
     public void load(File file) throws ConfigurationException
 145  
     {
 146  9
         delegate.load(file);
 147  7
     }
 148  
 
 149  
     public void load(URL url) throws ConfigurationException
 150  
     {
 151  3
         delegate.load(url);
 152  3
     }
 153  
 
 154  
     public void load(InputStream in) throws ConfigurationException
 155  
     {
 156  0
         delegate.load(in);
 157  0
     }
 158  
 
 159  
     public void load(InputStream in, String encoding) throws ConfigurationException
 160  
     {
 161  1
         delegate.load(in, encoding);
 162  1
     }
 163  
 
 164  
     public void save() throws ConfigurationException
 165  
     {
 166  2
         delegate.save();
 167  2
     }
 168  
 
 169  
     public void save(String fileName) throws ConfigurationException
 170  
     {
 171  3
         delegate.save(fileName);
 172  3
     }
 173  
 
 174  
     public void save(File file) throws ConfigurationException
 175  
     {
 176  7
         delegate.save(file);
 177  6
     }
 178  
 
 179  
     public void save(URL url) throws ConfigurationException
 180  
     {
 181  1
         delegate.save(url);
 182  1
     }
 183  
 
 184  
     public void save(OutputStream out) throws ConfigurationException
 185  
     {
 186  1
         delegate.save(out);
 187  1
     }
 188  
 
 189  
     public void save(OutputStream out, String encoding) throws ConfigurationException
 190  
     {
 191  1
         delegate.save(out, encoding);
 192  1
     }
 193  
 
 194  
     public String getFileName()
 195  
     {
 196  28
         return delegate.getFileName();
 197  
     }
 198  
 
 199  
     public void setFileName(String fileName)
 200  
     {
 201  104
         delegate.setFileName(fileName);
 202  104
     }
 203  
 
 204  
     public String getBasePath()
 205  
     {
 206  51
         return delegate.getBasePath();
 207  
     }
 208  
 
 209  
     public void setBasePath(String basePath)
 210  
     {
 211  48
         delegate.setBasePath(basePath);
 212  48
     }
 213  
 
 214  
     public File getFile()
 215  
     {
 216  4
         return delegate.getFile();
 217  
     }
 218  
 
 219  
     public void setFile(File file)
 220  
     {
 221  144
         delegate.setFile(file);
 222  144
     }
 223  
 
 224  
     public URL getURL()
 225  
     {
 226  1
         return delegate.getURL();
 227  
     }
 228  
 
 229  
     public void setURL(URL url)
 230  
     {
 231  7
         delegate.setURL(url);
 232  7
     }
 233  
 
 234  
     public void setAutoSave(boolean autoSave)
 235  
     {
 236  1
         delegate.setAutoSave(autoSave);
 237  1
     }
 238  
 
 239  
     public boolean isAutoSave()
 240  
     {
 241  2
         return delegate.isAutoSave();
 242  
     }
 243  
 
 244  
     public ReloadingStrategy getReloadingStrategy()
 245  
     {
 246  3
         return delegate.getReloadingStrategy();
 247  
     }
 248  
 
 249  
     public void setReloadingStrategy(ReloadingStrategy strategy)
 250  
     {
 251  5
         delegate.setReloadingStrategy(strategy);
 252  5
     }
 253  
 
 254  
     public void reload()
 255  
     {
 256  1259
         setDetailEvents(false);
 257  
         try
 258  
         {
 259  1259
             delegate.reload();
 260  1259
         }
 261  
         finally
 262  
         {
 263  0
             setDetailEvents(true);
 264  
         }
 265  1259
     }
 266  
 
 267  
     public String getEncoding()
 268  
     {
 269  24
         return delegate.getEncoding();
 270  
     }
 271  
 
 272  
     public void setEncoding(String encoding)
 273  
     {
 274  3
         delegate.setEncoding(encoding);
 275  3
     }
 276  
 
 277  
     public boolean containsKey(String key)
 278  
     {
 279  349
         reload();
 280  349
         return super.containsKey(key);
 281  
     }
 282  
 
 283  
     public Iterator getKeys(String prefix)
 284  
     {
 285  2
         reload();
 286  2
         return super.getKeys(prefix);
 287  
     }
 288  
 
 289  
     public Object getProperty(String key)
 290  
     {
 291  899
         reload();
 292  899
         return super.getProperty(key);
 293  
     }
 294  
 
 295  
     public boolean isEmpty()
 296  
     {
 297  9
         reload();
 298  9
         return super.isEmpty();
 299  
     }
 300  
 
 301  
     /**
 302  
      * Creates the file configuration delegate, i.e. the object that implements
 303  
      * functionality required by the <code>FileConfiguration</code> interface.
 304  
      * This base implementation will return an instance of the
 305  
      * <code>FileConfigurationDelegate</code> class. Derived classes may
 306  
      * override it to create a different delegate object.
 307  
      *
 308  
      * @return the file configuration delegate
 309  
      */
 310  
     protected FileConfigurationDelegate createDelegate()
 311  
     {
 312  163
         return new FileConfigurationDelegate();
 313  
     }
 314  
 
 315  
     /**
 316  
      * Helper method for initializing the file configuration delegate.
 317  
      *
 318  
      * @param del the delegate
 319  
      */
 320  
     private void initDelegate(FileConfigurationDelegate del)
 321  
     {
 322  412
         del.addConfigurationListener(this);
 323  412
     }
 324  
 
 325  
     /**
 326  
      * Reacts on configuration change events triggered by the delegate. These
 327  
      * events are passed to the registered configuration listeners.
 328  
      *
 329  
      * @param event the triggered event
 330  
      * @since 1.3
 331  
      */
 332  
     public void configurationChanged(ConfigurationEvent event)
 333  
     {
 334  
         // deliver reload events to registered listeners
 335  8
         setDetailEvents(true);
 336  
         try
 337  
         {
 338  8
             fireEvent(event.getType(), event.getPropertyName(), event
 339  
                     .getPropertyValue(), event.isBeforeUpdate());
 340  8
         }
 341  
         finally
 342  
         {
 343  0
             setDetailEvents(false);
 344  
         }
 345  8
     }
 346  
 
 347  
     /**
 348  
      * Returns the file configuration delegate.
 349  
      *
 350  
      * @return the delegate
 351  
      */
 352  
     protected FileConfigurationDelegate getDelegate()
 353  
     {
 354  227
         return delegate;
 355  
     }
 356  
 
 357  
     /**
 358  
      * Allows to set the file configuration delegate.
 359  
      * @param delegate the new delegate
 360  
      */
 361  
     protected void setDelegate(FileConfigurationDelegate delegate)
 362  
     {
 363  1
         this.delegate = delegate;
 364  1
     }
 365  
 
 366  
     /**
 367  
      * A special implementation of the <code>FileConfiguration</code> interface that is
 368  
      * used internally to implement the <code>FileConfiguration</code> methods
 369  
      * for hierarchical configurations.
 370  
      */
 371  413
     protected class FileConfigurationDelegate extends AbstractFileConfiguration
 372  
     {
 373  
         public void load(Reader in) throws ConfigurationException
 374  
         {
 375  27
             AbstractHierarchicalFileConfiguration.this.load(in);
 376  27
         }
 377  
 
 378  
         public void save(Writer out) throws ConfigurationException
 379  
         {
 380  18
             AbstractHierarchicalFileConfiguration.this.save(out);
 381  17
         }
 382  
 
 383  
         public void clear()
 384  
         {
 385  4
             AbstractHierarchicalFileConfiguration.this.clear();
 386  4
         }
 387  
     }
 388  
 }