Coverage report

  %line %branch
org.apache.commons.configuration.ConfigurationMap$ConfigurationSet$Entry
70% 
100% 

 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.AbstractMap;
 20   
 import java.util.AbstractSet;
 21   
 import java.util.Iterator;
 22   
 import java.util.Map;
 23   
 import java.util.Set;
 24   
 
 25   
 
 26   
 /**
 27   
  * <p>The <code>ConfigurationMap</code> wraps a
 28   
  * configuration-collection
 29   
  * {@link org.apache.commons.configuration.Configuration}
 30   
  * instance to provide a <code>Map</code> interface.</p>
 31   
  *
 32   
  * @todo This implementation is incomplete.
 33   
  *
 34   
  * @author <a href="mailto:ricardo.gladwell@btinternet.com">Ricardo Gladwell</a>
 35   
  */
 36   
 
 37   
 public class ConfigurationMap
 38   
         extends AbstractMap
 39   
 {
 40   
 
 41   
     /**
 42   
      * The <code>Configuration</code> wrapped by this class.
 43   
      */
 44   
     Configuration configuration = null;
 45   
 
 46   
     /**
 47   
      * Creates a new instance of a <code>ConfigurationMap</code>
 48   
      * that wraps the specified <code>Configuration</code>
 49   
      * instance.
 50   
      * @param configuration <code>Configuration</code>
 51   
      * instance.
 52   
      */
 53   
     public ConfigurationMap(Configuration configuration)
 54   
     {
 55   
         this.configuration = configuration;
 56   
     }
 57   
 
 58   
     /**
 59   
      * @see java.util.Map#entrySet()
 60   
      */
 61   
     public Set entrySet()
 62   
     {
 63   
         return new ConfigurationSet(configuration);
 64   
     }
 65   
 
 66   
     /**
 67   
      * @see java.util.Map#put(java.lang.Object, java.lang.Object)
 68   
      */
 69   
     public Object put(Object key, Object value)
 70   
     {
 71   
         String strKey = String.valueOf(key);
 72   
         Object old = configuration.getProperty(strKey);
 73   
         configuration.setProperty(strKey, value);
 74   
         return old;
 75   
     }
 76   
 
 77   
     /**
 78   
      * @see java.util.Map#get(java.lang.Object)
 79   
      */
 80   
     public Object get(Object key)
 81   
     {
 82   
         return configuration.getProperty(String.valueOf(key));
 83   
     }
 84   
 
 85   
     static class ConfigurationSet
 86   
             extends AbstractSet
 87   
     {
 88   
         private Configuration configuration = null;
 89   
 
 90  7 
         private class Entry
 91   
                 implements Map.Entry
 92   
         {
 93  7 
             private Object key = null;
 94   
 
 95   
             private Entry(Object key)
 96  7 
             {
 97  7 
                 this.key = key;
 98  7 
             }
 99   
 
 100   
             public Object getKey()
 101   
             {
 102  56 
                 return key;
 103   
             }
 104   
 
 105   
             public Object getValue()
 106   
             {
 107  7 
                 return configuration.getProperty((String) key);
 108   
             }
 109   
 
 110   
             public Object setValue(Object value)
 111   
             {
 112  0 
                 Object old = getValue();
 113  0 
                 configuration.setProperty((String) key, value);
 114  0 
                 return old;
 115   
             }
 116   
 
 117   
         }
 118   
 
 119   
         private class ConfigurationSetIterator
 120   
                 implements Iterator
 121   
         {
 122   
             private Iterator keys;
 123   
 
 124   
             private ConfigurationSetIterator()
 125   
             {
 126   
                 keys = configuration.getKeys();
 127   
             }
 128   
 
 129   
             public boolean hasNext()
 130   
             {
 131   
                 return keys.hasNext();
 132   
             }
 133   
 
 134   
             public Object next()
 135   
             {
 136   
                 return new Entry(keys.next());
 137   
             }
 138   
 
 139   
             public void remove()
 140   
             {
 141   
                 keys.remove();
 142   
             }
 143   
 
 144   
         }
 145   
 
 146   
         ConfigurationSet(Configuration configuration)
 147   
         {
 148   
             this.configuration = configuration;
 149   
         }
 150   
 
 151   
         /**
 152   
          * @see java.util.Collection#size()
 153   
          */
 154   
         public int size()
 155   
         {
 156   
             // Ouch. Now _that_ one is expensive...
 157   
             int count = 0;
 158   
             for (Iterator iterator = configuration.getKeys(); iterator.hasNext(); )
 159   
             {
 160   
                 iterator.next();
 161   
                 count++;
 162   
             }
 163   
             return count;
 164   
         }
 165   
 
 166   
         /**
 167   
          * @see java.util.Collection#iterator()
 168   
          */
 169   
         public Iterator iterator()
 170   
         {
 171   
             return new ConfigurationSetIterator();
 172   
         }
 173   
     }
 174   
 }

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