%line	%branch
org.apache.commons.configuration.DataConfiguration	85%	99%

1		/*
2		* Copyright 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.awt.Color;
20		import java.math.BigDecimal;
21		import java.math.BigInteger;
22		import java.net.URL;
23		import java.util.ArrayList;
24		import java.util.Calendar;
25		import java.util.Collection;
26		import java.util.Date;
27		import java.util.Iterator;
28		import java.util.List;
29		import java.util.Locale;
30
31		import org.apache.commons.collections.CollectionUtils;
32		import org.apache.commons.lang.ArrayUtils;
33		import org.apache.commons.lang.StringUtils;
34
35		/**
36		* Decorator providing additional getters for any Configuration. This extended
37		* Configuration supports more types: URL, Locale, Date, Calendar, Color, as
38		* well as lists and arrays for all types.
39		*
40		* <p>Let us know if you find this useful, the most frequently used getters
41		* are likely to be integrated in the Configuration interface in a future
42		* version.</p>
43		*
44		* @author <a href="ebourg@apache.org">Emmanuel Bourg</a>
45		* @version $Revision: 155408 $, $Date: 2005-02-26 13:56:39 +0100 (Sa, 26 Feb 2005) $
46		* @since 1.1
47		*/
48		public class DataConfiguration extends AbstractConfiguration
49		{
50		/** The key of the property storing the user defined date format. */
51		public static final String DATE_FORMAT_KEY = "org.apache.commons.configuration.format.date";
52
53		/** The default format for dates. */
54		public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
55
56		protected Configuration configuration;
57
58	204	public DataConfiguration(Configuration configuration)
59	782	{
60	782	this.configuration = configuration;
61	578	}
62
63		/**
64		* Return the configuration decorated by this DataConfiguration.
65		*/
66		public Configuration getConfiguration()
67		{
68	0	return configuration;
69		}
70
71		public Object getProperty(String key)
72	2298	{
73	7070	return configuration.getProperty(key);
74		}
75
76		protected void addPropertyDirect(String key, Object obj)
77	38220	{
78	147088	configuration.addProperty(key, obj);
79	108868	}
80
81		public boolean isEmpty()
82		{
83	0	return configuration.isEmpty();
84		}
85
86		public boolean containsKey(String key)
87		{
88	0	return configuration.containsKey(key);
89		}
90
91		public void clearProperty(String key)
92	264	{
93	1012	configuration.clearProperty(key);
94	748	}
95
96		public Iterator getKeys()
97		{
98	0	return configuration.getKeys();
99		}
100
101		/**
102		* Get a list of Boolean objects associated with the given
103		* configuration key. If the key doesn't map to an existing object
104		* an empty list is returned.
105		*
106		* @param key The configuration key.
107		* @return The associated Boolean list if the key is found.
108		*
109		* @throws ConversionException is thrown if the key maps to an
110		* object that is not a list of booleans.
111		*/
112		public List getBooleanList(String key)
113	60	{
114	187	return getBooleanList(key, new ArrayList());
115		}
116
117		/**
118		* Get a list of Boolean objects associated with the given
119		* configuration key. If the key doesn't map to an existing object,
120		* the default value is returned.
121		*
122		* @param key The configuration key.
123		* @param defaultValue The default value.
124		* @return The associated List of strings.
125		*
126		* @throws ConversionException is thrown if the key maps to an
127		* object that is not a list of booleans.
128		*/
129		public List getBooleanList(String key, List defaultValue)
130	66	{
131	204	Object value = getProperty(key);
132	66
133	204	List list = null;
134	66
135	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
136	6	{
137	34	list = defaultValue;
138	60	}
139	170	else if (value instanceof boolean[])
140		{
141	0	list = new ArrayList();
142	0	CollectionUtils.addAll(list, ArrayUtils.toObject((boolean[]) value));
143	60	}
144	170	else if (value instanceof Boolean[])
145		{
146	0	list = new ArrayList();
147	0	CollectionUtils.addAll(list, (Boolean[]) value);
148	60	}
149	170	else if (value instanceof Collection)
150	36	{
151	138	Collection values = (Collection) value;
152	102	list = new ArrayList();
153	36
154	210	Iterator it = values.iterator();
155	306	while (it.hasNext())
156	72	{
157	204	list.add(PropertyConverter.toBoolean(it.next()));
158		}
159		}
160		else
161		{
162		try
163		{
164	24	// attempt to convert a single value
165	92	list = new ArrayList();
166	68	list.add(PropertyConverter.toBoolean(value));
167	12	}
168	34	catch (ConversionException e)
169	12	{
170	46	throw new ConversionException('\'' + key + "' doesn't map to a list of booleans", e);
171	34	}
172		}
173	54
174	170	return list;
175		}
176
177		/**
178		* Get an array of boolean primitives associated with the given
179		* configuration key. If the key doesn't map to an existing object
180		* an empty array is returned.
181		*
182		* @param key The configuration key.
183		* @return The associated boolean array if the key is found.
184		*
185		* @throws ConversionException is thrown if the key maps to an
186		* object that is not a list of booleans.
187		*/
188		public boolean[] getBooleanArray(String key)
189	60	{
190	187	return getBooleanArray(key, new boolean[0]);
191		}
192
193		/**
194		* Get an array of boolean primitives associated with the given
195		* configuration key. If the key doesn't map to an existing object,
196		* the default value is returned.
197		*
198		* @param key The configuration key.
199		* @param defaultValue The default value.
200		* @return The associated boolean array if the key is found.
201		*
202		* @throws ConversionException is thrown if the key maps to an
203		* object that is not a list of booleans.
204		*/
205		public boolean[] getBooleanArray(String key, class="keyword">boolean[] defaultValue)
206	66	{
207	204	Object value = getProperty(key);
208
209		boolean[] array;
210	66
211	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
212	6	{
213	34	array = defaultValue;
214	60	}
215	170	else if (value instanceof boolean[])
216		{
217	0	array = (boolean[]) value;
218	60	}
219	170	else if (value instanceof Boolean[])
220		{
221	0	array = ArrayUtils.toPrimitive((Boolean[]) value);
222	60	}
223	170	else if (value instanceof Collection)
224	36	{
225	138	Collection values = (Collection) value;
226	102	array = new boolean[values.size()];
227	36
228	138	int i = 0;
229	210	Iterator it = values.iterator();
230	306	while (it.hasNext())
231	72	{
232	204	array[i++] = PropertyConverter.toBoolean(it.next()).booleanValue();
233		}
234		}
235		else
236		{
237		try
238		{
239	24	// attempt to convert a single value
240	92	array = new boolean[1];
241	68	array[0] = PropertyConverter.toBoolean(value).booleanValue();
242	12	}
243	34	catch (ConversionException e)
244	12	{
245	46	throw new ConversionException('\'' + key + "' doesn't map to a list of booleans", e);
246	34	}
247		}
248	54
249	170	return array;
250		}
251
252		/**
253		* Get a list of Byte objects associated with the given configuration key.
254		* If the key doesn't map to an existing object an empty list is returned.
255		*
256		* @param key The configuration key.
257		* @return The associated Byte list if the key is found.
258		*
259		* @throws ConversionException is thrown if the key maps to an
260		* object that is not a list of bytes.
261		*/
262		public List getByteList(String key)
263	60	{
264	187	return getByteList(key, new ArrayList());
265		}
266
267		/**
268		* Get a list of Byte objects associated with the given configuration key.
269		* If the key doesn't map to an existing object, the default value is
270		* returned.
271		*
272		* @param key The configuration key.
273		* @param defaultValue The default value.
274		* @return The associated List of Bytes.
275		*
276		* @throws ConversionException is thrown if the key maps to an
277		* object that is not a list of bytes.
278		*/
279		public List getByteList(String key, List defaultValue)
280	66	{
281	204	Object value = getProperty(key);
282	66
283	204	List list = null;
284	66
285	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
286	6	{
287	34	list = defaultValue;
288	60	}
289	170	else if (value instanceof byte[])
290		{
291	0	list = new ArrayList();
292	0	CollectionUtils.addAll(list, ArrayUtils.toObject((byte[]) value));
293	60	}
294	170	else if (value instanceof Byte[])
295		{
296	0	list = new ArrayList();
297	0	CollectionUtils.addAll(list, (Byte[]) value);
298	60	}
299	170	else if (value instanceof Collection)
300	36	{
301	138	Collection values = (Collection) value;
302	102	list = new ArrayList();
303	36
304	210	Iterator it = values.iterator();
305	306	while (it.hasNext())
306	72	{
307	204	list.add(PropertyConverter.toByte(it.next()));
308		}
309		}
310		else
311		{
312		try
313		{
314	24	// attempt to convert a single value
315	92	list = new ArrayList();
316	68	list.add(PropertyConverter.toByte(value));
317	12	}
318	34	catch (ConversionException e)
319	12	{
320	46	throw new ConversionException('\'' + key + "' doesn't map to a list of bytes", e);
321	34	}
322		}
323	54
324	170	return list;
325		}
326
327		/**
328		* Get an array of byte primitives associated with the given
329		* configuration key. If the key doesn't map to an existing object
330		* an empty array is returned.
331		*
332		* @param key The configuration key.
333		* @return The associated byte array if the key is found.
334		*
335		* @throws ConversionException is thrown if the key maps to an
336		* object that is not a list of bytes.
337		*/
338		public byte[] getByteArray(String key)
339	60	{
340	187	return getByteArray(key, new byte[0]);
341		}
342
343		/**
344		* Get an array of byte primitives associated with the given
345		* configuration key. If the key doesn't map to an existing object
346		* an empty array is returned.
347		*
348		* @param key The configuration key.
349		* @return The associated byte array if the key is found.
350		*
351		* @throws ConversionException is thrown if the key maps to an
352		* object that is not a list of bytes.
353		*/
354		public byte[] getByteArray(String key, byte[] defaultValue)
355	66	{
356	204	Object value = getProperty(key);
357
358		byte[] array;
359	66
360	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
361	6	{
362	34	array = defaultValue;
363	60	}
364	170	else if (value instanceof byte[])
365		{
366	0	array = (byte[]) value;
367	60	}
368	170	else if (value instanceof Byte[])
369		{
370	0	array = ArrayUtils.toPrimitive((Byte[]) value);
371	60	}
372	170	else if (value instanceof Collection)
373	36	{
374	138	Collection values = (Collection) value;
375	102	array = new byte[values.size()];
376	36
377	138	int i = 0;
378	210	Iterator it = values.iterator();
379	306	while (it.hasNext())
380	72	{
381	204	array[i++] = PropertyConverter.toByte(it.next()).byteValue();
382		}
383		}
384		else
385		{
386		try
387		{
388	24	// attempt to convert a single value
389	92	array = new byte[1];
390	68	array[0] = PropertyConverter.toByte(value).byteValue();
391	12	}
392	34	catch (ConversionException e)
393	12	{
394	46	throw new ConversionException('\'' + key + "' doesn't map to a list of bytes", e);
395	34	}
396		}
397	54
398	170	return array;
399		}
400
401		/**
402		* Get a list of Short objects associated with the given configuration key.
403		* If the key doesn't map to an existing object an empty list is returned.
404		*
405		* @param key The configuration key.
406		* @return The associated Short list if the key is found.
407		*
408		* @throws ConversionException is thrown if the key maps to an
409		* object that is not a list of shorts.
410		*/
411		public List getShortList(String key)
412	60	{
413	187	return getShortList(key, new ArrayList());
414		}
415
416		/**
417		* Get a list of Short objects associated with the given configuration key.
418		* If the key doesn't map to an existing object, the default value is
419		* returned.
420		*
421		* @param key The configuration key.
422		* @param defaultValue The default value.
423		* @return The associated List of Shorts.
424		*
425		* @throws ConversionException is thrown if the key maps to an
426		* object that is not a list of shorts.
427		*/
428		public List getShortList(String key, List defaultValue)
429	66	{
430	204	Object value = getProperty(key);
431	66
432	204	List list = null;
433	66
434	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
435	6	{
436	34	list = defaultValue;
437	60	}
438	170	else if (value instanceof short[])
439		{
440	0	list = new ArrayList();
441	0	CollectionUtils.addAll(list, ArrayUtils.toObject((short[]) value));
442	60	}
443	170	else if (value instanceof Short[])
444		{
445	0	list = new ArrayList();
446	0	CollectionUtils.addAll(list, (Short[]) value);
447	60	}
448	170	else if (value instanceof Collection)
449	36	{
450	138	Collection values = (Collection) value;
451	102	list = new ArrayList();
452	36
453	210	Iterator it = values.iterator();
454	306	while (it.hasNext())
455	72	{
456	204	list.add(PropertyConverter.toShort(it.next()));
457		}
458		}
459		else
460		{
461		try
462		{
463	24	// attempt to convert a single value
464	92	list = new ArrayList();
465	68	list.add(PropertyConverter.toShort(value));
466	12	}
467	34	catch (ConversionException e)
468	12	{
469	46	throw new ConversionException('\'' + key + "' doesn't map to a list of shorts", e);
470	34	}
471		}
472	54
473	170	return list;
474		}
475
476		/**
477		* Get an array of short primitives associated with the given
478		* configuration key. If the key doesn't map to an existing object
479		* an empty array is returned.
480		*
481		* @param key The configuration key.
482		* @return The associated short array if the key is found.
483		*
484		* @throws ConversionException is thrown if the key maps to an
485		* object that is not a list of shorts.
486		*/
487		public short[] getShortArray(String key)
488	60	{
489	187	return getShortArray(key, new short[0]);
490		}
491
492		/**
493		* Get an array of short primitives associated with the given
494		* configuration key. If the key doesn't map to an existing object
495		* an empty array is returned.
496		*
497		* @param key The configuration key.
498		* @return The associated short array if the key is found.
499		*
500		* @throws ConversionException is thrown if the key maps to an
501		* object that is not a list of shorts.
502		*/
503		public short[] getShortArray(String key, class="keyword">short[] defaultValue)
504	66	{
505	204	Object value = getProperty(key);
506
507		short[] array;
508	66
509	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
510	6	{
511	34	array = defaultValue;
512	60	}
513	170	else if (value instanceof short[])
514		{
515	0	array = (short[]) value;
516	60	}
517	170	else if (value instanceof Short[])
518		{
519	0	array = ArrayUtils.toPrimitive((Short[]) value);
520	60	}
521	170	else if (value instanceof Collection)
522	36	{
523	138	Collection values = (Collection) value;
524	102	array = new short[values.size()];
525	36
526	138	int i = 0;
527	210	Iterator it = values.iterator();
528	306	while (it.hasNext())
529	72	{
530	204	array[i++] = PropertyConverter.toShort(it.next()).shortValue();
531		}
532		}
533		else
534		{
535		try
536		{
537	24	// attempt to convert a single value
538	92	array = new short[1];
539	68	array[0] = PropertyConverter.toShort(value).shortValue();
540	12	}
541	34	catch (ConversionException e)
542	12	{
543	46	throw new ConversionException('\'' + key + "' doesn't map to a list of shorts", e);
544	34	}
545		}
546	54
547	170	return array;
548		}
549
550		/**
551		* Get a list of Integer objects associated with the given
552		* configuration key. If the key doesn't map to an existing object
553		* an empty list is returned.
554		*
555		* @param key The configuration key.
556		* @return The associated Integer list if the key is found.
557		*
558		* @throws ConversionException is thrown if the key maps to an
559		* object that is not a list of integers.
560		*/
561		public List getIntegerList(String key)
562	60	{
563	187	return getIntegerList(key, new ArrayList());
564		}
565
566		/**
567		* Get a list of Integer objects associated with the given
568		* configuration key. If the key doesn't map to an existing object,
569		* the default value is returned.
570		*
571		* @param key The configuration key.
572		* @param defaultValue The default value.
573		* @return The associated List of Integers.
574		*
575		* @throws ConversionException is thrown if the key maps to an
576		* object that is not a list of integers.
577		*/
578		public List getIntegerList(String key, List defaultValue)
579	66	{
580	204	Object value = getProperty(key);
581	66
582	204	List list = null;
583	66
584	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
585	6	{
586	34	list = defaultValue;
587	60	}
588	170	else if (value instanceof int[])
589		{
590	0	list = new ArrayList();
591	0	CollectionUtils.addAll(list, ArrayUtils.toObject((int[]) value));
592	60	}
593	170	else if (value instanceof Integer[])
594		{
595	0	list = new ArrayList();
596	0	CollectionUtils.addAll(list, (Integer[]) value);
597	60	}
598	170	else if (value instanceof Collection)
599	36	{
600	138	Collection values = (Collection) value;
601	102	list = new ArrayList();
602	36
603	210	Iterator it = values.iterator();
604	306	while (it.hasNext())
605	72	{
606	204	list.add(PropertyConverter.toInteger(it.next()));
607		}
608		}
609		else
610		{
611		try
612		{
613	24	// attempt to convert a single value
614	92	list = new ArrayList();
615	68	list.add(PropertyConverter.toInteger(value));
616	12	}
617	34	catch (ConversionException e)
618	12	{
619	46	throw new ConversionException('\'' + key + "' doesn't map to a list of integers", e);
620	34	}
621		}
622	54
623	170	return list;
624		}
625
626		/**
627		* Get an array of int primitives associated with the given
628		* configuration key. If the key doesn't map to an existing object
629		* an empty array is returned.
630		*
631		* @param key The configuration key.
632		* @return The associated int array if the key is found.
633		*
634		* @throws ConversionException is thrown if the key maps to an
635		* object that is not a list of integers.
636		*/
637		public int[] getIntArray(String key)
638	60	{
639	187	return getIntArray(key, new int[0]);
640		}
641
642		/**
643		* Get an array of int primitives associated with the given
644		* configuration key. If the key doesn't map to an existing object
645		* an empty array is returned.
646		*
647		* @param key The configuration key.
648		* @return The associated int array if the key is found.
649		*
650		* @throws ConversionException is thrown if the key maps to an
651		* object that is not a list of integers.
652		*/
653		public int[] getIntArray(String key, class="keyword">int[] defaultValue)
654	66	{
655	204	Object value = getProperty(key);
656
657		int[] array;
658	66
659	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
660	6	{
661	34	array = defaultValue;
662	60	}
663	170	else if (value instanceof int[])
664		{
665	0	array = (int[]) value;
666	60	}
667	170	else if (value instanceof Integer[])
668		{
669	0	array = ArrayUtils.toPrimitive((Integer[]) value);
670	60	}
671	170	else if (value instanceof Collection)
672	36	{
673	138	Collection values = (Collection) value;
674	102	array = new int[values.size()];
675	36
676	138	int i = 0;
677	210	Iterator it = values.iterator();
678	306	while (it.hasNext())
679	72	{
680	204	array[i++] = PropertyConverter.toInteger(it.next()).intValue();
681		}
682		}
683		else
684		{
685		try
686		{
687	24	// attempt to convert a single value
688	92	array = new int[1];
689	68	array[0] = PropertyConverter.toInteger(value).intValue();
690	12	}
691	34	catch (ConversionException e)
692	12	{
693	46	throw new ConversionException('\'' + key + "' doesn't map to a list of integers", e);
694	34	}
695		}
696	54
697	170	return array;
698		}
699
700		/**
701		* Get a list of Long objects associated with the given configuration key.
702		* If the key doesn't map to an existing object an empty list is returned.
703		*
704		* @param key The configuration key.
705		* @return The associated Long list if the key is found.
706		*
707		* @throws ConversionException is thrown if the key maps to an
708		* object that is not a list of longs.
709		*/
710		public List getLongList(String key)
711	60	{
712	187	return getLongList(key, new ArrayList());
713		}
714
715		/**
716		* Get a list of Long objects associated with the given configuration key.
717		* If the key doesn't map to an existing object, the default value is
718		* returned.
719		*
720		* @param key The configuration key.
721		* @param defaultValue The default value.
722		* @return The associated List of Longs.
723		*
724		* @throws ConversionException is thrown if the key maps to an
725		* object that is not a list of longs.
726		*/
727		public List getLongList(String key, List defaultValue)
728	66	{
729	204	Object value = getProperty(key);
730	66
731	204	List list = null;
732	66
733	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
734	6	{
735	34	list = defaultValue;
736	60	}
737	170	else if (value instanceof long[])
738		{
739	0	list = new ArrayList();
740	0	CollectionUtils.addAll(list, ArrayUtils.toObject((long[]) value));
741	60	}
742	170	else if (value instanceof Long[])
743		{
744	0	list = new ArrayList();
745	0	CollectionUtils.addAll(list, (Long[]) value);
746	60	}
747	170	else if (value instanceof Collection)
748	36	{
749	138	Collection values = (Collection) value;
750	102	list = new ArrayList();
751	36
752	210	Iterator it = values.iterator();
753	306	while (it.hasNext())
754	72	{
755	204	list.add(PropertyConverter.toLong(it.next()));
756		}
757		}
758		else
759		{
760		try
761		{
762	24	// attempt to convert a single value
763	92	list = new ArrayList();
764	68	list.add(PropertyConverter.toLong(value));
765	12	}
766	34	catch (ConversionException e)
767	12	{
768	46	throw new ConversionException('\'' + key + "' doesn't map to a list of longs", e);
769	34	}
770		}
771	54
772	170	return list;
773		}
774
775		/**
776		* Get an array of long primitives associated with the given
777		* configuration key. If the key doesn't map to an existing object
778		* an empty array is returned.
779		*
780		* @param key The configuration key.
781		* @return The associated long array if the key is found.
782		*
783		* @throws ConversionException is thrown if the key maps to an
784		* object that is not a list of longs.
785		*/
786		public long[] getLongArray(String key)
787	60	{
788	187	return getLongArray(key, new long[0]);
789		}
790
791		/**
792		* Get an array of long primitives associated with the given
793		* configuration key. If the key doesn't map to an existing object
794		* an empty array is returned.
795		*
796		* @param key The configuration key.
797		* @return The associated long array if the key is found.
798		*
799		* @throws ConversionException is thrown if the key maps to an
800		* object that is not a list of longs.
801		*/
802		public long[] getLongArray(String key, class="keyword">long[] defaultValue)
803	66	{
804	204	Object value = getProperty(key);
805
806		long[] array;
807	66
808	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
809	6	{
810	34	array = defaultValue;
811	60	}
812	170	else if (value instanceof long[])
813		{
814	0	array = (long[]) value;
815	60	}
816	170	else if (value instanceof Long[])
817		{
818	0	array = ArrayUtils.toPrimitive((Long[]) value);
819	60	}
820	170	else if (value instanceof Collection)
821	36	{
822	138	Collection values = (Collection) value;
823	102	array = new long[values.size()];
824	36
825	138	int i = 0;
826	210	Iterator it = values.iterator();
827	306	while (it.hasNext())
828	72	{
829	204	array[i++] = PropertyConverter.toLong(it.next()).longValue();
830		}
831		}
832		else
833		{
834		try
835		{
836	24	// attempt to convert a single value
837	92	array = new long[1];
838	68	array[0] = PropertyConverter.toLong(value).longValue();
839	12	}
840	34	catch (ConversionException e)
841	12	{
842	46	throw new ConversionException('\'' + key + "' doesn't map to a list of longs", e);
843	34	}
844		}
845	54
846	170	return array;
847		}
848
849		/**
850		* Get a list of Float objects associated with the given configuration key.
851		* If the key doesn't map to an existing object an empty list is returned.
852		*
853		* @param key The configuration key.
854		* @return The associated Float list if the key is found.
855		*
856		* @throws ConversionException is thrown if the key maps to an
857		* object that is not a list of floats.
858		*/
859		public List getFloatList(String key)
860	60	{
861	187	return getFloatList(key, new ArrayList());
862		}
863
864		/**
865		* Get a list of Float objects associated with the given
866		* configuration key. If the key doesn't map to an existing object,
867		* the default value is returned.
868		*
869		* @param key The configuration key.
870		* @param defaultValue The default value.
871		* @return The associated List of Floats.
872		*
873		* @throws ConversionException is thrown if the key maps to an
874		* object that is not a list of floats.
875		*/
876		public List getFloatList(String key, List defaultValue)
877	66	{
878	204	Object value = getProperty(key);
879	66
880	204	List list = null;
881	66
882	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
883	6	{
884	34	list = defaultValue;
885	60	}
886	170	else if (value instanceof float[])
887		{
888	0	list = new ArrayList();
889	0	CollectionUtils.addAll(list, ArrayUtils.toObject((float[]) value));
890	60	}
891	170	else if (value instanceof Float[])
892		{
893	0	list = new ArrayList();
894	0	CollectionUtils.addAll(list, (Float[]) value);
895	60	}
896	170	else if (value instanceof Collection)
897	36	{
898	138	Collection values = (Collection) value;
899	102	list = new ArrayList();
900	36
901	210	Iterator it = values.iterator();
902	306	while (it.hasNext())
903	72	{
904	204	list.add(PropertyConverter.toFloat(it.next()));
905		}
906		}
907		else
908		{
909		try
910		{
911	24	// attempt to convert a single value
912	92	list = new ArrayList();
913	68	list.add(PropertyConverter.toFloat(value));
914	12	}
915	34	catch (ConversionException e)
916	12	{
917	46	throw new ConversionException('\'' + key + "' doesn't map to a list of floats", e);
918	34	}
919		}
920	54
921	170	return list;
922		}
923
924		/**
925		* Get an array of float primitives associated with the given
926		* configuration key. If the key doesn't map to an existing object
927		* an empty array is returned.
928		*
929		* @param key The configuration key.
930		* @return The associated float array if the key is found.
931		*
932		* @throws ConversionException is thrown if the key maps to an
933		* object that is not a list of floats.
934		*/
935		public float[] getFloatArray(String key)
936	60	{
937	187	return getFloatArray(key, new float[0]);
938		}
939
940		/**
941		* Get an array of float primitives associated with the given
942		* configuration key. If the key doesn't map to an existing object
943		* an empty array is returned.
944		*
945		* @param key The configuration key.
946		* @return The associated float array if the key is found.
947		*
948		* @throws ConversionException is thrown if the key maps to an
949		* object that is not a list of floats.
950		*/
951		public float[] getFloatArray(String key, class="keyword">float[] defaultValue)
952	66	{
953	204	Object value = getProperty(key);
954
955		float[] array;
956	66
957	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
958	6	{
959	34	array = defaultValue;
960	60	}
961	170	else if (value instanceof float[])
962		{
963	0	array = (float[]) value;
964	60	}
965	170	else if (value instanceof Float[])
966		{
967	0	array = ArrayUtils.toPrimitive((Float[]) value);
968	60	}
969	170	else if (value instanceof Collection)
970	36	{
971	138	Collection values = (Collection) value;
972	102	array = new float[values.size()];
973	36
974	138	int i = 0;
975	210	Iterator it = values.iterator();
976	306	while (it.hasNext())
977	72	{
978	204	array[i++] = PropertyConverter.toFloat(it.next()).floatValue();
979		}
980		}
981		else
982		{
983		try
984		{
985	24	// attempt to convert a single value
986	92	array = new float[1];
987	68	array[0] = PropertyConverter.toFloat(value).floatValue();
988	12	}
989	34	catch (ConversionException e)
990	12	{
991	46	throw new ConversionException('\'' + key + "' doesn't map to a list of floats", e);
992	34	}
993		}
994	54
995	170	return array;
996		}
997
998		/**
999		* Get a list of Double objects associated with the given
1000		* configuration key. If the key doesn't map to an existing object
1001		* an empty list is returned.
1002		*
1003		* @param key The configuration key.
1004		* @return The associated Double list if the key is found.
1005		*
1006		* @throws ConversionException is thrown if the key maps to an
1007		* object that is not a list of doubles.
1008		*/
1009		public List getDoubleList(String key)
1010	60	{
1011	187	return getDoubleList(key, new ArrayList());
1012		}
1013
1014		/**
1015		* Get a list of Double objects associated with the given
1016		* configuration key. If the key doesn't map to an existing object,
1017		* the default value is returned.
1018		*
1019		* @param key The configuration key.
1020		* @param defaultValue The default value.
1021		* @return The associated List of Doubles.
1022		*
1023		* @throws ConversionException is thrown if the key maps to an
1024		* object that is not a list of doubles.
1025		*/
1026		public List getDoubleList(String key, List defaultValue)
1027	66	{
1028	204	Object value = getProperty(key);
1029	66
1030	204	List list = null;
1031	66
1032	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1033	6	{
1034	34	list = defaultValue;
1035	60	}
1036	170	else if (value instanceof double[])
1037		{
1038	0	list = new ArrayList();
1039	0	CollectionUtils.addAll(list, ArrayUtils.toObject((double[]) value));
1040	60	}
1041	170	else if (value instanceof Double[])
1042		{
1043	0	list = new ArrayList();
1044	0	CollectionUtils.addAll(list, (Double[]) value);
1045	60	}
1046	170	else if (value instanceof Collection)
1047	36	{
1048	138	Collection values = (Collection) value;
1049	102	list = new ArrayList();
1050	36
1051	210	Iterator it = values.iterator();
1052	306	while (it.hasNext())
1053	72	{
1054	204	list.add(PropertyConverter.toDouble(it.next()));
1055		}
1056		}
1057		else
1058		{
1059		try
1060		{
1061	24	// attempt to convert a single value
1062	92	list = new ArrayList();
1063	68	list.add(PropertyConverter.toDouble(value));
1064	12	}
1065	34	catch (ConversionException e)
1066	12	{
1067	46	throw new ConversionException('\'' + key + "' doesn't map to a list of doubles", e);
1068	34	}
1069		}
1070	54
1071	170	return list;
1072		}
1073
1074		/**
1075		* Get an array of double primitives associated with the given
1076		* configuration key. If the key doesn't map to an existing object
1077		* an empty array is returned.
1078		*
1079		* @param key The configuration key.
1080		* @return The associated double array if the key is found.
1081		*
1082		* @throws ConversionException is thrown if the key maps to an
1083		* object that is not a list of doubles.
1084		*/
1085		public double[] getDoubleArray(String key)
1086	60	{
1087	187	return getDoubleArray(key, new double[0]);
1088		}
1089
1090		/**
1091		* Get an array of double primitives associated with the given
1092		* configuration key. If the key doesn't map to an existing object
1093		* an empty array is returned.
1094		*
1095		* @param key The configuration key.
1096		* @return The associated double array if the key is found.
1097		*
1098		* @throws ConversionException is thrown if the key maps to an
1099		* object that is not a list of doubles.
1100		*/
1101		public double[] getDoubleArray(String key, class="keyword">double[] defaultValue)
1102	66	{
1103	204	Object value = getProperty(key);
1104
1105		double[] array;
1106	66
1107	204	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1108	6	{
1109	34	array = defaultValue;
1110	60	}
1111	170	else if (value instanceof double[])
1112		{
1113	0	array = (double[]) value;
1114	60	}
1115	170	else if (value instanceof Double[])
1116		{
1117	0	array = ArrayUtils.toPrimitive((Double[]) value);
1118	60	}
1119	170	else if (value instanceof Collection)
1120	36	{
1121	138	Collection values = (Collection) value;
1122	102	array = new double[values.size()];
1123	36
1124	138	int i = 0;
1125	210	Iterator it = values.iterator();
1126	306	while (it.hasNext())
1127	72	{
1128	204	array[i++] = PropertyConverter.toDouble(it.next()).doubleValue();
1129		}
1130		}
1131		else
1132		{
1133		try
1134		{
1135	24	// attempt to convert a single value
1136	92	array = new double[1];
1137	68	array[0] = PropertyConverter.toDouble(value).doubleValue();
1138	12	}
1139	34	catch (ConversionException e)
1140	12	{
1141	46	throw new ConversionException('\'' + key + "' doesn't map to a list of doubles", e);
1142	34	}
1143		}
1144	54
1145	170	return array;
1146		}
1147
1148		/**
1149		* Get a list of BigIntegers associated with the given configuration key.
1150		* If the key doesn't map to an existing object an empty list is returned.
1151		*
1152		* @param key The configuration key.
1153		* @return The associated BigInteger list if the key is found.
1154		*
1155		* @throws ConversionException is thrown if the key maps to an
1156		* object that is not a list of BigIntegers.
1157		*/
1158		public List getBigIntegerList(String key)
1159	114	{
1160	357	return getBigIntegerList(key, new ArrayList());
1161		}
1162
1163		/**
1164		* Get a list of BigIntegers associated with the given configuration key.
1165		* If the key doesn't map to an existing object, the default value is
1166		* returned.
1167		*
1168		* @param key The configuration key.
1169		* @param defaultValue The default value.
1170		* @return The associated List of BigIntegers.
1171		*
1172		* @throws ConversionException is thrown if the key maps to an
1173		* object that is not a list of BigIntegers.
1174		*/
1175		public List getBigIntegerList(String key, List defaultValue)
1176	120	{
1177	374	Object value = getProperty(key);
1178	120
1179	374	List list = null;
1180	120
1181	374	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1182	12	{
1183	68	list = defaultValue;
1184	108	}
1185	306	else if (value instanceof BigInteger[])
1186		{
1187	0	list = new ArrayList();
1188	0	CollectionUtils.addAll(list, (BigInteger[]) value);
1189	108	}
1190	306	else if (value instanceof Collection)
1191	60	{
1192	230	Collection values = (Collection) value;
1193	170	list = new ArrayList();
1194	60
1195	350	Iterator it = values.iterator();
1196	510	while (it.hasNext())
1197	120	{
1198	340	list.add(PropertyConverter.toBigInteger(it.next()));
1199		}
1200		}
1201		else
1202		{
1203		try
1204		{
1205	48	// attempt to convert a single value
1206	184	list = new ArrayList();
1207	136	list.add(PropertyConverter.toBigInteger(value));
1208	24	}
1209	68	catch (ConversionException e)
1210	24	{
1211	92	throw new ConversionException('\'' + key + "' doesn't map to a list of big integers", e);
1212	68	}
1213		}
1214	96
1215	306	return list;
1216		}
1217
1218		/**
1219		* Get an array of BigIntegers associated with the given
1220		* configuration key. If the key doesn't map to an existing object
1221		* an empty array is returned.
1222		*
1223		* @param key The configuration key.
1224		* @return The associated BigInteger array if the key is found.
1225		*
1226		* @throws ConversionException is thrown if the key maps to an
1227		* object that is not a list of BigIntegers.
1228		*/
1229		public BigInteger[] getBigIntegerArray(String key)
1230	54	{
1231	170	return getBigIntegerArray(key, new BigInteger[0]);
1232		}
1233
1234		/**
1235		* Get an array of BigIntegers associated with the given
1236		* configuration key. If the key doesn't map to an existing object
1237		* an empty array is returned.
1238		*
1239		* @param key The configuration key.
1240		* @return The associated BigInteger array if the key is found.
1241		*
1242		* @throws ConversionException is thrown if the key maps to an
1243		* object that is not a list of BigIntegers.
1244		*/
1245		public BigInteger[] getBigIntegerArray(String key, BigInteger[] defaultValue)
1246	60	{
1247	235	List list = getBigIntegerList(key);
1248	153	if (list.isEmpty())
1249	6	{
1250	34	return defaultValue;
1251		}
1252		else
1253	42	{
1254	119	return (BigInteger[]) list.toArray(new BigInteger[list.size()]);
1255		}
1256		}
1257
1258		/**
1259		* Get a list of BigDecimals associated with the given configuration key.
1260		* If the key doesn't map to an existing object an empty list is returned.
1261		*
1262		* @param key The configuration key.
1263		* @return The associated BigDecimal list if the key is found.
1264		*
1265		* @throws ConversionException is thrown if the key maps to an
1266		* object that is not a list of BigDecimals.
1267		*/
1268		public List getBigDecimalList(String key)
1269	114	{
1270	357	return getBigDecimalList(key, new ArrayList());
1271		}
1272
1273		/**
1274		* Get a list of BigDecimals associated with the given configuration key.
1275		* If the key doesn't map to an existing object, the default value is
1276		* returned.
1277		*
1278		* @param key The configuration key.
1279		* @param defaultValue The default value.
1280		* @return The associated List of BigDecimals.
1281		*
1282		* @throws ConversionException is thrown if the key maps to an
1283		* object that is not a list of BigDecimals.
1284		*/
1285		public List getBigDecimalList(String key, List defaultValue)
1286	120	{
1287	374	Object value = getProperty(key);
1288	120
1289	374	List list = null;
1290	120
1291	374	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1292	12	{
1293	68	list = defaultValue;
1294	108	}
1295	306	else if (value instanceof BigDecimal[])
1296		{
1297	0	list = new ArrayList();
1298	0	CollectionUtils.addAll(list, (BigDecimal[]) value);
1299	108	}
1300	306	else if (value instanceof Collection)
1301	60	{
1302	230	Collection values = (Collection) value;
1303	170	list = new ArrayList();
1304	60
1305	350	Iterator it = values.iterator();
1306	510	while (it.hasNext())
1307	120	{
1308	340	list.add(PropertyConverter.toBigDecimal(it.next()));
1309		}
1310		}
1311		else
1312		{
1313		try
1314		{
1315	48	// attempt to convert a single value
1316	184	list = new ArrayList();
1317	136	list.add(PropertyConverter.toBigDecimal(value));
1318	24	}
1319	68	catch (ConversionException e)
1320	24	{
1321	92	throw new ConversionException('\'' + key + "' doesn't map to a list of big decimals", e);
1322	68	}
1323		}
1324	96
1325	306	return list;
1326		}
1327
1328		/**
1329		* Get an array of BigDecimals associated with the given
1330		* configuration key. If the key doesn't map to an existing object
1331		* an empty array is returned.
1332		*
1333		* @param key The configuration key.
1334		* @return The associated BigDecimal array if the key is found.
1335		*
1336		* @throws ConversionException is thrown if the key maps to an
1337		* object that is not a list of BigDecimals.
1338		*/
1339		public BigDecimal[] getBigDecimalArray(String key)
1340	54	{
1341	170	return getBigDecimalArray(key, new BigDecimal[0]);
1342		}
1343
1344		/**
1345		* Get an array of BigDecimals associated with the given
1346		* configuration key. If the key doesn't map to an existing object
1347		* an empty array is returned.
1348		*
1349		* @param key The configuration key.
1350		* @return The associated BigDecimal array if the key is found.
1351		*
1352		* @throws ConversionException is thrown if the key maps to an
1353		* object that is not a list of BigDecimals.
1354		*/
1355		public BigDecimal[] getBigDecimalArray(String key, BigDecimal[] defaultValue)
1356	60	{
1357	235	List list = getBigDecimalList(key);
1358	153	if (list.isEmpty())
1359	6	{
1360	34	return defaultValue;
1361		}
1362		else
1363	42	{
1364	119	return (BigDecimal[]) list.toArray(new BigDecimal[list.size()]);
1365		}
1366		}
1367
1368		/**
1369		* Get an URL associated with the given configuration key.
1370		*
1371		* @param key The configuration key.
1372		* @return The associated URL.
1373		*
1374		* @throws ConversionException is thrown if the key maps to an
1375		* object that is not an URL.
1376		*/
1377		public URL getURL(String key)
1378	12	{
1379	34	return getURL(key, null);
1380		}
1381
1382		/**
1383		* Get an URL associated with the given configuration key.
1384		* If the key doesn't map to an existing object, the default value
1385		* is returned.
1386		*
1387		* @param key The configuration key.
1388		* @param defaultValue The default value.
1389		* @return The associated URL.
1390		*
1391		* @throws ConversionException is thrown if the key maps to an
1392		* object that is not an URL.
1393		*/
1394		public URL getURL(String key, URL defaultValue)
1395	18	{
1396	51	Object value = resolveContainerStore(key);
1397	18
1398	51	if (value == null)
1399	6	{
1400	17	return defaultValue;
1401		}
1402		else
1403		{
1404		try
1405	12	{
1406	34	return PropertyConverter.toURL(value);
1407		}
1408	0	catch (ConversionException e)
1409		{
1410	0	throw new ConversionException('\'' + key + "' doesn't map to an URL", e);
1411		}
1412		}
1413		}
1414
1415		/**
1416		* Get a list of URLs associated with the given configuration key.
1417		* If the key doesn't map to an existing object an empty list is returned.
1418		*
1419		* @param key The configuration key.
1420		* @return The associated URL list if the key is found.
1421		*
1422		* @throws ConversionException is thrown if the key maps to an
1423		* object that is not a list of URLs.
1424		*/
1425		public List getURLList(String key)
1426	114	{
1427	355	return getURLList(key, new ArrayList());
1428		}
1429
1430		/**
1431		* Get a list of URLs associated with the given configuration key.
1432		* If the key doesn't map to an existing object, the default value is
1433		* returned.
1434		*
1435		* @param key The configuration key.
1436		* @param defaultValue The default value.
1437		* @return The associated List of URLs.
1438		*
1439		* @throws ConversionException is thrown if the key maps to an
1440		* object that is not a list of URLs.
1441		*/
1442		public List getURLList(String key, List defaultValue)
1443	120	{
1444	372	Object value = getProperty(key);
1445	120
1446	372	List list = null;
1447	120
1448	372	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1449	12	{
1450	67	list = defaultValue;
1451	108	}
1452	305	else if (value instanceof URL[])
1453		{
1454	0	list = new ArrayList();
1455	0	CollectionUtils.addAll(list, (URL[]) value);
1456	108	}
1457	305	else if (value instanceof Collection)
1458	60	{
1459	230	Collection values = (Collection) value;
1460	170	list = new ArrayList();
1461	60
1462	350	Iterator it = values.iterator();
1463	510	while (it.hasNext())
1464	120	{
1465	340	list.add(PropertyConverter.toURL(it.next()));
1466		}
1467		}
1468		else
1469		{
1470		try
1471		{
1472	48	// attempt to convert a single value
1473	183	list = new ArrayList();
1474	135	list.add(PropertyConverter.toURL(value));
1475	24	}
1476	68	catch (ConversionException e)
1477	24	{
1478	92	throw new ConversionException('\'' + key + "' doesn't map to a list of URLs", e);
1479	67	}
1480		}
1481	96
1482	304	return list;
1483		}
1484
1485		/**
1486		* Get an array of URLs associated with the given configuration key.
1487		* If the key doesn't map to an existing object an empty array is returned.
1488		*
1489		* @param key The configuration key.
1490		* @return The associated URL array if the key is found.
1491		*
1492		* @throws ConversionException is thrown if the key maps to an
1493		* object that is not a list of URLs.
1494		*/
1495		public URL[] getURLArray(String key)
1496	54	{
1497	170	return getURLArray(key, new URL[0]);
1498		}
1499
1500		/**
1501		* Get an array of URLs associated with the given configuration key.
1502		* If the key doesn't map to an existing object an empty array is returned.
1503		*
1504		* @param key The configuration key.
1505		* @return The associated URL array if the key is found.
1506		*
1507		* @throws ConversionException is thrown if the key maps to an
1508		* object that is not a list of URLs.
1509		*/
1510		public URL[] getURLArray(String key, URL[] defaultValue)
1511	60	{
1512	235	List list = getURLList(key);
1513	153	if (list.isEmpty())
1514	6	{
1515	34	return defaultValue;
1516		}
1517		else
1518	42	{
1519	119	return (URL[]) list.toArray(new URL[list.size()]);
1520		}
1521		}
1522
1523		/**
1524		* Get a Date associated with the given configuration key. If the property
1525		* is a String, it will be parsed with the format defined by the user in
1526		* the {@link #DATE_FORMAT_KEY} property, or if it's not defined with the
1527		* {@link #DEFAULT_DATE_FORMAT} pattern.
1528		*
1529		* @param key The configuration key.
1530		* @return The associated Date.
1531		*
1532		* @throws ConversionException is thrown if the key maps to an
1533		* object that is not a Date.
1534		*/
1535		public Date getDate(String key)
1536	18	{
1537	51	return getDate(key, getDefaultDateFormat());
1538		}
1539
1540		/**
1541		* Get a Date associated with the given configuration key. If the property
1542		* is a String, it will be parsed with the specified format pattern.
1543		*
1544		* @param key The configuration key.
1545		* @param format The non-localized {@link java.text.DateFormat} pattern.
1546		* @return The associated Date
1547		*
1548		* @throws ConversionException is thrown if the key maps to an
1549		* object that is not a Date.
1550		*/
1551		public Date getDate(String key, String format)
1552	18	{
1553	51	return getDate(key, null, format);
1554		}
1555
1556		/**
1557		* Get a Date associated with the given configuration key. If the property
1558		* is a String, it will be parsed with the format defined by the user in
1559		* the {@link #DATE_FORMAT_KEY} property, or if it's not defined with the
1560		* {@link #DEFAULT_DATE_FORMAT} pattern. If the key doesn't map to an
1561		* existing object, the default value is returned.
1562		*
1563		* @param key The configuration key.
1564		* @param defaultValue The default value.
1565		* @return The associated Date.
1566		*
1567		* @throws ConversionException is thrown if the key maps to an
1568		* object that is not a Date.
1569		*/
1570		public Date getDate(String key, Date defaultValue)
1571	6	{
1572	17	return getDate(key, defaultValue, getDefaultDateFormat());
1573		}
1574
1575		/**
1576		* Get a Date associated with the given configuration key. If the property
1577		* is a String, it will be parsed with the specified format pattern.
1578		* If the key doesn't map to an existing object, the default value
1579		* is returned.
1580		*
1581		* @param key The configuration key.
1582		* @param defaultValue The default value.
1583		* @param format The non-localized {@link java.text.DateFormat} pattern.
1584		* @return The associated Date.
1585		*
1586		* @throws ConversionException is thrown if the key maps to an
1587		* object that is not a Date.
1588		*/
1589		public Date getDate(String key, Date defaultValue, String format)
1590	24	{
1591	68	Object value = resolveContainerStore(key);
1592	24
1593	68	if (value == null)
1594	6	{
1595	17	return defaultValue;
1596		}
1597		else
1598		{
1599		try
1600	18	{
1601	51	return PropertyConverter.toDate(value, format);
1602		}
1603	0	catch (ConversionException e)
1604		{
1605	0	throw new ConversionException('\'' + key + "' doesn't map to a Date", e);
1606		}
1607		}
1608		}
1609
1610		/**
1611		* Get a list of Dates associated with the given configuration key.
1612		* If the property is a list of Strings, they will be parsed with the
1613		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
1614		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
1615		* If the key doesn't map to an existing object an empty list is returned.
1616		*
1617		* @param key The configuration key.
1618		* @return The associated Date list if the key is found.
1619		*
1620		* @throws ConversionException is thrown if the key maps to an
1621		* object that is not a list of Dates.
1622		*/
1623		public List getDateList(String key)
1624	126	{
1625	391	return getDateList(key, new ArrayList());
1626		}
1627
1628		/**
1629		* Get a list of Dates associated with the given configuration key.
1630		* If the property is a list of Strings, they will be parsed with the
1631		* specified format pattern. If the key doesn't map to an existing object
1632		* an empty list is returned.
1633		*
1634		* @param key The configuration key.
1635		* @param format The non-localized {@link java.text.DateFormat} pattern.
1636		* @return The associated Date list if the key is found.
1637		*
1638		* @throws ConversionException is thrown if the key maps to an
1639		* object that is not a list of Dates.
1640		*/
1641		public List getDateList(String key, String format)
1642		{
1643	0	return getDateList(key, new ArrayList(), format);
1644		}
1645
1646		/**
1647		* Get a list of Dates associated with the given configuration key.
1648		* If the property is a list of Strings, they will be parsed with the
1649		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
1650		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
1651		* If the key doesn't map to an existing object, the default value is
1652		* returned.
1653		*
1654		* @param key The configuration key.
1655		* @param defaultValue The default value.
1656		* @return The associated Date list if the key is found.
1657		*
1658		* @throws ConversionException is thrown if the key maps to an
1659		* object that is not a list of Dates.
1660		*/
1661		public List getDateList(String key, List defaultValue)
1662	132	{
1663	408	return getDateList(key, defaultValue, getDefaultDateFormat());
1664		}
1665
1666		/**
1667		* Get a list of Dates associated with the given configuration key.
1668		* If the property is a list of Strings, they will be parsed with the
1669		* specified format pattern. If the key doesn't map to an existing object,
1670		* the default value is returned.
1671		*
1672		* @param key The configuration key.
1673		* @param defaultValue The default value.
1674		* @param format The non-localized {@link java.text.DateFormat} pattern.
1675		* @return The associated Date list if the key is found.
1676		*
1677		* @throws ConversionException is thrown if the key maps to an
1678		* object that is not a list of Dates.
1679		*/
1680		public List getDateList(String key, List defaultValue, String format)
1681	132	{
1682	408	Object value = getProperty(key);
1683	132
1684	408	List list = null;
1685	132
1686	408	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1687	12	{
1688	68	list = defaultValue;
1689	120	}
1690	340	else if (value instanceof Date[])
1691		{
1692	0	list = new ArrayList();
1693	0	CollectionUtils.addAll(list, (Date[]) value);
1694	120	}
1695	340	else if (value instanceof Calendar[])
1696		{
1697	0	list = new ArrayList();
1698	0	Calendar[] values = (Calendar[]) value;
1699
1700	0	for (int i = 0; i < values.length; i++)
1701		{
1702	0	list.add(values[i].getTime());
1703		}
1704	120	}
1705	340	else if (value instanceof Collection)
1706	72	{
1707	276	Collection values = (Collection) value;
1708	204	list = new ArrayList();
1709	72
1710	420	Iterator it = values.iterator();
1711	612	while (it.hasNext())
1712	144	{
1713	408	list.add(PropertyConverter.toDate(it.next(), format));
1714		}
1715		}
1716		else
1717		{
1718		try
1719		{
1720	48	// attempt to convert a single value
1721	184	list = new ArrayList();
1722	136	list.add(PropertyConverter.toDate(value, format));
1723	24	}
1724	68	catch (ConversionException e)
1725	24	{
1726	92	throw new ConversionException('\'' + key + "' doesn't map to a list of Dates", e);
1727	68	}
1728		}
1729	108
1730	340	return list;
1731		}
1732
1733		/**
1734		* Get an array of Dates associated with the given configuration key.
1735		* If the property is a list of Strings, they will be parsed with the
1736		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
1737		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
1738		* If the key doesn't map to an existing object an empty array is returned.
1739		*
1740		* @param key The configuration key.
1741		* @return The associated Date array if the key is found.
1742		*
1743		* @throws ConversionException is thrown if the key maps to an
1744		* object that is not a list of Dates.
1745		*/
1746		public Date[] getDateArray(String key)
1747	60	{
1748	187	return getDateArray(key, new Date[0]);
1749		}
1750
1751		/**
1752		* Get an array of Dates associated with the given configuration key.
1753		* If the property is a list of Strings, they will be parsed with the
1754		* specified format pattern. If the key doesn't map to an existing object
1755		* an empty array is returned.
1756		*
1757		* @param key The configuration key.
1758		* @param format The non-localized {@link java.text.DateFormat} pattern.
1759		* @return The associated Date array if the key is found.
1760		*
1761		* @throws ConversionException is thrown if the key maps to an
1762		* object that is not a list of Dates.
1763		*/
1764		public Date[] getDateArray(String key, String format)
1765		{
1766	0	return getDateArray(key, new Date[0], format);
1767		}
1768
1769		/**
1770		* Get an array of Dates associated with the given configuration key.
1771		* If the property is a list of Strings, they will be parsed with the
1772		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
1773		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
1774		* If the key doesn't map to an existing object an empty array is returned.
1775		*
1776		* @param key The configuration key.
1777		* @return The associated Date array if the key is found.
1778		*
1779		* @throws ConversionException is thrown if the key maps to an
1780		* object that is not a list of Dates.
1781		*/
1782		public Date[] getDateArray(String key, Date[] defaultValue)
1783	66	{
1784	204	return getDateArray(key, defaultValue, getDefaultDateFormat());
1785		}
1786
1787		/**
1788		* Get an array of Dates associated with the given configuration key.
1789		* If the property is a list of Strings, they will be parsed with the
1790		* specified format pattern. If the key doesn't map to an existing object,
1791		* the default value is returned.
1792		*
1793		* @param key The configuration key.
1794		* @param defaultValue The default value.
1795		* @param format The non-localized {@link java.text.DateFormat} pattern.
1796		* @return The associated Date array if the key is found.
1797		*
1798		* @throws ConversionException is thrown if the key maps to an
1799		* object that is not a list of Dates.
1800		*/
1801		public Date[] getDateArray(String key, Date[] defaultValue, String format)
1802	66	{
1803	258	List list = getDateList(key);
1804	170	if (list.isEmpty())
1805	6	{
1806	34	return defaultValue;
1807		}
1808		else
1809	48	{
1810	136	return (Date[]) list.toArray(new Date[list.size()]);
1811		}
1812		}
1813
1814		/**
1815		* Get a Calendar associated with the given configuration key. If the
1816		* property is a String, it will be parsed with the format defined by the
1817		* user in the {@link #DATE_FORMAT_KEY} property, or if it's not defined
1818		* with the {@link #DEFAULT_DATE_FORMAT} pattern.
1819		*
1820		* @param key The configuration key.
1821		* @return The associated Calendar.
1822		*
1823		* @throws ConversionException is thrown if the key maps to an
1824		* object that is not a Calendar.
1825		*/
1826		public Calendar getCalendar(String key)
1827	18	{
1828	51	return getCalendar(key, getDefaultDateFormat());
1829		}
1830
1831		/**
1832		* Get a Calendar associated with the given configuration key. If the
1833		* property is a String, it will be parsed with the specified format
1834		* pattern.
1835		*
1836		* @param key The configuration key.
1837		* @param format The non-localized {@link java.text.DateFormat} pattern.
1838		* @return The associated Calendar
1839		*
1840		* @throws ConversionException is thrown if the key maps to an
1841		* object that is not a Calendar.
1842		*/
1843		public Calendar getCalendar(String key, String format)
1844	18	{
1845	51	return getCalendar(key, null, format);
1846		}
1847
1848		/**
1849		* Get a Calendar associated with the given configuration key. If the
1850		* property is a String, it will be parsed with the format defined by the
1851		* user in the {@link #DATE_FORMAT_KEY} property, or if it's not defined
1852		* with the {@link #DEFAULT_DATE_FORMAT} pattern. If the key doesn't map
1853		* to an existing object, the default value is returned.
1854		*
1855		* @param key The configuration key.
1856		* @param defaultValue The default value.
1857		* @return The associated Calendar.
1858		*
1859		* @throws ConversionException is thrown if the key maps to an
1860		* object that is not a Calendar.
1861		*/
1862		public Calendar getCalendar(String key, Calendar defaultValue)
1863	6	{
1864	17	return getCalendar(key, defaultValue, getDefaultDateFormat());
1865		}
1866
1867		/**
1868		* Get a Calendar associated with the given configuration key. If the
1869		* property is a String, it will be parsed with the specified format
1870		* pattern. If the key doesn't map to an existing object, the default
1871		* value is returned.
1872		*
1873		* @param key The configuration key.
1874		* @param defaultValue The default value.
1875		* @param format The non-localized {@link java.text.DateFormat} pattern.
1876		* @return The associated Calendar.
1877		*
1878		* @throws ConversionException is thrown if the key maps to an
1879		* object that is not a Calendar.
1880		*/
1881		public Calendar getCalendar(String key, Calendar defaultValue, String format)
1882	24	{
1883	68	Object value = resolveContainerStore(key);
1884	24
1885	68	if (value == null)
1886	6	{
1887	17	return defaultValue;
1888		}
1889		else
1890		{
1891		try
1892	18	{
1893	51	return PropertyConverter.toCalendar(value, format);
1894		}
1895	0	catch (ConversionException e)
1896		{
1897	0	throw new ConversionException('\'' + key + "' doesn't map to a Calendar", e);
1898		}
1899		}
1900		}
1901
1902		/**
1903		* Get a list of Calendars associated with the given configuration key.
1904		* If the property is a list of Strings, they will be parsed with the
1905		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
1906		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
1907		* If the key doesn't map to an existing object an empty list is returned.
1908		*
1909		* @param key The configuration key.
1910		* @return The associated Calendar list if the key is found.
1911		*
1912		* @throws ConversionException is thrown if the key maps to an
1913		* object that is not a list of Calendars.
1914		*/
1915		public List getCalendarList(String key)
1916	60	{
1917	187	return getCalendarList(key, new ArrayList());
1918		}
1919
1920		/**
1921		* Get a list of Calendars associated with the given configuration key.
1922		* If the property is a list of Strings, they will be parsed with the
1923		* specified format pattern. If the key doesn't map to an existing object
1924		* an empty list is returned.
1925		*
1926		* @param key The configuration key.
1927		* @param format The non-localized {@link java.text.DateFormat} pattern.
1928		* @return The associated Calendar list if the key is found.
1929		*
1930		* @throws ConversionException is thrown if the key maps to an
1931		* object that is not a list of Calendars.
1932		*/
1933		public List getCalendarList(String key, String format)
1934	66	{
1935	204	return getCalendarList(key, new ArrayList(), format);
1936		}
1937
1938		/**
1939		* Get a list of Calendars associated with the given configuration key.
1940		* If the property is a list of Strings, they will be parsed with the
1941		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
1942		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
1943		* If the key doesn't map to an existing object, the default value is
1944		* returned.
1945		*
1946		* @param key The configuration key.
1947		* @param defaultValue The default value.
1948		* @return The associated Calendar list if the key is found.
1949		*
1950		* @throws ConversionException is thrown if the key maps to an
1951		* object that is not a list of Calendars.
1952		*/
1953		public List getCalendarList(String key, List defaultValue)
1954	66	{
1955	204	return getCalendarList(key, defaultValue, getDefaultDateFormat());
1956		}
1957
1958		/**
1959		* Get a list of Calendars associated with the given configuration key.
1960		* If the property is a list of Strings, they will be parsed with the
1961		* specified format pattern. If the key doesn't map to an existing object,
1962		* the default value is returned.
1963		*
1964		* @param key The configuration key.
1965		* @param defaultValue The default value.
1966		* @param format The non-localized {@link java.text.DateFormat} pattern.
1967		* @return The associated Calendar list if the key is found.
1968		*
1969		* @throws ConversionException is thrown if the key maps to an
1970		* object that is not a list of Calendars.
1971		*/
1972		public List getCalendarList(String key, List defaultValue, String format)
1973	132	{
1974	408	Object value = getProperty(key);
1975	132
1976	408	List list = null;
1977	132
1978	408	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
1979	12	{
1980	68	list = defaultValue;
1981	120	}
1982	340	else if (value instanceof Calendar[])
1983		{
1984	0	list = new ArrayList();
1985	0	CollectionUtils.addAll(list, (Calendar[]) value);
1986	120	}
1987	340	else if (value instanceof Date[])
1988		{
1989	0	list = new ArrayList();
1990	0	Date[] values = (Date[]) value;
1991
1992	0	for (int i = 0; i < values.length; i++)
1993		{
1994	0	Calendar calendar = Calendar.getInstance();
1995	0	calendar.setTime(values[i]);
1996	0	list.add(calendar);
1997		}
1998	120	}
1999	340	else if (value instanceof Collection)
2000	72	{
2001	276	Collection values = (Collection) value;
2002	204	list = new ArrayList();
2003	72
2004	420	Iterator it = values.iterator();
2005	612	while (it.hasNext())
2006	144	{
2007	408	list.add(PropertyConverter.toCalendar(it.next(), format));
2008		}
2009		}
2010		else
2011		{
2012		try
2013		{
2014	48	// attempt to convert a single value
2015	184	list = new ArrayList();
2016	136	list.add(PropertyConverter.toCalendar(value, format));
2017	24	}
2018	68	catch (ConversionException e)
2019	24	{
2020	92	throw new ConversionException('\'' + key + "' doesn't map to a list of Calendars", e);
2021	68	}
2022		}
2023	108
2024	340	return list;
2025		}
2026
2027		/**
2028		* Get an array of Calendars associated with the given configuration key.
2029		* If the property is a list of Strings, they will be parsed with the
2030		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
2031		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
2032		* If the key doesn't map to an existing object an empty array is returned.
2033		*
2034		* @param key The configuration key.
2035		* @return The associated Calendar array if the key is found.
2036		*
2037		* @throws ConversionException is thrown if the key maps to an
2038		* object that is not a list of Calendars.
2039		*/
2040		public Calendar[] getCalendarArray(String key)
2041	60	{
2042	187	return getCalendarArray(key, new Calendar[0]);
2043		}
2044
2045		/**
2046		* Get an array of Calendars associated with the given configuration key.
2047		* If the property is a list of Strings, they will be parsed with the
2048		* specified format pattern. If the key doesn't map to an existing object
2049		* an empty array is returned.
2050		*
2051		* @param key The configuration key.
2052		* @param format The non-localized {@link java.text.DateFormat} pattern.
2053		* @return The associated Calendar array if the key is found.
2054		*
2055		* @throws ConversionException is thrown if the key maps to an
2056		* object that is not a list of Calendars.
2057		*/
2058		public Calendar[] getCalendarArray(String key, String format)
2059		{
2060	0	return getCalendarArray(key, new Calendar[0], format);
2061		}
2062
2063		/**
2064		* Get an array of Calendars associated with the given configuration key.
2065		* If the property is a list of Strings, they will be parsed with the
2066		* format defined by the user in the {@link #DATE_FORMAT_KEY} property,
2067		* or if it's not defined with the {@link #DEFAULT_DATE_FORMAT} pattern.
2068		* If the key doesn't map to an existing object an empty array is returned.
2069		*
2070		* @param key The configuration key.
2071		* @return The associated Calendar array if the key is found.
2072		*
2073		* @throws ConversionException is thrown if the key maps to an
2074		* object that is not a list of Calendars.
2075		*/
2076		public Calendar[] getCalendarArray(String key, Calendar[] defaultValue)
2077	66	{
2078	204	return getCalendarArray(key, defaultValue, getDefaultDateFormat());
2079		}
2080
2081		/**
2082		* Get an array of Calendars associated with the given configuration key.
2083		* If the property is a list of Strings, they will be parsed with the
2084		* specified format pattern. If the key doesn't map to an existing object,
2085		* the default value is returned.
2086		*
2087		* @param key The configuration key.
2088		* @param defaultValue The default value.
2089		* @param format The non-localized {@link java.text.DateFormat} pattern.
2090		* @return The associated Calendar array if the key is found.
2091		*
2092		* @throws ConversionException is thrown if the key maps to an
2093		* object that is not a list of Calendars.
2094		*/
2095		public Calendar[] getCalendarArray(String key, Calendar[] defaultValue, String format)
2096	66	{
2097	258	List list = getCalendarList(key, format);
2098	170	if (list.isEmpty())
2099	6	{
2100	34	return defaultValue;
2101		}
2102		else
2103	48	{
2104	136	return (Calendar[]) list.toArray(new Calendar[list.size()]);
2105		}
2106		}
2107
2108		/**
2109		* Returns the date format specified by the user in the DATE_FORMAT_KEY
2110		* property, or the default format otherwise.
2111		*/
2112		private String getDefaultDateFormat()
2113	378	{
2114	1156	return getString(DATE_FORMAT_KEY, DEFAULT_DATE_FORMAT);
2115		}
2116
2117		/**
2118		* Get a Locale associated with the given configuration key.
2119		*
2120		* @param key The configuration key.
2121		* @return The associated Locale.
2122		*
2123		* @throws ConversionException is thrown if the key maps to an
2124		* object that is not a Locale.
2125		*/
2126		public Locale getLocale(String key)
2127	36	{
2128	102	return getLocale(key, null);
2129		}
2130
2131		/**
2132		* Get a Locale associated with the given configuration key.
2133		* If the key doesn't map to an existing object, the default value
2134		* is returned.
2135		*
2136		* @param key The configuration key.
2137		* @param defaultValue The default value.
2138		* @return The associated Locale.
2139		*
2140		* @throws ConversionException is thrown if the key maps to an
2141		* object that is not a Locale.
2142		*/
2143		public Locale getLocale(String key, Locale defaultValue)
2144	48	{
2145	136	Object value = resolveContainerStore(key);
2146	48
2147	136	if (value == null)
2148	6	{
2149	17	return defaultValue;
2150		}
2151		else
2152		{
2153		try
2154	42	{
2155	119	return PropertyConverter.toLocale(value);
2156		}
2157	0	catch (ConversionException e)
2158		{
2159	0	throw new ConversionException('\'' + key + "' doesn't map to a Locale", e);
2160		}
2161		}
2162		}
2163
2164		/**
2165		* Get a list of Locales associated with the given configuration key.
2166		* If the key doesn't map to an existing object an empty list is returned.
2167		*
2168		* @param key The configuration key.
2169		* @return The associated Locale list if the key is found.
2170		*
2171		* @throws ConversionException is thrown if the key maps to an
2172		* object that is not a list of Locales.
2173		*/
2174		public List getLocaleList(String key)
2175	114	{
2176	357	return getLocaleList(key, new ArrayList());
2177		}
2178
2179		/**
2180		* Get a list of Locales associated with the given configuration key.
2181		* If the key doesn't map to an existing object, the default value is
2182		* returned.
2183		*
2184		* @param key The configuration key.
2185		* @param defaultValue The default value.
2186		* @return The associated List of Locales.
2187		*
2188		* @throws ConversionException is thrown if the key maps to an
2189		* object that is not a list of Locales.
2190		*/
2191		public List getLocaleList(String key, List defaultValue)
2192	120	{
2193	374	Object value = getProperty(key);
2194	120
2195	374	List list = null;
2196	120
2197	374	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
2198	12	{
2199	68	list = defaultValue;
2200	108	}
2201	306	else if (value instanceof Locale[])
2202		{
2203	0	list = new ArrayList();
2204	0	CollectionUtils.addAll(list, (Locale[]) value);
2205	108	}
2206	306	else if (value instanceof Collection)
2207	60	{
2208	230	Collection values = (Collection) value;
2209	170	list = new ArrayList();
2210	60
2211	350	Iterator it = values.iterator();
2212	510	while (it.hasNext())
2213	120	{
2214	340	list.add(PropertyConverter.toLocale(it.next()));
2215		}
2216		}
2217		else
2218		{
2219		try
2220		{
2221	48	// attempt to convert a single value
2222	184	list = new ArrayList();
2223	136	list.add(PropertyConverter.toLocale(value));
2224	24	}
2225	68	catch (ConversionException e)
2226	24	{
2227	92	throw new ConversionException('\'' + key + "' doesn't map to a list of Locales", e);
2228	68	}
2229		}
2230	96
2231	306	return list;
2232		}
2233
2234		/**
2235		* Get an array of Locales associated with the given
2236		* configuration key. If the key doesn't map to an existing object
2237		* an empty array is returned.
2238		*
2239		* @param key The configuration key.
2240		* @return The associated Locale array if the key is found.
2241		*
2242		* @throws ConversionException is thrown if the key maps to an
2243		* object that is not a list of Locales.
2244		*/
2245		public Locale[] getLocaleArray(String key)
2246	54	{
2247	170	return getLocaleArray(key, new Locale[0]);
2248		}
2249
2250		/**
2251		* Get an array of Locales associated with the given
2252		* configuration key. If the key doesn't map to an existing object
2253		* an empty array is returned.
2254		*
2255		* @param key The configuration key.
2256		* @return The associated Locale array if the key is found.
2257		*
2258		* @throws ConversionException is thrown if the key maps to an
2259		* object that is not a list of Locales.
2260		*/
2261		public Locale[] getLocaleArray(String key, Locale[] defaultValue)
2262	60	{
2263	235	List list = getLocaleList(key);
2264	153	if (list.isEmpty())
2265	6	{
2266	34	return defaultValue;
2267		}
2268		else
2269	42	{
2270	119	return (Locale[]) list.toArray(new Locale[list.size()]);
2271		}
2272		}
2273
2274		/**
2275		* Get a Color associated with the given configuration key.
2276		*
2277		* @param key The configuration key.
2278		* @return The associated Color.
2279		*
2280		* @throws ConversionException is thrown if the key maps to an
2281		* object that is not a Color.
2282		*/
2283		public Color getColor(String key)
2284	18	{
2285	51	return getColor(key, null);
2286		}
2287
2288		/**
2289		* Get a Color associated with the given configuration key.
2290		* If the key doesn't map to an existing object, the default value
2291		* is returned.
2292		*
2293		* @param key The configuration key.
2294		* @param defaultValue The default value.
2295		* @return The associated Color.
2296		*
2297		* @throws ConversionException is thrown if the key maps to an
2298		* object that is not a Color.
2299		*/
2300		public Color getColor(String key, Color defaultValue)
2301	18	{
2302	51	Object value = resolveContainerStore(key);
2303	18
2304	51	if (value == null)
2305		{
2306	0	return defaultValue;
2307		}
2308		else
2309		{
2310		try
2311	18	{
2312	51	return PropertyConverter.toColor(value);
2313		}
2314	0	catch (ConversionException e)
2315		{
2316	0	throw new ConversionException('\'' + key + "' doesn't map to a Color", e);
2317		}
2318		}
2319		}
2320
2321		/**
2322		* Get a list of Colors associated with the given configuration key.
2323		* If the key doesn't map to an existing object an empty list is returned.
2324		*
2325		* @param key The configuration key.
2326		* @return The associated Color list if the key is found.
2327		*
2328		* @throws ConversionException is thrown if the key maps to an
2329		* object that is not a list of Colors.
2330		*/
2331		public List getColorList(String key)
2332	114	{
2333	357	return getColorList(key, new ArrayList());
2334		}
2335
2336		/**
2337		* Get a list of Colors associated with the given configuration key.
2338		* If the key doesn't map to an existing object, the default value is
2339		* returned.
2340		*
2341		* @param key The configuration key.
2342		* @param defaultValue The default value.
2343		* @return The associated List of Colors.
2344		*
2345		* @throws ConversionException is thrown if the key maps to an
2346		* object that is not a list of Colors.
2347		*/
2348		public List getColorList(String key, List defaultValue)
2349	120	{
2350	374	Object value = getProperty(key);
2351	120
2352	374	List list = null;
2353	120
2354	374	if (value == null || (value instanceof String && StringUtils.isEmpty((String) value)))
2355	12	{
2356	68	list = defaultValue;
2357	108	}
2358	306	else if (value instanceof Color[])
2359		{
2360	0	list = new ArrayList();
2361	0	CollectionUtils.addAll(list, (Color[]) value);
2362	108	}
2363	306	else if (value instanceof Collection)
2364	60	{
2365	230	Collection values = (Collection) value;
2366	170	list = new ArrayList();
2367	60
2368	350	Iterator it = values.iterator();
2369	510	while (it.hasNext())
2370	120	{
2371	340	list.add(PropertyConverter.toColor(it.next()));
2372		}
2373		}
2374		else
2375		{
2376		try
2377		{
2378	48	// attempt to convert a single value
2379	184	list = new ArrayList();
2380	136	list.add(PropertyConverter.toColor(value));
2381	24	}
2382	68	catch (ConversionException e)
2383	24	{
2384	92	throw new ConversionException('\'' + key + "' doesn't map to a list of Colors", e);
2385	68	}
2386		}
2387	96
2388	306	return list;
2389		}
2390
2391		/**
2392		* Get an array of Colors associated with the given
2393		* configuration key. If the key doesn't map to an existing object
2394		* an empty array is returned.
2395		*
2396		* @param key The configuration key.
2397		* @return The associated Color array if the key is found.
2398		*
2399		* @throws ConversionException is thrown if the key maps to an
2400		* object that is not a list of Colors.
2401		*/
2402		public Color[] getColorArray(String key)
2403	54	{
2404	170	return getColorArray(key, new Color[0]);
2405		}
2406
2407		/**
2408		* Get an array of Colors associated with the given
2409		* configuration key. If the key doesn't map to an existing object
2410		* an empty array is returned.
2411		*
2412		* @param key The configuration key.
2413		* @return The associated Color array if the key is found.
2414		*
2415		* @throws ConversionException is thrown if the key maps to an
2416		* object that is not a list of Colors.
2417		*/
2418		public Color[] getColorArray(String key, Color[] defaultValue)
2419	60	{
2420	235	List list = getColorList(key);
2421	153	if (list.isEmpty())
2422	6	{
2423	34	return defaultValue;
2424		}
2425		else
2426	42	{
2427	119	return (Color[]) list.toArray(new Color[list.size()]);
2428		}
2429		}
2430
2431		}