Coverage report

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

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

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