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