Coverage report

  %line %branch
org.apache.commons.configuration.SubsetConfiguration$1
100% 
100% 

 1   
 /*
 2   
  * Copyright 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.Iterator;
 20   
 
 21   
 import org.apache.commons.collections.Transformer;
 22   
 import org.apache.commons.collections.iterators.TransformIterator;
 23   
 
 24   
 /**
 25   
  * A subset of another configuration. The new Configuration object contains
 26   
  * every key from the parent Configuration that starts with prefix. The prefix
 27   
  * is removed from the keys in the subset.
 28   
  *
 29   
  * @see Configuration#subset(String)
 30   
  *
 31   
  * @author Emmanuel Bourg
 32   
  * @version $Revision: 1.6 $, $Date: 2004/10/05 21:17:25 $
 33   
  */
 34   
 public class SubsetConfiguration extends AbstractConfiguration
 35   
 {
 36   
     /** The parent configuration. */
 37   
     protected Configuration parent;
 38   
 
 39   
     /** The prefix used to select the properties. */
 40   
     protected String prefix;
 41   
 
 42   
     /** The prefix delimiter */
 43   
     protected String delimiter;
 44   
 
 45   
     /**
 46   
      * Create a subset of the specified configuration
 47   
      *
 48   
      * @param parent The parent configuration
 49   
      * @param prefix The prefix used to select the properties
 50   
      */
 51   
     public SubsetConfiguration(Configuration parent, String prefix)
 52   
     {
 53   
         this.parent = parent;
 54   
         this.prefix = prefix;
 55   
     }
 56   
 
 57   
     /**
 58   
      * Create a subset of the specified configuration
 59   
      *
 60   
      * @param parent    The parent configuration
 61   
      * @param prefix    The prefix used to select the properties
 62   
      * @param delimiter The prefix delimiter
 63   
      */
 64   
     public SubsetConfiguration(Configuration parent, String prefix, String delimiter)
 65   
     {
 66   
         this.parent = parent;
 67   
         this.prefix = prefix;
 68   
         this.delimiter = delimiter;
 69   
     }
 70   
 
 71   
     /**
 72   
      * Return the key in the parent configuration associated to the specified
 73   
      * key in this subset.
 74   
      *
 75   
      * @param key The key in the subset.
 76   
      */
 77   
     protected String getParentKey(String key)
 78   
     {
 79   
         if ("".equals(key) || key == null)
 80   
         {
 81   
             return prefix;
 82   
         }
 83   
         else
 84   
         {
 85   
             return delimiter == null ? prefix + key : prefix + delimiter + key;
 86   
         }
 87   
     }
 88   
 
 89   
     /**
 90   
      * Return the key in the subset configuration associated to the specified
 91   
      * key in the parent configuration.
 92   
      *
 93   
      * @param key The key in the parent configuration.
 94   
      */
 95   
     protected String getChildKey(String key)
 96   
     {
 97   
         if (!key.startsWith(prefix))
 98   
         {
 99   
             throw new IllegalArgumentException("The parent key '" + key + "' is not in the subset.");
 100   
         }
 101   
         else
 102   
         {
 103   
             String modifiedKey = null;
 104   
             if (key.length() == prefix.length())
 105   
             {
 106   
                 modifiedKey = "";
 107   
             }
 108   
             else
 109   
             {
 110   
                 int i = prefix.length() + (delimiter != null ? delimiter.length() : 0);
 111   
                 modifiedKey = key.substring(i);
 112   
             }
 113   
 
 114   
             return modifiedKey;
 115   
         }
 116   
     }
 117   
 
 118   
     /**
 119   
      * Return the parent configuation for this subset.
 120   
      */
 121   
     public Configuration getParent()
 122   
     {
 123   
         return parent;
 124   
     }
 125   
 
 126   
     /**
 127   
      * Return the prefix used to select the properties in the parent configuration.
 128   
      */
 129   
     public String getPrefix()
 130   
     {
 131   
         return prefix;
 132   
     }
 133   
 
 134   
     /**
 135   
      * Set the prefix used to select the properties in the parent configuration.
 136   
      */
 137   
     public void setPrefix(String prefix)
 138   
     {
 139   
         this.prefix = prefix;
 140   
     }
 141   
 
 142   
     /**
 143   
      * {@inheritDoc}
 144   
      */
 145   
     public Configuration subset(String prefix)
 146   
     {
 147   
         return parent.subset(getParentKey(prefix));
 148   
     }
 149   
 
 150   
     /**
 151   
      * {@inheritDoc}
 152   
      */
 153   
     public boolean isEmpty()
 154   
     {
 155   
         return !getKeys().hasNext();
 156   
     }
 157   
 
 158   
     /**
 159   
      * {@inheritDoc}
 160   
      */
 161   
     public boolean containsKey(String key)
 162   
     {
 163   
         return parent.containsKey(getParentKey(key));
 164   
     }
 165   
 
 166   
     /**
 167   
      * {@inheritDoc}
 168   
      */
 169   
     public void addPropertyDirect(String key, Object value)
 170   
     {
 171   
         parent.addProperty(getParentKey(key), value);
 172   
     }
 173   
 
 174   
     /**
 175   
      * {@inheritDoc}
 176   
      */
 177   
     public void setProperty(String key, Object value)
 178   
     {
 179   
         parent.setProperty(getParentKey(key), value);
 180   
     }
 181   
 
 182   
     /**
 183   
      * {@inheritDoc}
 184   
      */
 185   
     public void clearProperty(String key)
 186   
     {
 187   
         parent.clearProperty(getParentKey(key));
 188   
     }
 189   
 
 190   
     /**
 191   
      * {@inheritDoc}
 192   
      */
 193   
     public Object getPropertyDirect(String key)
 194   
     {
 195   
         return parent.getProperty(getParentKey(key));
 196   
     }
 197   
 
 198   
     /**
 199   
      * {@inheritDoc}
 200   
      */
 201   
     public Iterator getKeys(String prefix)
 202   
     {
 203   
         return new TransformIterator(parent.getKeys(getParentKey(prefix)), class="keyword">new Transformer()
 204   
         {
 205  1 
             public Object transform(Object obj)
 206   
             {
 207  2 
                 return getChildKey((String) obj);
 208   
             }
 209   
         });
 210   
     }
 211   
 
 212   
     /**
 213   
      * {@inheritDoc}
 214   
      */
 215   
     public Iterator getKeys()
 216   
     {
 217   
         return new TransformIterator(parent.getKeys(prefix), class="keyword">new Transformer()
 218   
         {
 219   
             public Object transform(Object obj)
 220   
             {
 221   
                 return getChildKey((String) obj);
 222   
             }
 223   
         });
 224   
     }
 225   
 
 226   
     /**
 227   
      * {@inheritDoc}
 228   
      */
 229   
     protected String interpolate(String base)
 230   
     {
 231   
         if (delimiter == null && "".equals(prefix))
 232   
         {
 233   
             return super.interpolate(base);
 234   
         }
 235   
         else
 236   
         {
 237   
             SubsetConfiguration config = new SubsetConfiguration(parent, "");
 238   
             return config.interpolate(base);
 239   
         }
 240   
     }
 241   
 
 242   
     /**
 243   
      * {@inheritDoc}
 244   
      *
 245   
      * Change the behaviour of the parent configuration if it supports this feature.
 246   
      */
 247   
     public void setThrowExceptionOnMissing(boolean throwExceptionOnMissing)
 248   
     {
 249   
         if (parent instanceof AbstractConfiguration)
 250   
         {
 251   
             ((AbstractConfiguration) parent).setThrowExceptionOnMissing(throwExceptionOnMissing);
 252   
         }
 253   
         else
 254   
         {
 255   
             super.setThrowExceptionOnMissing(throwExceptionOnMissing);
 256   
         }
 257   
     }
 258   
 
 259   
     /**
 260   
      * {@inheritDoc}
 261   
      *
 262   
      * The subset inherits this feature from its parent if it supports this feature.
 263   
      */
 264   
     public boolean isThrowExceptionOnMissing()
 265   
     {
 266   
         if (parent instanceof AbstractConfiguration)
 267   
         {
 268   
             return ((AbstractConfiguration) parent).isThrowExceptionOnMissing();
 269   
         }
 270   
         else
 271   
         {
 272   
             return super.isThrowExceptionOnMissing();
 273   
         }
 274   
     }
 275   
 }

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