View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *     http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.configuration;
19  
20  import java.math.BigDecimal;
21  import java.math.BigInteger;
22  import java.util.Iterator;
23  import java.util.List;
24  import java.util.Properties;
25  
26  /***
27   * <p>The main Configuration interface.</p>
28   * <p>This interface allows accessing and manipulating a configuration object.
29   * The major part of the methods defined in this interface deals with accessing
30   * properties of various data types. There is a generic <code>getProperty()</code>
31   * method, which returns the value of the queried property in its raw data
32   * type. Other getter methods try to convert this raw data type into a specific
33   * data type. If this fails, a <code>ConversionException</code> will be thrown.</p>
34   * <p>For most of the property getter methods an overloaded version exists that
35   * allows to specify a default value, which will be returned if the queried
36   * property cannot be found in the configuration. The behavior of the methods
37   * that do not take a default value in case of a missing property is not defined
38   * by this interface and depends on a concrete implementation. E.g. the
39   * <code>{@link AbstractConfiguration}</code> class, which is the base class
40   * of most configuration implementations provided by this package, per default
41   * returns <b>null</b> if a property is not found, but provides the
42   * <code>{@link org.apache.commons.configuration.AbstractConfiguration#setThrowExceptionOnMissing(boolean)
43   * setThrowExceptionOnMissing()}</code>
44   * method, with which it can be configured to throw a <code>NoSuchElementException</code>
45   * exception in that case. (Note that getter methods for primitive types in
46   * <code>AbstractConfiguration</code> always throw an exception for missing
47   * properties because there is no way of overloading the return value.)</p>
48   * <p>With the <code>addProperty()</code> and <code>setProperty()</code> methods
49   * new properties can be added to a configuration or the values of properties
50   * can be changed. With <code>clearProperty()</code> a property can be removed.
51   * Other methods allow to iterate over the contained properties or to create
52   * a subset configuration.</p>
53   *
54   * @author Commons Configuration team
55   * @version $Id: Configuration.java 449017 2006-09-22 17:27:00Z oheger $
56   */
57  public interface Configuration
58  {
59      /***
60       * Return a decorator Configuration containing every key from the current
61       * Configuration that starts with the specified prefix. The prefix is
62       * removed from the keys in the subset. For example, if the configuration
63       * contains the following properties:
64       *
65       * <pre>
66       *    prefix.number = 1
67       *    prefix.string = Apache
68       *    prefixed.foo = bar
69       *    prefix = Jakarta</pre>
70       *
71       * the Configuration returned by <code>subset("prefix")</code> will contain
72       * the properties:
73       *
74       * <pre>
75       *    number = 1
76       *    string = Apache
77       *    = Jakarta</pre>
78       *
79       * (The key for the value "Jakarta" is an empty string)
80       * <p>
81       * Since the subset is a decorator and not a modified copy of the initial
82       * Configuration, any change made to the subset is available to the
83       * Configuration, and reciprocally.
84       *
85       * @param prefix The prefix used to select the properties.
86       * @return a subset configuration
87       *
88       * @see SubsetConfiguration
89       */
90      Configuration subset(String prefix);
91  
92      /***
93       * Check if the configuration is empty.
94       *
95       * @return <code>true</code> if the configuration contains no property,
96       *         <code>false</code> otherwise.
97       */
98      boolean isEmpty();
99  
100     /***
101      * Check if the configuration contains the specified key.
102      *
103      * @param key the key whose presence in this configuration is to be tested
104      *
105      * @return <code>true</code> if the configuration contains a value for this
106      *         key, <code>false</code> otherwise
107      */
108     boolean containsKey(String key);
109 
110     /***
111      * Add a property to the configuration. If it already exists then the value
112      * stated here will be added to the configuration entry. For example, if
113      * the property:
114      *
115      * <pre>resource.loader = file</pre>
116      *
117      * is already present in the configuration and you call
118      *
119      * <pre>addProperty("resource.loader", "classpath")</pre>
120      *
121      * Then you will end up with a List like the following:
122      *
123      * <pre>["file", "classpath"]</pre>
124      *
125      * @param key The key to add the property to.
126      * @param value The value to add.
127      */
128     void addProperty(String key, Object value);
129 
130     /***
131      * Set a property, this will replace any previously set values. Set values
132      * is implicitly a call to clearProperty(key), addProperty(key, value).
133      *
134      * @param key The key of the property to change
135      * @param value The new value
136      */
137     void setProperty(String key, Object value);
138 
139     /***
140      * Remove a property from the configuration.
141      *
142      * @param key the key to remove along with corresponding value.
143      */
144     void clearProperty(String key);
145 
146     /***
147      * Remove all properties from the configuration.
148      */
149     void clear();
150 
151     /***
152      * Gets a property from the configuration. This is the most basic get
153      * method for retrieving values of properties. In a typical implementation
154      * of the <code>Configuration</code> interface the other get methods (that
155      * return specific data types) will internally make use of this method. On
156      * this level variable substitution is not yet performed. The returned
157      * object is an internal representation of the property value for the passed
158      * in key. It is owned by the <code>Configuration</code> object. So a caller
159      * should not modify this object. It cannot be guaranteed that this object
160      * will stay constant over time (i.e. further update operations on the
161      * configuration may change its internal state).
162      *
163      * @param key property to retrieve
164      * @return the value to which this configuration maps the specified key, or
165      *         null if the configuration contains no mapping for this key.
166      */
167     Object getProperty(String key);
168 
169     /***
170      * Get the list of the keys contained in the configuration that match the
171      * specified prefix.
172      *
173      * @param prefix The prefix to test against.
174      * @return An Iterator of keys that match the prefix.
175      * @see #getKeys()
176      */
177     Iterator getKeys(String prefix);
178 
179     /***
180      * Get the list of the keys contained in the configuration. The returned
181      * iterator can be used to obtain all defined keys. Note that the exact
182      * behavior of the iterator's <code>remove()</code> method is specific to
183      * a concrete implementation. It <em>may</em> remove the corresponding
184      * property from the configuration, but this is not guaranteed. In any case
185      * it is no replacement for calling
186      * <code>{@link #clearProperty(String)}</code> for this property. So it is
187      * highly recommended to avoid using the iterator's <code>remove()</code>
188      * method.
189      *
190      * @return An Iterator.
191      */
192     Iterator getKeys();
193 
194     /***
195      * Get a list of properties associated with the given configuration key.
196      * This method expects the given key to have an arbitrary number of String
197      * values, each of which is of the form <code>key=value</code>. These
198      * strings are splitted at the equals sign, and the key parts will become
199      * keys of the returned <code>Properties</code> object, the value parts
200      * become values.
201      *
202      * @param key The configuration key.
203      * @return The associated properties if key is found.
204      *
205      * @throws ConversionException is thrown if the key maps to an
206      *         object that is not a String/List.
207      *
208      * @throws IllegalArgumentException if one of the tokens is
209      *         malformed (does not contain an equals sign).
210      */
211     Properties getProperties(String key);
212 
213     /***
214      * Get a boolean associated with the given configuration key.
215      *
216      * @param key The configuration key.
217      * @return The associated boolean.
218      *
219      * @throws ConversionException is thrown if the key maps to an
220      *         object that is not a Boolean.
221      */
222     boolean getBoolean(String key);
223 
224     /***
225      * Get a boolean associated with the given configuration key.
226      * If the key doesn't map to an existing object, the default value
227      * is returned.
228      *
229      * @param key The configuration key.
230      * @param defaultValue The default value.
231      * @return The associated boolean.
232      *
233      * @throws ConversionException is thrown if the key maps to an
234      *         object that is not a Boolean.
235      */
236     boolean getBoolean(String key, boolean defaultValue);
237 
238     /***
239      * Get a {@link Boolean} associated with the given configuration key.
240      *
241      * @param key The configuration key.
242      * @param defaultValue The default value.
243      * @return The associated boolean if key is found and has valid
244      *         format, default value otherwise.
245      *
246      * @throws ConversionException is thrown if the key maps to an
247      *         object that is not a Boolean.
248      */
249     Boolean getBoolean(String key, Boolean defaultValue);
250 
251     /***
252      * Get a byte associated with the given configuration key.
253      *
254      * @param key The configuration key.
255      * @return The associated byte.
256      *
257      * @throws ConversionException is thrown if the key maps to an
258      *         object that is not a Byte.
259      */
260     byte getByte(String key);
261 
262     /***
263      * Get a byte associated with the given configuration key.
264      * If the key doesn't map to an existing object, the default value
265      * is returned.
266      *
267      * @param key The configuration key.
268      * @param defaultValue The default value.
269      * @return The associated byte.
270      *
271      * @throws ConversionException is thrown if the key maps to an
272      *         object that is not a Byte.
273      */
274     byte getByte(String key, byte defaultValue);
275 
276     /***
277      * Get a {@link Byte} associated with the given configuration key.
278      *
279      * @param key The configuration key.
280      * @param defaultValue The default value.
281      * @return The associated byte if key is found and has valid format, default
282      *         value otherwise.
283      *
284      * @throws ConversionException is thrown if the key maps to an object that
285      *         is not a Byte.
286      */
287     Byte getByte(String key, Byte defaultValue);
288 
289     /***
290      * Get a double associated with the given configuration key.
291      *
292      * @param key The configuration key.
293      * @return The associated double.
294      *
295      * @throws ConversionException is thrown if the key maps to an
296      *         object that is not a Double.
297      */
298     double getDouble(String key);
299 
300     /***
301      * Get a double associated with the given configuration key.
302      * If the key doesn't map to an existing object, the default value
303      * is returned.
304      *
305      * @param key The configuration key.
306      * @param defaultValue The default value.
307      * @return The associated double.
308      *
309      * @throws ConversionException is thrown if the key maps to an
310      *         object that is not a Double.
311      */
312     double getDouble(String key, double defaultValue);
313 
314     /***
315      * Get a {@link Double} associated with the given configuration key.
316      *
317      * @param key The configuration key.
318      * @param defaultValue The default value.
319      * @return The associated double if key is found and has valid
320      *         format, default value otherwise.
321      *
322      * @throws ConversionException is thrown if the key maps to an
323      *         object that is not a Double.
324      */
325     Double getDouble(String key, Double defaultValue);
326 
327     /***
328      * Get a float associated with the given configuration key.
329      *
330      * @param key The configuration key.
331      * @return The associated float.
332      * @throws ConversionException is thrown if the key maps to an
333      *         object that is not a Float.
334      */
335     float getFloat(String key);
336 
337     /***
338      * Get a float associated with the given configuration key.
339      * If the key doesn't map to an existing object, the default value
340      * is returned.
341      *
342      * @param key The configuration key.
343      * @param defaultValue The default value.
344      * @return The associated float.
345      *
346      * @throws ConversionException is thrown if the key maps to an
347      *         object that is not a Float.
348      */
349     float getFloat(String key, float defaultValue);
350 
351     /***
352      * Get a {@link Float} associated with the given configuration key.
353      * If the key doesn't map to an existing object, the default value
354      * is returned.
355      *
356      * @param key The configuration key.
357      * @param defaultValue The default value.
358      * @return The associated float if key is found and has valid
359      *         format, default value otherwise.
360      *
361      * @throws ConversionException is thrown if the key maps to an
362      *         object that is not a Float.
363      */
364     Float getFloat(String key, Float defaultValue);
365 
366     /***
367      * Get a int associated with the given configuration key.
368      *
369      * @param key The configuration key.
370      * @return The associated int.
371      *
372      * @throws ConversionException is thrown if the key maps to an
373      *         object that is not a Integer.
374      */
375     int getInt(String key);
376 
377     /***
378      * Get a int associated with the given configuration key.
379      * If the key doesn't map to an existing object, the default value
380      * is returned.
381      *
382      * @param key The configuration key.
383      * @param defaultValue The default value.
384      * @return The associated int.
385      *
386      * @throws ConversionException is thrown if the key maps to an
387      *         object that is not a Integer.
388      */
389     int getInt(String key, int defaultValue);
390 
391     /***
392      * Get an {@link Integer} associated with the given configuration key.
393      * If the key doesn't map to an existing object, the default value
394      * is returned.
395      *
396      * @param key The configuration key.
397      * @param defaultValue The default value.
398      * @return The associated int if key is found and has valid format, default
399      *         value otherwise.
400      *
401      * @throws ConversionException is thrown if the key maps to an object that
402      *         is not a Integer.
403      */
404     Integer getInteger(String key, Integer defaultValue);
405 
406     /***
407      * Get a long associated with the given configuration key.
408      *
409      * @param key The configuration key.
410      * @return The associated long.
411      *
412      * @throws ConversionException is thrown if the key maps to an
413      *         object that is not a Long.
414      */
415     long getLong(String key);
416 
417     /***
418      * Get a long associated with the given configuration key.
419      * If the key doesn't map to an existing object, the default value
420      * is returned.
421      *
422      * @param key The configuration key.
423      * @param defaultValue The default value.
424      * @return The associated long.
425      *
426      * @throws ConversionException is thrown if the key maps to an
427      *         object that is not a Long.
428      */
429     long getLong(String key, long defaultValue);
430 
431     /***
432      * Get a {@link Long} associated with the given configuration key.
433      * If the key doesn't map to an existing object, the default value
434      * is returned.
435      *
436      * @param key The configuration key.
437      * @param defaultValue The default value.
438      * @return The associated long if key is found and has valid
439      * format, default value otherwise.
440      *
441      * @throws ConversionException is thrown if the key maps to an
442      *         object that is not a Long.
443      */
444     Long getLong(String key, Long defaultValue);
445 
446     /***
447      * Get a short associated with the given configuration key.
448      *
449      * @param key The configuration key.
450      * @return The associated short.
451      *
452      * @throws ConversionException is thrown if the key maps to an
453      *         object that is not a Short.
454      */
455     short getShort(String key);
456 
457     /***
458      * Get a short associated with the given configuration key.
459      *
460      * @param key The configuration key.
461      * @param defaultValue The default value.
462      * @return The associated short.
463      *
464      * @throws ConversionException is thrown if the key maps to an
465      *         object that is not a Short.
466      */
467     short getShort(String key, short defaultValue);
468 
469     /***
470      * Get a {@link Short} associated with the given configuration key.
471      * If the key doesn't map to an existing object, the default value
472      * is returned.
473      *
474      * @param key The configuration key.
475      * @param defaultValue The default value.
476      * @return The associated short if key is found and has valid
477      *         format, default value otherwise.
478      *
479      * @throws ConversionException is thrown if the key maps to an
480      *         object that is not a Short.
481      */
482     Short getShort(String key, Short defaultValue);
483 
484     /***
485      * Get a {@link BigDecimal} associated with the given configuration key.
486      *
487      * @param key The configuration key.
488      * @return The associated BigDecimal if key is found and has valid format
489      */
490     BigDecimal getBigDecimal(String key);
491 
492     /***
493      * Get a {@link BigDecimal} associated with the given configuration key.
494      * If the key doesn't map to an existing object, the default value
495      * is returned.
496      *
497      * @param key          The configuration key.
498      * @param defaultValue The default value.
499      *
500      * @return The associated BigDecimal if key is found and has valid
501      *         format, default value otherwise.
502      */
503     BigDecimal getBigDecimal(String key, BigDecimal defaultValue);
504 
505     /***
506      * Get a {@link BigInteger} associated with the given configuration key.
507      *
508      * @param key The configuration key.
509      *
510      * @return The associated BigInteger if key is found and has valid format
511      */
512     BigInteger getBigInteger(String key);
513 
514     /***
515      * Get a {@link BigInteger} associated with the given configuration key.
516      * If the key doesn't map to an existing object, the default value
517      * is returned.
518      *
519      * @param key          The configuration key.
520      * @param defaultValue The default value.
521      *
522      * @return The associated BigInteger if key is found and has valid
523      *         format, default value otherwise.
524      */
525     BigInteger getBigInteger(String key, BigInteger defaultValue);
526 
527     /***
528      * Get a string associated with the given configuration key.
529      *
530      * @param key The configuration key.
531      * @return The associated string.
532      *
533      * @throws ConversionException is thrown if the key maps to an object that
534      *         is not a String.
535      */
536     String getString(String key);
537 
538     /***
539      * Get a string associated with the given configuration key.
540      * If the key doesn't map to an existing object, the default value
541      * is returned.
542      *
543      * @param key The configuration key.
544      * @param defaultValue The default value.
545      * @return The associated string if key is found and has valid
546      *         format, default value otherwise.
547      *
548      * @throws ConversionException is thrown if the key maps to an object that
549      *         is not a String.
550      */
551     String getString(String key, String defaultValue);
552 
553     /***
554      * Get an array of strings associated with the given configuration key.
555      * If the key doesn't map to an existing object an empty array is returned
556      *
557      * @param key The configuration key.
558      * @return The associated string array if key is found.
559      *
560      * @throws ConversionException is thrown if the key maps to an
561      *         object that is not a String/List of Strings.
562      */
563     String[] getStringArray(String key);
564 
565     /***
566      * Get a List of strings associated with the given configuration key.
567      * If the key doesn't map to an existing object an empty List is returned.
568      *
569      * @param key The configuration key.
570      * @return The associated List.
571      *
572      * @throws ConversionException is thrown if the key maps to an
573      *         object that is not a List.
574      */
575     List getList(String key);
576 
577     /***
578      * Get a List of strings associated with the given configuration key.
579      * If the key doesn't map to an existing object, the default value
580      * is returned.
581      *
582      * @param key The configuration key.
583      * @param defaultValue The default value.
584      * @return The associated List of strings.
585      *
586      * @throws ConversionException is thrown if the key maps to an
587      *         object that is not a List.
588      */
589     List getList(String key, List defaultValue);
590 }