A Map based Configuration.
This implementation of the
Configuration interface is
initialized with a
java.util.Map. The methods of the
Configuration interface are implemented on top of the content of
this map. The following storage scheme is used:
Property keys are directly mapped to map keys, i.e. the
getProperty() method directly performs a
get() on
the map. Analogously,
setProperty() or
addProperty() operations write new data into the map. If a value
is added to an existing property, a
java.util.List is created,
which stores the values of this property.
An important use case of this class is to treat a map as a
Configuration allowing access to its data through the richer
interface. This can be a bit problematic in some cases because the map may
contain values that need not adhere to the default storage scheme used by
typical configuration implementations, e.g. regarding lists. In such cases
care must be taken when manipulating the data through the
Configuration interface, e.g. by calling
addProperty(); results may be different than expected.
The handling of list delimiters is a bit different for this configuration
implementation: When a property of type String is queried, it is passed to
the current
org.apache.commons.configuration2.convert.ListDelimiterHandler which may generate multiple values.
Note that per default a list delimiter handler is set which does not do any
list splitting, so this feature is disabled. It can be enabled by setting
a properly configured
ListDelimiterHandler implementation, e.g. a
org.apache.commons.configuration2.convert.DefaultListDelimiterHandler object.
Notice that list splitting is only performed for single string values. If a
property has multiple values, the single values are not split even if they
contain the list delimiter character.
As the underlying
Map is directly used as store of the property
values, the thread-safety of this
Configuration implementation
depends on the map passed to the constructor.
Notes about type safety: For properties with multiple values this implementation
creates lists of type
Object and stores them. If a property is assigned
another value, the value is added to the list. This can cause problems if the
map passed to the constructor already contains lists of other types. This
should be avoided, otherwise it cannot be guaranteed that the application
might throw
ClassCastException exceptions later.