# All Classes and Interfaces

Class
Description
AbsoluteNameLocationStrategy
A specialized implementation of `FileLocationStrategy` which checks whether the provided file name is already an absolute file name.
AbstractConfiguration
Abstract configuration class.
AbstractHierarchicalConfiguration<T>
A specialized configuration class that extends its base class by the ability of keeping more structure in the stored properties.
AbstractListDelimiterHandler
An abstract base class for concrete `ListDelimiterHandler` implementations.
AbstractYAMLBasedConfiguration
A base class for configuration implementations based on YAML structures.
AppletConfiguration
A configuration wrapper to read applet parameters.
BaseConfiguration
Basic configuration class.
BaseConfigurationBuilderProvider
A fully-functional, reflection-based implementation of the `ConfigurationBuilderProvider` interface which can deal with the default tags defining configuration sources.
BaseConfigurationXMLReader
A specialized SAX2 XML parser that processes configuration objects.
BaseEventSource
A base class for objects that can generate configuration events.
BaseHierarchicalConfiguration
A specialized hierarchical configuration implementation that is based on a structure of `ImmutableNode` objects.
BaseHierarchicalConfiguration.BuilderVisitor
A specialized visitor base class that can be used for storing the tree of configuration nodes.
BasePathLocationStrategy
A specialized implementation of `FileLocationStrategy` which tries to construct a file path from the locator's base path and file name.
BasicBuilderParameters
An implementation of `BuilderParameters` which handles the parameters of a `ConfigurationBuilder` common to all concrete `Configuration` implementations.
BasicBuilderProperties<T>
Definition of a properties interface for basic parameters which are supported by all `ConfigurationBuilder` implementations derived from `BasicConfigurationBuilder`.
BasicConfigurationBuilder<T extends ImmutableConfiguration>
An implementation of the `ConfigurationBuilder` interface which is able to create different concrete `ImmutableConfiguration` implementations based on reflection.
BeanCreationContext
Definition of a context object storing all required information for the creation of a bean.
BeanDeclaration
Definition of an interface for declaring a bean in a configuration file.
BeanFactory
Definition of an interface for bean factories.
BeanHelper
A helper class for creating bean instances that are defined in configuration files.
BuilderConfigurationWrapperFactory
A class that allows the creation of configuration objects wrapping a `ConfigurationBuilder`.
BuilderConfigurationWrapperFactory.EventSourceSupport
An enumeration class with different options for supporting the `EventSource` interface in generated `ImmutableConfiguration` proxies.
BuilderParameters
An interface to be implemented by objects which can be used to parameterize a `ConfigurationBuilder`.
CatalogResolver
Thin wrapper around xml commons CatalogResolver to allow list of catalogs to be provided.
CatalogResolver.Catalog
Overrides the Catalog implementation to use the underlying FileSystem.
CatalogResolver.CatalogManager
Extends the CatalogManager to make the FileSystem and base directory accessible.
ClasspathLocationStrategy
A specialized `FileLocationStrategy` implementation which searches for files on the class path.
CombinedBeanDeclaration
A special implementation of the `BeanDeclaration` interface which allows combining multiple `BeanDeclaration` objects.
CombinedBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties of a builder for a combined configuration.
CombinedBuilderParametersImpl
A specialized parameters object for a `CombinedConfigurationBuilder`.
CombinedBuilderProperties<T>
Definition of a properties interface for the parameters of a combined configuration builder.
CombinedConfiguration
A hierarchical composite configuration class.
CombinedConfigurationBuilder
A specialized `ConfigurationBuilder` implementation that creates a `CombinedConfiguration` from multiple configuration sources defined by an XML-based configuration definition file.
CombinedConfigurationBuilderProvider
A specialized `ConfigurationBuilderProvider` implementation which deals with combined configuration builders.
CombinedLocationStrategy
A specialized implementation of a `FileLocationStrategy` which encapsulates an arbitrary number of `FileLocationStrategy` objects.
CombinedReloadingController
A specialized `ReloadingController` implementation which manages an arbitrary number of other `ReloadingController` objects.
CompositeConfiguration
`CompositeConfiguration` allows you to add multiple `Configuration` objects to an aggregated configuration.
Configuration
The main Configuration interface.
ConfigurationBuilder<T extends ImmutableConfiguration>
Definition of an interface for objects that can create `ImmutableConfiguration` or `Configuration` objects of a specific type.
ConfigurationBuilderEvent
A base event class for events generated by a `ConfigurationBuilder`.
ConfigurationBuilderProvider
An interface for creating builders for configuration sources of a `CombinedConfigurationBuilder`.
ConfigurationBuilderResultCreatedEvent
A specialized event class which is generated by a `ConfigurationBuilder` when a result configuration has been created.
ConfigurationComparator
Comparator for configurations interface.
ConfigurationConsumer<T>
A Configuration task that may throw a ConfigurationException.
ConfigurationConverter
Configuration converter.
ConfigurationDeclaration
A specialized `BeanDeclaration` implementation that represents the declaration of a configuration source.
ConfigurationDecoder
An interface for decoding encoded values from a configuration source.
ConfigurationDynaBean
The `ConfigurationDynaBean` dynamically reads and writes configurations properties from a wrapped configuration-collection `Configuration` instance.
ConfigurationDynaClass
The `ConfigurationDynaClass` dynamically determines properties for a `ConfigurationDynaBean` from a wrapped configuration-collection `Configuration` instance.
ConfigurationErrorEvent
An event class that is used for reporting errors that occurred while processing configuration properties.
ConfigurationEvent
An event class for reporting updates on a configuration object.
ConfigurationException
Any exception that occurs while initializing a Configuration object.
ConfigurationInterpolator
A class that handles interpolation (variable substitution) for configuration objects.
ConfigurationLogger
A class providing basic logging capabilities.
ConfigurationLookup
A specialized implementation of the `Lookup` interface which uses a `Configuration` object to resolve variables.
ConfigurationMap
The `ConfigurationMap` wraps a configuration-collection `Configuration` instance to provide a `Map` interface.
ConfigurationNodePointerFactory
Implementation of the `NodePointerFactory` interface for configuration nodes.
ConfigurationNodeVisitor<T>
Definition of a Visitor interface for a configuration node structure.
ConfigurationNodeVisitorAdapter<T>
A simple adapter class that simplifies writing custom node visitor implementations.
ConfigurationPropertiesFactoryBean
FactoryBean which wraps a Commons CompositeConfiguration object for usage with PropertiesLoaderSupport.
ConfigurationPropertySource
Allow use of Apache Commons Configuration Objects as Spring PropertySources
ConfigurationRuntimeException
A configuration related runtime exception.
Configurations
A convenience class which simplifies the creation of standard configurations and their builders.
ConfigurationUtils
Miscellaneous utility methods for configurations.
ConfigurationXMLReader
A base class for "faked" `XMLReader` classes that transform a configuration object in a set of SAX parsing events.
ConstantLookup
Looks up constant fields in classes.
ConstructorArg
A class representing an argument for a constructor invocation to be used by a `BeanDeclaration`.
ConversionException
Thrown when a property is incompatible with the type requested.
ConversionHandler
An interface defining the possible data type conversions supported by the configuration framework.
CopyObjectDefaultHandler
A specialized implementation of `DefaultParametersHandler` that copies the properties of a `BuilderParameters` object (passed at construction time) onto the object to be initialized.
DatabaseBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties for a database configuration.
DatabaseBuilderParametersImpl
A specialized parameters object for database configurations.
DatabaseBuilderProperties<T>
Definition of a properties interface for parameters of a database configuration.
DatabaseConfiguration
Configuration stored in a database.
DataConfiguration
Decorator providing additional getters for any Configuration.
DefaultBeanFactory
The default implementation of the `BeanFactory` interface.
DefaultConfigurationKey
A simple class that supports creation of and iteration on configuration keys supported by a `DefaultExpressionEngine` object.
DefaultConversionHandler
A default implementation of the `ConversionHandler` interface.
DefaultEntityResolver
The DefaultEntityResolver used by XML Configurations.
DefaultExpressionEngine
A default implementation of the `ExpressionEngine` interface providing the "native" expression language for hierarchical configurations.
DefaultExpressionEngineSymbols
A class representing the various symbols that are supported in keys recognized by `DefaultExpressionEngine`.
DefaultExpressionEngineSymbols.Builder
A builder class for creating instances of `DefaultExpressionEngineSymbols`.
DefaultFileSystem
FileSystem that uses java.io.File or HttpClient.
DefaultListDelimiterHandler
The default implementation of the `ListDelimiterHandler` interface.
DefaultLookups
An enumeration class defining constants for built-in `Lookup` objects available for `Configuration` instances.
DefaultParametersHandler<T>
Definition of an interface for setting default values for specific configuration parameter objects.
DefaultParametersManager
A class for managing a set of `DefaultParametersHandler` objects.
DefaultReloadingDetectorFactory
A default implementation of the `ReloadingDetectorFactory` interface.
DisabledListDelimiterHandler
A specialized implementation of the `ListDelimiterHandler` interface which disables list splitting.
DummyLookup
A simple dummy `Lookup` implementation.
DynamicCombinedConfiguration
DynamicCombinedConfiguration allows a set of CombinedConfigurations to be used.
EntityRegistry
Interface used for registering and retrieving PUBLICID to URL mappings.
EntityResolverSupport
Interface that identifies the class as using an EntityResolver
EnvironmentConfiguration
A Configuration implementation that reads the platform specific environment variables using the map returned by `System.getenv()`.
EnvironmentLookup
Deprecated.
Use `DefaultLookups.ENVIRONMENT`.
Event
The base class for all events generated by this library.
EventListener<T extends Event>
Definition of a generic event listener interface.
EventListenerList
A class for managing event listeners for an event source.
EventListenerList.EventListenerIterator<T extends Event>
A special `Iterator` implementation used by the `getEventListenerIterator()` method.
EventListenerParameters
A specialized parameters implementation for `BasicConfigurationBuilder` which allows for a convenient event listener initialization.
EventListenerProvider
Definition of an interface that is evaluated by a `ConfigurationBuilder` to initialize event listeners.
EventListenerRegistrationData<T extends Event>
A data class holding information about an event listener registration.
EventSource
An interface for configuration implementations which support registration of event listeners.
EventType<T extends Event>
A class representing an event type.
ExpressionEngine
Definition of an interface for evaluating keys for hierarchical configurations.
ExprLookup
Lookup that allows expressions to be evaluated.
ExprLookup.Variable
The key and corresponding object that will be made available to the JexlContext for use in expressions.
ExprLookup.Variables
List wrapper used to allow the Variables list to be created as beans in DefaultConfigurationBuilder.
FileBased
Definition of an interface to be implemented by objects which know how to read and write themselves from or to a character stream.
FileBasedBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties of a configuration of a file-based configuration builder.
FileBasedBuilderParametersImpl
An implementation of `BuilderParameters` which contains parameters related to `Configuration` implementations that are loaded from files.
FileBasedBuilderProperties<T>
Definition of a properties interface for parameters of file-based configurations.
FileBasedConfiguration
An interface which combines the `FileBased` and `Configuration` interfaces.
FileBasedConfigurationBuilder<T extends FileBasedConfiguration>
A specialized `ConfigurationBuilder` implementation which can handle configurations read from a `FileHandler`.
FileExtensionConfigurationBuilderProvider
A specialized implementation of `ConfigurationBuilderProvider` which determines the name of the result configuration class based on the extension of the file to load.
FileHandler
A class that manages persistence of an associated `FileBased` object.
FileHandlerListener
A listener interface for receiving notifications about updates of a `FileHandler`.
FileHandlerListenerAdapter
An adapter class simplifying the implementation of custom `FileHandlerListener` classes.
FileHandlerReloadingDetector
A specialized implementation of `ReloadingDetector` which monitors a file specified by a `FileHandler`.
FileLocationStrategy
An interface allowing applications to customize the process of locating a file.
FileLocator
A class describing the location of a file.
FileLocator.FileLocatorBuilder
A typical builder implementation for creating `FileLocator` objects.
FileLocatorAware
Definition of an interface to be implemented by `FileBased` objects which need access to the current `FileLocator`.
FileLocatorUtils
A utility class providing helper methods related to locating files.
FileOptionsProvider
Some FileSystems allow options to be passed on File operations.
FileSystem
Abstract layer to allow various types of file systems.
FileSystemLocationStrategy
A specialized implementation of `FileLocationStrategy` which uses the passed in `FileSystem` to locate a file.
HierarchicalBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties for a hierarchical configuration.
HierarchicalBuilderParametersImpl
A specialized parameters object for hierarchical configurations.
HierarchicalBuilderProperties<T>
Definition of a parameters interface for hierarchical configurations.
HierarchicalConfiguration<T>
An interface for mutable hierarchical configurations.
HierarchicalConfigurationXMLReader<T>
A specialized SAX2 XML parser that "parses" hierarchical configuration objects.
HomeDirectoryLocationStrategy
A specialized implementation of `FileLocationStrategy` which searches for files in the user's home directory or another special configurable directory.
ImmutableConfiguration
The main interface for accessing configuration data in a read-only fashion.
ImmutableHierarchicalConfiguration
An interface for immutable hierarchical configurations.
ImmutableNode
An immutable default implementation for configuration nodes.
ImmutableNode.Builder
A builder class for creating instances of `ImmutableNode`.
INIBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties for a INI configuration.
INIBuilderParametersImpl
A specialized parameters class for INI configuration.
INIBuilderProperties<T>
Definition of a parameters interface for INI configurations.
INIConfiguration
A specialized hierarchical configuration implementation for parsing ini files.
INIConfiguration.Builder
Builds instances of INIConfiguration.
Initializable
Definition of an interface to be implemented by `Configuration` implementations which support a special initialization method.
InMemoryNodeModel
A specialized node model implementation which operates on `ImmutableNode` structures.
InMemoryNodeModelSupport
A specialized version of the `NodeModelSupport` interface which allows querying an `InMemoryNodeModel`.
InputStreamSupport
Definition of an interface to be implemented by objects which support reading from an input stream.
InterpolatorSpecification
A simple value class defining a `ConfigurationInterpolator`.
InterpolatorSpecification.Builder
A builder class for creating instances of `InterpolatorSpecification`.
JndiBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties for a JNDI configuration.
JndiBuilderParametersImpl
A specialized parameters object for JNDI configurations.
JndiBuilderProperties<T>
Definition of a properties interface for parameters of a JNDI configuration.
JNDIConfiguration
This Configuration class allows you to interface with a JNDI datasource.
JSONConfiguration
A specialized hierarchical configuration class that is able to parse JSON documents.
LegacyListDelimiterHandler
A specialized implementation of `ListDelimiterHandler` which simulates the list delimiter handling as it was used by `PropertiesConfiguration` in Commons Configuration 1.x.
ListDelimiterHandler
Definition of an interface that controls the handling of list delimiters in configuration properties.
LockMode
An enumeration used by `SynchronizerSupport` to specify how an object is locked.
Lookup
Definition of an interface for looking up variables during interpolation.
ManagedReloadingDetector
A strategy to reload configuration based on management requests.
ManagedReloadingDetectorMBean
MBean definition for managing configuration reload.
MapConfiguration
A Map based Configuration.
MergeCombiner
A specialized implementation of the `NodeCombiner` interface that performs a merge from two passed in node hierarchies.
MultiFileBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties of a builder managing multiple file-based configurations.
MultiFileBuilderParametersImpl
A specialized parameters object for `MultiFileConfigurationBuilder`.
MultiFileBuilderProperties<T>
Definition of a properties interface for the parameters of a multiple file configuration builder.
MultiFileConfigurationBuilder<T extends FileBasedConfiguration>
A specialized `ConfigurationBuilder` implementation providing access to multiple file-based configurations based on a file name pattern.
MultiFileConfigurationBuilderProvider
A specialized `ConfigurationBuilderProvider` implementation for integrating `MultiFileConfigurationBuilder` with `CombinedConfigurationBuilder`.
NodeAddData<T>
A simple data class used by `ExpressionEngine` to store the results of the `prepareAdd()` operation.
NodeCombiner
A base class for node combiner implementations.
NodeHandler<T>
Definition of an interface for accessing the data of a configuration node.
NodeHandlerDecorator<T>
An abstract base class for decorators of a `NodeHandler`.
NodeKeyResolver<T>
Definition of an interface which allows resolving a (property) key for different manipulating operations.
NodeMatcher<C>
An interface for matching nodes based on specific criteria.
NodeModel<T>
Definition of an interface describing a model based on a nodes structure.
NodeModelSupport<T>
An interface to be implemented by objects that support a `NodeModel`.
NodeNameMatchers
An enumeration class with several pre-defined `NodeMatcher` implementations based on node names.
NodeSelector
A class for selecting a specific node based on a key or a set of keys.
NodeTreeWalker
A class providing different algorithms for traversing a hierarchy of configuration nodes.
NodeUpdateData<T>
A simple data class used by node models to store parameters of an update operation.
NoOpSynchronizer
An implementation of the `Synchronizer` interface which does not perform any synchronization.
OverrideCombiner
A concrete combiner implementation that is able to construct an override combination.
Parameters
A convenience class for creating parameter objects for initializing configuration builder objects.
ParseException
This exception is thrown when parse errors are encountered.
PatternSubtreeConfigurationWrapper
Wraps a BaseHierarchicalConfiguration and allows subtrees to be accessed via a configured path with replaceable tokens derived from the ConfigurationInterpolator.
PeriodicReloadingTrigger
A timer-based trigger for reloading checks.
PropertiesBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties for a properties configuration.
PropertiesBuilderParametersImpl
A specialized parameter class for configuring `PropertiesConfiguration` instances.
PropertiesBuilderProperties<T>
Definition of a parameters interface for properties configurations.
PropertiesConfiguration
This is the "classic" Properties loader which loads the values from a single or multiple files (which can be chained with "include =".
PropertiesConfiguration.DefaultIOFactory
A default implementation of the `IOFactory` interface.
PropertiesConfiguration.IOFactory
Definition of an interface that allows customization of read and write operations.
PropertiesConfiguration.JupIOFactory
An alternative `PropertiesConfiguration.IOFactory` that tries to mimic the behavior of `Properties` (Jup) more closely.
PropertiesConfiguration.JupPropertiesReader
A `PropertiesConfiguration.PropertiesReader` that tries to mimic the behavior of `Properties`.
PropertiesConfiguration.JupPropertiesWriter
A `PropertiesConfiguration.PropertiesWriter` that tries to mimic the behavior of `Properties`.
PropertiesConfiguration.PropertiesReader
This class is used to read properties lines.
PropertiesConfiguration.PropertiesWriter
This class is used to write properties lines.
PropertiesConfigurationLayout
A helper class used by `PropertiesConfiguration` to keep the layout of a properties file.
PropertyConverter
A utility class to convert the configuration properties into any type.
PropertyListConfiguration
NeXT / OpenStep style configuration.
PropertyListParserConstants
Token literal values and constants.
PropertyListParserTokenManager
Token Manager.
ProvidedURLLocationStrategy
A specialized implementation of `FileLocationStrategy` which checks whether a passed in `FileLocator` already has a defined URL.
QueryResult<T>
A data class representing a single query result produced by an `ExpressionEngine`.
ReadWriteSynchronizer
A special implementation of `Synchronizer` based on the JDK's `ReentrantReadWriteLock` class.
ReferenceNodeHandler
An extension of the `NodeHandler` interface which allows access to so-called references stored for a node.
ReloadingCombinedConfigurationBuilder
An extension of `CombinedConfigurationBuilder` which also supports reloading operations.
ReloadingController
A class for adding support for reload operations in a generic way.
ReloadingControllerSupport
Definition of an interface to be implemented by components which support reloading operations managed by a `ReloadingController`.
ReloadingDetector
An interface to be implemented by objects which can detect whether a reload operation is required.
ReloadingDetectorFactory
Definition of an interface for objects which can create a `ReloadingDetector`.
ReloadingEvent
An event that is fired when a reload operation is required.
ReloadingFileBasedConfigurationBuilder<T extends FileBasedConfiguration>
A specialized `ConfigurationBuilder` implementation which can handle configurations read from a `FileHandler` and supports reloading.
ReloadingMultiFileConfigurationBuilder<T extends FileBasedConfiguration>
A specialized `MultiFileConfigurationBuilder` implementation which adds support for reloading.
ServletConfiguration
A configuration wrapper around a `ServletConfig`.
ServletContextConfiguration
A configuration wrapper to read the initialization parameters of a servlet context.
ServletFilterConfiguration
A configuration wrapper around a `FilterConfig`.
ServletRequestConfiguration
A configuration wrapper to read the parameters of a servlet request.
SimpleCharStream
An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).
StrictConfigurationComparator
Strict comparator for configurations.
SubnodeConfiguration
A specialized hierarchical configuration class with a node model that uses a tracked node of another node model as its root node.
SubsetConfiguration
A subset of another configuration.
Synchronizer
An interface controlling synchronization of configuration instances.
SynchronizerSupport
Definition of an interface for objects that can be associated with a `Synchronizer`.
SystemConfiguration
A configuration based on the system properties.
SystemPropertiesLookup
Deprecated.
Use `DefaultLookups.SYSTEM_PROPERTIES`.
Token
Describes the input token stream.
TokenMgrError
Token Manager Error.
TrackedNodeModel
A specialized `NodeModel` implementation that uses a tracked node managed by an `InMemoryNodeModel` object as root node.
TreeUtils
Utility methods.
UnionCombiner
A specialized implementation of the `NodeCombiner` interface that constructs a union from two passed in node hierarchies.
URLConnectionOptions
Carries options and operates on `URLConnection`.
ValueTransformer
Definition of an interface used by `ListDelimiterHandler` to perform additional transformations on behalf of a configuration when a property value is escaped.
VerifiableOutputStream
OutputStream that can be checked for errors after it is written to.
VFSFileHandlerReloadingDetector
A file-based reloading strategy that uses Commons VFS to determine when a file was changed.
VFSFileSystem
FileSystem that uses Apache Commons VFS.
XMLBeanDeclaration
An implementation of the `BeanDeclaration` interface that is suitable for XML configuration files.
XMLBuilderParameters
Definition of a parameters interface providing a fluent API for setting all properties for a XML configuration.
XMLBuilderParametersImpl
A specialized parameters class for XML configuration.
XMLBuilderProperties<T>
Definition of a parameters interface for XML configurations.
XMLConfiguration
A specialized hierarchical configuration class that is able to parse XML documents.
XMLPropertiesConfiguration
This configuration implements the XML properties format introduced in Java, see https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html.
XMLPropertyListConfiguration
Property list file (plist) in XML FORMAT as used by macOS X (http://www.apple.com/DTDs/PropertyList-1.0.dtd).
XPathExpressionEngine
A specialized implementation of the `ExpressionEngine` interface that is able to evaluate XPATH expressions.
YAMLConfiguration
A specialized hierarchical configuration class that is able to parse YAML documents.