View Javadoc

    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          private class Entry
    91                  implements Map.Entry
    92          {
    93              private Object key = null;
    94
    95              private Entry(Object key)
    96              {
    97                  this.key = key;
    98              }
    99
    100             public Object getKey()
    101             {
    102                 return key;
    103             }
    104
    105             public Object getValue()
    106             {
    107                 return configuration.getProperty((String) key);
    108             }
    109
    110             public Object setValue(Object value)
    111             {
    112                 Object old = getValue();
    113                 configuration.setProperty((String) key, value);
    114                 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 }