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  import org.apache.commons.collections.map.LinkedMap;
26  
27  /***
28   * Basic configuration classe. Stores the configuration data but does not
29   * provide any load or save functions. If you want to load your Configuration
30   * from a file use PropertiesConfiguration or XmlConfiguration.
31   *
32   * This class extends normal Java properties by adding the possibility
33   * to use the same key many times concatenating the value strings
34   * instead of overwriting them.
35   *
36   * @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a>
37   * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
38   * @author <a href="mailto:daveb@miceda-data">Dave Bryson</a>
39   * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
40   * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
41   * @author <a href="mailto:kjohnson@transparent.com">Kent Johnson</a>
42   * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
43   * @author <a href="mailto:ipriha@surfeu.fi">Ilkka Priha</a>
44   * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
45   * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
46   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
47   * @author <a href="mailto:ksh@scand.com">Konstantin Shaposhnikov</a>
48   * @author <a href="mailto:oliver.heger@t-online.de">Oliver Heger</a>
49   * @version $Id: BaseConfiguration.java 439648 2006-09-02 20:42:10Z oheger $
50   */
51  public class BaseConfiguration extends AbstractConfiguration implements Cloneable
52  {
53      /*** stores the configuration key-value pairs */
54      private Map store = new LinkedMap();
55  
56      /***
57       * Adds a key/value pair to the map.  This routine does no magic morphing.
58       * It ensures the keylist is maintained
59       *
60       * @param key key to use for mapping
61       * @param value object to store
62       */
63      protected void addPropertyDirect(String key, Object value)
64      {
65          Object previousValue = getProperty(key);
66  
67          if (previousValue == null)
68          {
69              store.put(key, value);
70          }
71          else if (previousValue instanceof List)
72          {
73              // the value is added to the existing list
74              ((List) previousValue).add(value);
75          }
76          else
77          {
78              // the previous value is replaced by a list containing the previous value and the new value
79              List list = new ArrayList();
80              list.add(previousValue);
81              list.add(value);
82  
83              store.put(key, list);
84          }
85      }
86  
87      /***
88       * Read property from underlying map.
89       *
90       * @param key key to use for mapping
91       *
92       * @return object associated with the given configuration key.
93       */
94      public Object getProperty(String key)
95      {
96          return store.get(key);
97      }
98  
99      /***
100      * Check if the configuration is empty
101      *
102      * @return <code>true</code> if Configuration is empty,
103      * <code>false</code> otherwise.
104      */
105     public boolean isEmpty()
106     {
107         return store.isEmpty();
108     }
109 
110     /***
111      * check if the configuration contains the key
112      *
113      * @param key the configuration key
114      *
115      * @return <code>true</code> if Configuration contain given key,
116      * <code>false</code> otherwise.
117      */
118     public boolean containsKey(String key)
119     {
120         return store.containsKey(key);
121     }
122 
123     /***
124      * Clear a property in the configuration.
125      *
126      * @param key the key to remove along with corresponding value.
127      */
128     protected void clearPropertyDirect(String key)
129     {
130         if (containsKey(key))
131         {
132             store.remove(key);
133         }
134     }
135 
136     /***
137      * {@inheritDoc}
138      */
139     public void clear()
140     {
141         fireEvent(EVENT_CLEAR, null, null, true);
142         store.clear();
143         fireEvent(EVENT_CLEAR, null, null, false);
144     }
145 
146     /***
147      * Get the list of the keys contained in the configuration
148      * repository.
149      *
150      * @return An Iterator.
151      */
152     public Iterator getKeys()
153     {
154         return store.keySet().iterator();
155     }
156 
157     /***
158      * Creates a copy of this object. This implementation will create a deep
159      * clone, i.e. the map that stores the properties is cloned, too. So changes
160      * performed at the copy won't affect the original and vice versa.
161      *
162      * @return the copy
163      * @since 1.3
164      */
165     public Object clone()
166     {
167         try
168         {
169             BaseConfiguration copy = (BaseConfiguration) super.clone();
170             copy.store = (Map) ConfigurationUtils.clone(store);
171             copy.clearConfigurationListeners();
172             return copy;
173         }
174         catch (CloneNotSupportedException cex)
175         {
176             // should not happen
177             throw new ConfigurationRuntimeException(cex);
178         }
179     }
180 }