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, subset
getSynchronizer, lock, setSynchronizer, unlock
getExpressionEngine, getMaxIndex, getRootElementName, immutableChildConfigurationsAt, immutableConfigurationAt, immutableConfigurationAt, immutableConfigurationsAt
containsKey, get, get, getArray, getArray, getBigDecimal, getBigDecimal, getBigInteger, getBigInteger, getBoolean, getBoolean, getBoolean, getByte, getByte, getByte, getCollection, getCollection, getDouble, getDouble, getDouble, getDuration, getDuration, getEncodedString, getEncodedString, getEnum, getEnum, 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, size
getNodeModel
void 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 parentSubnodeConfiguration
HierarchicalConfiguration<T> configurationAt(String key)
configurationAt(key,
<b>false</b>)
.key
- the key that selects the sub treeSubnodeConfiguration
List<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–2022 The Apache Software Foundation. All rights reserved.