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.ArrayList;
21  import java.util.Iterator;
22  import java.util.List;
23  import java.util.Map;
24  
25  /***
26   * A Map based Configuration.
27   *
28   * @author Emmanuel Bourg
29   * @version $Revision: 439648 $, $Date: 2006-09-02 22:42:10 +0200 (Sa, 02 Sep 2006) $
30   * @since 1.1
31   */
32  public class MapConfiguration extends AbstractConfiguration implements Cloneable
33  {
34      /*** The Map decorated by this configuration. */
35      protected Map map;
36  
37      /***
38       * Create a Configuration decorator around the specified Map. The map is
39       * used to store the configuration properties, any change will also affect
40       * the Map.
41       *
42       * @param map the map
43       */
44      public MapConfiguration(Map map)
45      {
46          this.map = map;
47      }
48  
49      /***
50       * Return the Map decorated by this configuration.
51       *
52       * @return the map this configuration is based onto
53       */
54      public Map getMap()
55      {
56          return map;
57      }
58  
59      public Object getProperty(String key)
60      {
61          Object value = map.get(key);
62          if ((value instanceof String) && (!isDelimiterParsingDisabled()))
63          {
64              List list = PropertyConverter.split((String) value, getListDelimiter());
65              return list.size() > 1 ? list : value;
66          }
67          else
68          {
69              return value;
70          }
71      }
72  
73      protected void addPropertyDirect(String key, Object value)
74      {
75          Object previousValue = getProperty(key);
76  
77          if (previousValue == null)
78          {
79              map.put(key, value);
80          }
81          else if (previousValue instanceof List)
82          {
83              // the value is added to the existing list
84              ((List) previousValue).add(value);
85          }
86          else
87          {
88              // the previous value is replaced by a list containing the previous value and the new value
89              List list = new ArrayList();
90              list.add(previousValue);
91              list.add(value);
92  
93              map.put(key, list);
94          }
95      }
96  
97      public boolean isEmpty()
98      {
99          return map.isEmpty();
100     }
101 
102     public boolean containsKey(String key)
103     {
104         return map.containsKey(key);
105     }
106 
107     protected void clearPropertyDirect(String key)
108     {
109         map.remove(key);
110     }
111 
112     public Iterator getKeys()
113     {
114         return map.keySet().iterator();
115     }
116 
117     /***
118      * Returns a copy of this object. The returned configuration will contain
119      * the same properties as the original. Event listeners are not cloned.
120      *
121      * @return the copy
122      * @since 1.3
123      */
124     public Object clone()
125     {
126         try
127         {
128             MapConfiguration copy = (MapConfiguration) super.clone();
129             copy.clearConfigurationListeners();
130             copy.map = (Map) ConfigurationUtils.clone(map);
131             return copy;
132         }
133         catch (CloneNotSupportedException cex)
134         {
135             // cannot happen
136             throw new ConfigurationRuntimeException(cex);
137         }
138     }
139 }