Coverage report

  %line %branch
org.apache.commons.configuration.CompositeConfiguration
98% 
94% 

 1  
 /*
 2  
  * Copyright 2001-2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License")
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *     http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 
 17  
 package org.apache.commons.configuration;
 18  
 
 19  
 import java.util.ArrayList;
 20  
 import java.util.Iterator;
 21  
 import java.util.LinkedList;
 22  
 import java.util.List;
 23  
 
 24  
 /**
 25  
  * This Configuration class allows you to add multiple different types of Configuration
 26  
  * to this CompositeConfiguration.  If you add Configuration1, and then Configuration2,
 27  
  * any properties shared will mean that Configuration1 will be returned.
 28  
  * You can add multiple different types or the same type of properties file.
 29  
  * If Configuration1 doesn't have the property, then Configuration2 will be checked.
 30  
  *
 31  
  * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
 32  
  * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
 33  
  * @version $Id: CompositeConfiguration.java 155408 2005-02-26 12:56:39Z dirkv $
 34  
  */
 35  
 public class CompositeConfiguration extends AbstractConfiguration
 36  
 {
 37  
     /** List holding all the configuration */
 38  2337
     private List configList = new LinkedList();
 39  
 
 40  
     /**
 41  
      * Configuration that holds in memory stuff.  Inserted as first so any
 42  
      * setProperty() override anything else added.
 43  
      */
 44  
     private Configuration inMemoryConfiguration;
 45  
 
 46  
     /**
 47  
      * Creates an empty CompositeConfiguration object which can then
 48  
      * be added some other Configuration files
 49  
      */
 50  
     public CompositeConfiguration()
 51  2245
     {
 52  2245
         clear();
 53  2245
     }
 54  
 
 55  
     /**
 56  
      * Creates an CompositeConfiguration object with a specified InMemory
 57  
      * configuration. This configuration will store any changes made to
 58  
      * the CompositeConfiguration.
 59  
      *
 60  
      * @param inMemoryConfiguration the in memory configuration to use
 61  
      */
 62  
     public CompositeConfiguration(Configuration inMemoryConfiguration)
 63  92
     {
 64  92
         configList.clear();
 65  92
         this.inMemoryConfiguration = inMemoryConfiguration;
 66  92
         configList.add(inMemoryConfiguration);
 67  92
     }
 68  
 
 69  
     /**
 70  
      * Add a configuration.
 71  
      *
 72  
      * @param config the configuration to add
 73  
      */
 74  
     public void addConfiguration(Configuration config)
 75  
     {
 76  3211
         if (!configList.contains(config))
 77  
         {
 78  
             // As the inMemoryConfiguration contains all manually added keys,
 79  
             // we must make sure that it is always last. "Normal", non composed
 80  
             // configuration add their keys at the end of the configuration and
 81  
             // we want to mimic this behaviour.
 82  3165
             configList.add(configList.indexOf(inMemoryConfiguration), config);
 83  
 
 84  3165
             if (config instanceof AbstractConfiguration)
 85  
             {
 86  3165
                 ((AbstractConfiguration) config).setThrowExceptionOnMissing(isThrowExceptionOnMissing());
 87  
             }
 88  
         }
 89  3211
     }
 90  
 
 91  
     /**
 92  
      * Remove a configuration. The in memory configuration cannot be removed.
 93  
      *
 94  
      * @param config The configuration to remove
 95  
      */
 96  
     public void removeConfiguration(Configuration config)
 97  
     {
 98  
         // Make sure that you can't remove the inMemoryConfiguration from
 99  
         // the CompositeConfiguration object
 100  92
         if (!config.equals(inMemoryConfiguration))
 101  
         {
 102  46
             configList.remove(config);
 103  
         }
 104  92
     }
 105  
 
 106  
     /**
 107  
      * Return the number of configurations.
 108  
      *
 109  
      * @return the number of configuration
 110  
      */
 111  
     public int getNumberOfConfigurations()
 112  
     {
 113  483
         return configList.size();
 114  
     }
 115  
 
 116  
     /**
 117  
      * Remove all configuration reinitialize the in memory configuration.
 118  
      */
 119  
     public void clear()
 120  
     {
 121  2429
         configList.clear();
 122  
         // recreate the in memory configuration
 123  2429
         inMemoryConfiguration = new BaseConfiguration();
 124  2429
         ((BaseConfiguration) inMemoryConfiguration).setThrowExceptionOnMissing(isThrowExceptionOnMissing());
 125  2429
         configList.add(inMemoryConfiguration);
 126  2429
     }
 127  
 
 128  
     /**
 129  
      * Add this property to the inmemory Configuration.
 130  
      *
 131  
      * @param key The Key to add the property to.
 132  
      * @param token The Value to add.
 133  
      */
 134  
     protected void addPropertyDirect(String key, Object token)
 135  
     {
 136  483
         inMemoryConfiguration.addProperty(key, token);
 137  483
     }
 138  
 
 139  
     /**
 140  
      * Read property from underlying composite
 141  
      *
 142  
      * @param key key to use for mapping
 143  
      *
 144  
      * @return object associated with the given configuration key.
 145  
      */
 146  
     public Object getProperty(String key)
 147  
     {
 148  2820
         Configuration firstMatchingConfiguration = null;
 149  2820
         for (Iterator i = configList.iterator(); i.hasNext();)
 150  
         {
 151  4292
             Configuration config = (Configuration) i.next();
 152  4292
             if (config.containsKey(key))
 153  
             {
 154  2245
                 firstMatchingConfiguration = config;
 155  2245
                 break;
 156  
             }
 157  
         }
 158  
 
 159  2820
         if (firstMatchingConfiguration != null)
 160  
         {
 161  2245
             return firstMatchingConfiguration.getProperty(key);
 162  
         }
 163  
         else
 164  
         {
 165  575
             return null;
 166  
         }
 167  
     }
 168  
 
 169  
     /**
 170  
      * {@inheritDoc}
 171  
      */
 172  
     public Iterator getKeys()
 173  
     {
 174  276
         List keys = new ArrayList();
 175  276
         for (Iterator i = configList.iterator(); i.hasNext();)
 176  
         {
 177  506
             Configuration config = (Configuration) i.next();
 178  
 
 179  506
             Iterator j = config.getKeys();
 180  2898
             while (j.hasNext())
 181  
             {
 182  2392
                 String key = (String) j.next();
 183  2392
                 if (!keys.contains(key))
 184  
                 {
 185  2369
                     keys.add(key);
 186  
                 }
 187  
             }
 188  
         }
 189  
 
 190  276
         return keys.iterator();
 191  
     }
 192  
 
 193  
     /**
 194  
      * {@inheritDoc}
 195  
      */
 196  
     public Iterator getKeys(String key)
 197  
     {
 198  207
         List keys = new ArrayList();
 199  207
         for (Iterator i = configList.iterator(); i.hasNext();)
 200  
         {
 201  506
             Configuration config = (Configuration) i.next();
 202  
 
 203  506
             Iterator j = config.getKeys(key);
 204  3703
             while (j.hasNext())
 205  
             {
 206  3197
                 String newKey = (String) j.next();
 207  3197
                 if (!keys.contains(newKey))
 208  
                 {
 209  3151
                     keys.add(newKey);
 210  
                 }
 211  
             }
 212  
         }
 213  
 
 214  207
         return keys.iterator();
 215  
     }
 216  
 
 217  
     /**
 218  
      * {@inheritDoc}
 219  
      */
 220  
     public boolean isEmpty()
 221  
     {
 222  115
         boolean isEmpty = true;
 223  115
         for (Iterator i = configList.iterator(); i.hasNext();)
 224  
         {
 225  115
             Configuration config = (Configuration) i.next();
 226  115
             if (!config.isEmpty())
 227  
             {
 228  115
                 return false;
 229  
             }
 230  
         }
 231  
 
 232  0
         return isEmpty;
 233  
     }
 234  
 
 235  
     /**
 236  
      * {@inheritDoc}
 237  
      */
 238  
     public void clearProperty(String key)
 239  
     {
 240  322
         for (Iterator i = configList.iterator(); i.hasNext();)
 241  
         {
 242  736
             Configuration config = (Configuration) i.next();
 243  736
             config.clearProperty(key);
 244  
         }
 245  322
     }
 246  
 
 247  
     /**
 248  
      * {@inheritDoc}
 249  
      */
 250  
     public boolean containsKey(String key)
 251  
     {
 252  1219
         for (Iterator i = configList.iterator(); i.hasNext();)
 253  
         {
 254  1541
             Configuration config = (Configuration) i.next();
 255  1541
             if (config.containsKey(key))
 256  
             {
 257  1012
                 return true;
 258  
             }
 259  
         }
 260  207
         return false;
 261  
     }
 262  
 
 263  
     /**
 264  
      * {@inheritDoc}
 265  
      */
 266  
     public List getList(String key, List defaultValue)
 267  
     {
 268  989
         List list = new ArrayList();
 269  
 
 270  
         // add all elements from the first configuration containing the requested key
 271  989
         Iterator it = configList.iterator();
 272  2323
         while (it.hasNext() && list.isEmpty())
 273  
         {
 274  1334
             Configuration config = (Configuration) it.next();
 275  1334
             if (config != inMemoryConfiguration && config.containsKey(key))
 276  
             {
 277  713
                 list.addAll(config.getList(key));
 278  
             }
 279  
         }
 280  
 
 281  
         // add all elements from the in memory configuration
 282  989
         list.addAll(inMemoryConfiguration.getList(key));
 283  
 
 284  989
         if (list.isEmpty())
 285  
         {
 286  115
             return defaultValue;
 287  
         }
 288  
 
 289  874
         return list;
 290  
     }
 291  
 
 292  
     /**
 293  
      * {@inheritDoc}
 294  
      */
 295  
     public String[] getStringArray(String key)
 296  
     {
 297  299
         List list = getList(key);
 298  
 
 299  
         // interpolate the strings
 300  299
         String[] tokens = new String[list.size()];
 301  
 
 302  759
         for (int i = 0; i < tokens.length; i++)
 303  
         {
 304  460
             tokens[i] = interpolate(String.valueOf(list.get(i)));
 305  
         }
 306  
 
 307  299
         return tokens;
 308  
     }
 309  
 
 310  
     /**
 311  
      * Return the configuration at the specified index.
 312  
      *
 313  
      * @param index The index of the configuration to retrieve
 314  
      */
 315  
     public Configuration getConfiguration(int index)
 316  
     {
 317  368
         return (Configuration) configList.get(index);
 318  
     }
 319  
 
 320  
     /**
 321  
      * {@inheritDoc}
 322  
      */
 323  
     public Configuration getInMemoryConfiguration()
 324  
     {
 325  0
         return inMemoryConfiguration;
 326  
     }
 327  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.