View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.configuration;
19  
20  import java.util.AbstractMap;
21  import java.util.AbstractSet;
22  import java.util.Iterator;
23  import java.util.Map;
24  import java.util.Set;
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   * <p><em>Note:</em> This implementation is incomplete.</p>
33   *
34   * @author <a href="mailto:ricardo.gladwell@btinternet.com">Ricardo Gladwell</a>
35   * @version $Revision: 439648 $, $Date: 2006-09-02 22:42:10 +0200 (Sa, 02 Sep 2006) $
36   * @since 1.0
37   */
38  public class ConfigurationMap extends AbstractMap
39  {
40      /***
41       * The <code>Configuration</code> wrapped by this class.
42       */
43      private Configuration configuration;
44  
45      /***
46       * Creates a new instance of a <code>ConfigurationMap</code>
47       * that wraps the specified <code>Configuration</code>
48       * instance.
49       * @param configuration <code>Configuration</code>
50       * instance.
51       */
52      public ConfigurationMap(Configuration configuration)
53      {
54          this.configuration = configuration;
55      }
56  
57      /***
58       * Returns the wrapped <code>Configuration</code> object.
59       *
60       * @return the wrapped configuration
61       * @since 1.2
62       */
63      public Configuration getConfiguration()
64      {
65          return configuration;
66      }
67  
68      /***
69       * @see java.util.Map#entrySet()
70       */
71      public Set entrySet()
72      {
73          return new ConfigurationSet(configuration);
74      }
75  
76      /***
77       * @see java.util.Map#put(java.lang.Object, java.lang.Object)
78       */
79      public Object put(Object key, Object value)
80      {
81          String strKey = String.valueOf(key);
82          Object old = configuration.getProperty(strKey);
83          configuration.setProperty(strKey, value);
84          return old;
85      }
86  
87      /***
88       * @see java.util.Map#get(java.lang.Object)
89       */
90      public Object get(Object key)
91      {
92          return configuration.getProperty(String.valueOf(key));
93      }
94  
95      /***
96       * Set of entries in the map.
97       */
98      static class ConfigurationSet extends AbstractSet
99      {
100         /*** The configuration mapped to this entry set. */
101         private Configuration configuration;
102 
103         /***
104          * A Map entry in the ConfigurationMap.
105          */
106         private final class Entry implements Map.Entry
107         {
108             /*** The key of the map entry. */
109             private Object key;
110 
111             private Entry(Object key)
112             {
113                 this.key = key;
114             }
115 
116             public Object getKey()
117             {
118                 return key;
119             }
120 
121             public Object getValue()
122             {
123                 return configuration.getProperty((String) key);
124             }
125 
126             public Object setValue(Object value)
127             {
128                 Object old = getValue();
129                 configuration.setProperty((String) key, value);
130                 return old;
131             }
132         }
133 
134         /***
135          * Iterator over the entries in the ConfigurationMap.
136          */
137         private final class ConfigurationSetIterator implements Iterator
138         {
139             /*** An iterator over the keys in the configuration. */
140             private Iterator keys;
141 
142             private ConfigurationSetIterator()
143             {
144                 keys = configuration.getKeys();
145             }
146 
147             public boolean hasNext()
148             {
149                 return keys.hasNext();
150             }
151 
152             public Object next()
153             {
154                 return new Entry(keys.next());
155             }
156 
157             public void remove()
158             {
159                 keys.remove();
160             }
161         }
162 
163         ConfigurationSet(Configuration configuration)
164         {
165             this.configuration = configuration;
166         }
167 
168         /***
169          * @see java.util.Collection#size()
170          */
171         public int size()
172         {
173             // Ouch. Now _that_ one is expensive...
174             int count = 0;
175             for (Iterator iterator = configuration.getKeys(); iterator.hasNext();)
176             {
177                 iterator.next();
178                 count++;
179             }
180             return count;
181         }
182 
183         /***
184          * @see java.util.Collection#iterator()
185          */
186         public Iterator iterator()
187         {
188             return new ConfigurationSetIterator();
189         }
190     }
191 }