T - the type of the nodes used by this hierarchical configurationpublic interface HierarchicalConfiguration<T> extends Configuration, ImmutableHierarchicalConfiguration, NodeModelSupport<T>
An interface for mutable hierarchical configurations.
This interface introduces methods for manipulating tree-like structured
configuration sources. Also, all methods defined by the Configuration
interface are available.
This interface does not make any assumptions about the concrete type of nodes used by an implementation; this is reflected by a generic type parameter. Concrete implementations may therefore define their own hierarchical structures.
| Modifier and Type | Method and Description |
|---|---|
void |
addNodes(String key,
Collection<? extends T> nodes)
Adds a collection of nodes at the specified position of the configuration
tree.
|
List<HierarchicalConfiguration<T>> |
childConfigurationsAt(String key)
Returns a list with sub configurations for all child nodes of the node
selected by the given key.
|
List<HierarchicalConfiguration<T>> |
childConfigurationsAt(String key,
boolean supportUpdates)
Returns a list with sub configurations for all child nodes of the node
selected by the given key allowing the caller to specify the
supportUpdates flag. |
void |
clearTree(String key)
Removes all values of the property with the given name and of keys that
start with this name.
|
HierarchicalConfiguration<T> |
configurationAt(String key)
Returns a hierarchical subnode configuration for the node specified by
the given key.
|
HierarchicalConfiguration<T> |
configurationAt(String key,
boolean supportUpdates)
Returns a hierarchical sub configuration object that wraps the
configuration node specified by the given key.
|
List<HierarchicalConfiguration<T>> |
configurationsAt(String key)
Returns a list of sub configurations for all configuration nodes selected
by the given key.
|
List<HierarchicalConfiguration<T>> |
configurationsAt(String key,
boolean supportUpdates)
Returns a list of sub configurations for all configuration nodes selected
by the given key allowing the caller to specify the
supportUpdates flag. |
void |
setExpressionEngine(ExpressionEngine expressionEngine)
Sets the expression engine to be used by this configuration.
|
addProperty, clear, clearProperty, getInterpolator, installInterpolator, setInterpolator, setProperty, subsetgetSynchronizer, lock, setSynchronizer, unlockgetExpressionEngine, getMaxIndex, getRootElementName, immutableChildConfigurationsAt, immutableConfigurationAt, immutableConfigurationAt, immutableConfigurationsAtcontainsKey, get, get, getArray, getArray, getBigDecimal, getBigDecimal, getBigInteger, getBigInteger, getBoolean, getBoolean, getBoolean, getByte, getByte, getByte, getCollection, getCollection, getDouble, getDouble, getDouble, getEncodedString, getEncodedString, getFloat, getFloat, getFloat, getInt, getInt, getInteger, getKeys, getKeys, getList, getList, getList, getList, getLong, getLong, getLong, getProperties, getProperty, getShort, getShort, getShort, getString, getString, getStringArray, immutableSubset, isEmpty, sizegetNodeModelvoid setExpressionEngine(ExpressionEngine expressionEngine)
expressionEngine - the new expression engine; can be null,
then the default expression engine will be usedvoid addNodes(String key, Collection<? extends T> nodes)
addProperty(), but
instead of a single property a whole collection of nodes can be added -
and thus complete configuration sub trees. E.g. with this method it is
possible to add parts of another BaseHierarchicalConfiguration
object to this object. If the passed in key refers to
an existing and unique node, the new nodes are added to this node.
Otherwise a new node will be created at the specified position in the
hierarchy.key - the key where the nodes are to be added; can be null ,
then they are added to the root nodenodes - a collection with the Node objects to be
addedHierarchicalConfiguration<T> configurationAt(String key, boolean supportUpdates)
Returns a hierarchical sub configuration object that wraps the
configuration node specified by the given key. This method provides an
easy means of accessing sub trees of a hierarchical configuration. In the
returned configuration the sub tree can directly be accessed, it becomes
the root node of this configuration. Because of this the passed in key
must select exactly one configuration node; otherwise an
IllegalArgumentException will be thrown.
The difference between this method and the
Configuration.subset(String) method is that
subset() supports arbitrary subsets of configuration nodes
while configurationAt() only returns a single sub tree.
Please refer to the documentation of the
SubnodeConfiguration class to obtain further information
about sub configurations and when they should be used.
With the supportUpdate flag the behavior of the returned
sub configuration regarding updates of its parent
configuration can be determined. If set to false, the configurations
return on independent nodes structures. So changes made on one configuration
cannot be seen by the other one. A value of true in contrast creates
a direct connection between both configurations - they are then using the
same underlying data structures as much as possible. There are however changes
which break this connection; for instance, if the sub tree the sub configuration
belongs to is completely removed from the parent configuration. If such a
change happens, the sub configuration becomes detached from its parent.
It can still be used in a normal way, but changes on it are not reflected
by the parent and vice verse. Also, it is not possible to reattach a once
detached sub configuration.
key - the key that selects the sub treesupportUpdates - a flag whether the returned sub configuration
should be directly connected to its parentSubnodeConfigurationHierarchicalConfiguration<T> configurationAt(String key)
configurationAt(key,
<b>false</b>).key - the key that selects the sub treeSubnodeConfigurationList<HierarchicalConfiguration<T>> configurationsAt(String key)
ExpressionEngine) and then create a sub configuration for
each returned node (like configurationAt(String) ). This is
especially useful when dealing with list-like structures. As an example
consider the configuration that contains data about database tables and
their fields. If you need access to all fields of a certain table, you
can simply do
List fields = config.configurationsAt("tables.table(0).fields.field");
for(Iterator it = fields.iterator(); it.hasNext();)
{
BaseHierarchicalConfiguration sub = (BaseHierarchicalConfiguration) it.next();
// now the children and attributes of the field node can be
// directly accessed
String fieldName = sub.getString("name");
String fieldType = sub.getString("type");
...
The configuration objects returned are not connected to
the parent configuration.key - the key for selecting the desired nodesList<HierarchicalConfiguration<T>> configurationsAt(String key, boolean supportUpdates)
supportUpdates flag. This method works like
configurationsAt(String), but with the additional boolean
parameter it can be specified whether the returned configurations react
on updates of the parent configuration.key - the key for selecting the desired nodessupportUpdates - a flag whether the returned sub configuration
should be directly connected to its parentconfigurationsAt(String, boolean)List<HierarchicalConfiguration<T>> childConfigurationsAt(String key)
ImmutableHierarchicalConfiguration.immutableChildConfigurationsAt(String), but returns a list with
mutable configuration objects. The configuration objects returned are
not connected to the parent configuration.key - the key for selecting the desired parent nodeHierarchicalConfiguration objects for all
child nodes of the selected parent nodeList<HierarchicalConfiguration<T>> childConfigurationsAt(String key, boolean supportUpdates)
supportUpdates flag.key - the key for selecting the desired parent nodesupportUpdates - a flag whether the returned sub configuration
should be directly connected to its parentHierarchicalConfiguration objects for
all child nodes of the selected parent nodevoid clearTree(String key)
clearTree("foo") would remove both properties.key - the key of the property to be removedCopyright © 2001–2020 The Apache Software Foundation. All rights reserved.