%line	%branch
org.apache.commons.configuration.CompositeConfiguration	98%	98%

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.ArrayList;
20		import java.util.Iterator;
21		import java.util.LinkedList;
22		import java.util.List;
23		import java.util.Vector;
24
25		/**
26		* This Configuration class allows you to add multiple different types of Configuration
27		* to this CompositeConfiguration. If you add Configuration1, and then Configuration2,
28		* any properties shared will mean that Configuration1 will be returned.
29		* You can add multiple different types or the same type of properties file.
30		* If Configuration1 doesn't have the property, then Configuration2 will be checked.
31		*
32		* @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
33		* @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
34		* @version $Id: CompositeConfiguration.java,v 1.19 2004/10/05 22:56:58 ebourg Exp $
35		*/
36		public class CompositeConfiguration extends AbstractConfiguration
37		{
38		/** List holding all the configuration */
39	98	private List configList = new LinkedList();
40
41		/**
42		* Configuration that holds in memory stuff. Inserted as first so any
43		* setProperty() override anything else added.
44		*/
45		private Configuration inMemoryConfiguration;
46
47		/**
48		* Creates an empty CompositeConfiguration object which can then
49		* be added some other Configuration files
50		*/
51		public CompositeConfiguration()
52	94	{
53	94	clear();
54	94	}
55
56		/**
57		* Creates an CompositeConfiguration object with a specified InMemory
58		* configuration. This configuration will store any changes made to
59		* the CompositeConfiguration.
60		*
61		* @param inMemoryConfiguration the in memory configuration to use
62		*/
63		public CompositeConfiguration(Configuration inMemoryConfiguration)
64	4	{
65	4	configList.clear();
66	4	this.inMemoryConfiguration = inMemoryConfiguration;
67	4	configList.add(inMemoryConfiguration);
68	4	}
69
70		/**
71		* Add a configuration.
72		*
73		* @param config the configuration to add
74		*/
75		public void addConfiguration(Configuration config)
76		{
77	131	if (!configList.contains(config))
78		{
79		// As the inMemoryConfiguration contains all manually added keys,
80		// we must make sure that it is always last. "Normal", non composed
81		// configuration add their keys at the end of the configuration and
82		// we want to mimic this behaviour.
83	129	configList.add(configList.indexOf(inMemoryConfiguration), config);
84
85	129	if (config instanceof AbstractConfiguration)
86		{
87	129	((AbstractConfiguration) config).setThrowExceptionOnMissing(isThrowExceptionOnMissing());
88		}
89		}
90	131	}
91
92		/**
93		* Remove a configuration. The in memory configuration cannot be removed.
94		*
95		* @param config The configuration to remove
96		*/
97		public void removeConfiguration(Configuration config)
98		{
99		// Make sure that you can't remove the inMemoryConfiguration from
100		// the CompositeConfiguration object
101	4	if (!config.equals(inMemoryConfiguration))
102		{
103	2	configList.remove(config);
104		}
105	4	}
106
107		/**
108		* Return the number of configurations.
109		*
110		* @return the number of configuration
111		*/
112		public int getNumberOfConfigurations()
113		{
114	21	return configList.size();
115		}
116
117		/**
118		* Remove all configuration reinitialize the in memory configuration.
119		*/
120		public void clear()
121		{
122	102	configList.clear();
123		// recreate the in memory configuration
124	102	inMemoryConfiguration = new BaseConfiguration();
125	102	((BaseConfiguration) inMemoryConfiguration).setThrowExceptionOnMissing(isThrowExceptionOnMissing());
126	102	configList.add(inMemoryConfiguration);
127	102	}
128
129		/**
130		* Add this property to the inmemory Configuration.
131		*
132		* @param key The Key to add the property to.
133		* @param token The Value to add.
134		*/
135		protected void addPropertyDirect(String key, Object token)
136		{
137	22	inMemoryConfiguration.addProperty(key, token);
138	22	}
139
140		/**
141		* Read property from underlying composite
142		*
143		* @param key key to use for mapping
144		*
145		* @return object associated with the given configuration key.
146		*/
147		protected Object getPropertyDirect(String key)
148		{
149	118	Configuration firstMatchingConfiguration = null;
150	118	for (Iterator i = configList.iterator(); i.hasNext();)
151		{
152	181	Configuration config = (Configuration) i.next();
153	181	if (config.containsKey(key))
154		{
155	93	firstMatchingConfiguration = config;
156	93	break;
157		}
158		}
159
160	118	if (firstMatchingConfiguration != null)
161		{
162	93	return firstMatchingConfiguration.getProperty(key);
163		}
164		else
165		{
166	25	return null;
167		}
168		}
169
170		/**
171		* {@inheritDoc}
172		*/
173		public Iterator getKeys()
174		{
175	12	List keys = new ArrayList();
176	12	for (Iterator i = configList.iterator(); i.hasNext();)
177		{
178	22	Configuration config = (Configuration) i.next();
179
180	22	Iterator j = config.getKeys();
181	126	while (j.hasNext())
182		{
183	104	String key = (String) j.next();
184	104	if (!keys.contains(key))
185		{
186	103	keys.add(key);
187		}
188		}
189		}
190
191	12	return keys.iterator();
192		}
193
194		/**
195		* {@inheritDoc}
196		*/
197		public Iterator getKeys(String key)
198		{
199	7	List keys = new ArrayList();
200	7	for (Iterator i = configList.iterator(); i.hasNext();)
201		{
202	16	Configuration config = (Configuration) i.next();
203
204	16	Iterator j = config.getKeys(key);
205	149	while (j.hasNext())
206		{
207	133	String newKey = (String) j.next();
208	133	if (!keys.contains(newKey))
209		{
210	131	keys.add(newKey);
211		}
212		}
213		}
214
215	7	return keys.iterator();
216		}
217
218		/**
219		* {@inheritDoc}
220		*/
221		public boolean isEmpty()
222		{
223	4	boolean isEmpty = true;
224	4	for (Iterator i = configList.iterator(); i.hasNext();)
225		{
226	4	Configuration config = (Configuration) i.next();
227	4	if (!config.isEmpty())
228		{
229	4	return false;
230		}
231		}
232
233	0	return isEmpty;
234		}
235
236		/**
237		* {@inheritDoc}
238		*/
239		public Object getProperty(String key)
240		{
241	37	return getPropertyDirect(key);
242		}
243
244		/**
245		* {@inheritDoc}
246		*/
247		public void setProperty(String key, Object value)
248		{
249	8	clearProperty(key);
250	8	addProperty(key, value);
251	8	}
252
253		/**
254		* {@inheritDoc}
255		*/
256		public void clearProperty(String key)
257		{
258	14	for (Iterator i = configList.iterator(); i.hasNext();)
259		{
260	32	Configuration config = (Configuration) i.next();
261	32	config.clearProperty(key);
262		}
263	14	}
264
265		/**
266		* {@inheritDoc}
267		*/
268		public boolean containsKey(String key)
269		{
270	53	for (Iterator i = configList.iterator(); i.hasNext();)
271		{
272	67	Configuration config = (Configuration) i.next();
273	67	if (config.containsKey(key))
274		{
275	44	return true;
276		}
277		}
278	9	return false;
279		}
280
281		/**
282		* {@inheritDoc}
283		*/
284		public List getList(String key, List defaultValue)
285		{
286	71	List list = new ArrayList();
287
288		// add all elements from the first configuration containing the requested key
289	71	Iterator it = configList.iterator();
290	162	while (it.hasNext() && list.isEmpty())
291		{
292	91	Configuration config = (Configuration) it.next();
293	91	if (config != inMemoryConfiguration && config.containsKey(key))
294		{
295	56	list.addAll(config.getList(key));
296		}
297		}
298
299		// add all elements from the in memory configuration
300	71	list.addAll(inMemoryConfiguration.getList(key));
301
302	71	if (list.isEmpty())
303		{
304	8	return defaultValue;
305		}
306
307	63	return list;
308		}
309
310		/**
311		* {@inheritDoc}
312		*/
313		public Vector getVector(String key, Vector defaultValue)
314		{
315	27	return new Vector(getList(key, defaultValue));
316		}
317
318		/**
319		* {@inheritDoc}
320		*/
321		public String[] getStringArray(String key)
322		{
323	13	List list = getList(key);
324
325		// interpolate the strings
326	13	String[] tokens = new String[list.size()];
327
328	33	for (int i = 0; i < tokens.length; i++)
329		{
330	20	tokens[i] = interpolate(String.valueOf(list.get(i)));
331		}
332
333	13	return tokens;
334		}
335
336		/**
337		* Return the configuration at the specified index.
338		*
339		* @param index The index of the configuration to retrieve
340		*/
341		public Configuration getConfiguration(int index)
342		{
343	14	return (Configuration) configList.get(index);
344		}
345
346		/**
347		* {@inheritDoc}
348		*/
349		public Configuration getInMemoryConfiguration()
350		{
351	0	return inMemoryConfiguration;
352		}
353		}

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.