001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    
018    package org.apache.commons.configuration;
019    
020    import java.util.ArrayList;
021    import java.util.Collection;
022    import java.util.Iterator;
023    import java.util.LinkedHashMap;
024    import java.util.List;
025    import java.util.Map;
026    
027    /**
028     * Basic configuration class. Stores the configuration data but does not
029     * provide any load or save functions. If you want to load your Configuration
030     * from a file use PropertiesConfiguration or XmlConfiguration.
031     *
032     * This class extends normal Java properties by adding the possibility
033     * to use the same key many times concatenating the value strings
034     * instead of overwriting them.
035     *
036     * @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a>
037     * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
038     * @author <a href="mailto:daveb@miceda-data">Dave Bryson</a>
039     * @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
040     * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
041     * @author <a href="mailto:kjohnson@transparent.com">Kent Johnson</a>
042     * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
043     * @author <a href="mailto:ipriha@surfeu.fi">Ilkka Priha</a>
044     * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
045     * @author <a href="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
046     * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
047     * @author <a href="mailto:ksh@scand.com">Konstantin Shaposhnikov</a>
048     * @version $Id: BaseConfiguration.java 1231721 2012-01-15 18:32:07Z oheger $
049     */
050    public class BaseConfiguration extends AbstractConfiguration implements Cloneable
051    {
052        /** stores the configuration key-value pairs */
053        private Map<String, Object> store = new LinkedHashMap<String, Object>();
054    
055        /**
056         * Adds a key/value pair to the map.  This routine does no magic morphing.
057         * It ensures the keylist is maintained
058         *
059         * @param key key to use for mapping
060         * @param value object to store
061         */
062        @Override
063        protected void addPropertyDirect(String key, Object value)
064        {
065            Object previousValue = getProperty(key);
066    
067            if (previousValue == null)
068            {
069                store.put(key, value);
070            }
071            else if (previousValue instanceof List)
072            {
073                // safe to case because we have created the lists ourselves
074                @SuppressWarnings("unchecked")
075                List<Object> valueList = (List<Object>) previousValue;
076                // the value is added to the existing list
077                valueList.add(value);
078            }
079            else
080            {
081                // the previous value is replaced by a list containing the previous value and the new value
082                List<Object> list = new ArrayList<Object>();
083                list.add(previousValue);
084                list.add(value);
085    
086                store.put(key, list);
087            }
088        }
089    
090        /**
091         * Read property from underlying map.
092         *
093         * @param key key to use for mapping
094         *
095         * @return object associated with the given configuration key.
096         */
097        public Object getProperty(String key)
098        {
099            return store.get(key);
100        }
101    
102        /**
103         * Check if the configuration is empty
104         *
105         * @return {@code true} if Configuration is empty,
106         * {@code false} otherwise.
107         */
108        public boolean isEmpty()
109        {
110            return store.isEmpty();
111        }
112    
113        /**
114         * check if the configuration contains the key
115         *
116         * @param key the configuration key
117         *
118         * @return {@code true} if Configuration contain given key,
119         * {@code false} otherwise.
120         */
121        public boolean containsKey(String key)
122        {
123            return store.containsKey(key);
124        }
125    
126        /**
127         * Clear a property in the configuration.
128         *
129         * @param key the key to remove along with corresponding value.
130         */
131        @Override
132        protected void clearPropertyDirect(String key)
133        {
134            if (containsKey(key))
135            {
136                store.remove(key);
137            }
138        }
139    
140        @Override
141        public void clear()
142        {
143            fireEvent(EVENT_CLEAR, null, null, true);
144            store.clear();
145            fireEvent(EVENT_CLEAR, null, null, false);
146        }
147    
148        /**
149         * Get the list of the keys contained in the configuration
150         * repository.
151         *
152         * @return An Iterator.
153         */
154        public Iterator<String> getKeys()
155        {
156            return store.keySet().iterator();
157        }
158    
159        /**
160         * Creates a copy of this object. This implementation will create a deep
161         * clone, i.e. the map that stores the properties is cloned, too. So changes
162         * performed at the copy won't affect the original and vice versa.
163         *
164         * @return the copy
165         * @since 1.3
166         */
167        @Override
168        public Object clone()
169        {
170            try
171            {
172                BaseConfiguration copy = (BaseConfiguration) super.clone();
173                // This is safe because the type of the map is known
174                @SuppressWarnings("unchecked")
175                Map<String, Object> clonedStore = (Map<String, Object>) ConfigurationUtils.clone(store);
176                copy.store = clonedStore;
177    
178                // Handle collections in the map; they have to be cloned, too
179                for (Map.Entry<String, Object> e : store.entrySet())
180                {
181                    if (e.getValue() instanceof Collection)
182                    {
183                        // This is safe because the collections were created by ourselves
184                        @SuppressWarnings("unchecked")
185                        Collection<String> strList = (Collection<String>) e.getValue();
186                        copy.store.put(e.getKey(), new ArrayList<String>(strList));
187                    }
188                }
189    
190                return copy;
191            }
192            catch (CloneNotSupportedException cex)
193            {
194                // should not happen
195                throw new ConfigurationRuntimeException(cex);
196            }
197        }
198    }