Coverage report

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

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

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