All Classes and Interfaces
Class
Description
Abstract configuration class.
Partial implementation of the
FileConfiguration interface.Base class for implementing file based hierarchical configurations.
A configuration wrapper to read applet parameters.
Basic configuration class.
A specialized SAX2 XML parser that processes configuration objects.
Definition of an interface for declaring a bean in a configuration file.
Definition of an interface for bean factories.
A helper class for creating bean instances that are defined in configuration
files.
Thin wrapper around xml commons CatalogResolver to allow list of catalogs
to be provided.
Overrides the Catalog implementation to use the underlying FileSystem.
Extend the CatalogManager to make the FileSystem and base directory accessible.
A hierarchical composite configuration class.
CompositeConfiguration allows you to add multiple Configuration
objects to an aggregated configuration.The main Configuration interface.
Definition of an interface for objects that can create a configuration.
Comparator for configurations interface.
Configuration converter.
The ConfigurationDynaBean dynamically reads and writes
configurations properties from a wrapped configuration-collection
Configuration instance.The ConfigurationDynaClass dynamically determines properties for
a
ConfigurationDynaBean from a wrapped configuration-collection
Configuration instance.
An event class that is used for reporting errors that occurred while
processing configuration properties.
An event listener interface to be implemented by observers that are
interested in internal errors caused by processing of configuration
properties.
An event class for reporting updates on a configuration object.
Any exception that occurs while initializing a Configuration
object.
Deprecated.
A simple data class that holds all information about a configuration
from the
<additional> section.An internally used helper class for constructing the composite
configuration object.
A class that handles interpolation (variable substitution) for configuration
objects.
Deprecated.
Use
DefaultConfigurationKey
instead.
A simple event listener interface for configuration observers.
The
ConfigurationMap wraps a
configuration-collection
Configuration
instance to provide a Map interface.
Definition of an interface for the nodes of a hierarchical configuration.
Implementation of the
NodePointerFactory interface for
configuration nodes.
Definition of a Visitor interface for a configuration node
structure.
A simple adapter class that simplifies writing custom node visitor
implementations.
A configuration related runtime exception.
Miscellaneous utility methods for configurations.
A base class for "faked"
XMLReader classes
that transform a configuration object in a set of SAX parsing events.
A specialized lookup implementation that allows access to constant fields of
classes.
Exception thrown when a property is incompatible with the type requested.
Configuration stored in a database.
Decorator providing additional getters for any Configuration.
The default implementation of the
BeanFactory interface.
A factory class that creates a composite configuration from an XML based
configuration definition file.
A specialized
BeanDeclaration implementation that
represents the declaration of a configuration source.
A base class for creating and initializing configuration sources.
A specialized provider implementation that deals with file based
configurations.
A specialized configuration provider for XML configurations.
A simple class that supports creation of and iteration on configuration keys
supported by a
DefaultExpressionEngine object.
A default implementation of the
ConfigurationNode interface.An internally used helper class for managing a collection of sub nodes.
The DefaultEntityResolver used by XML Configurations.
A default implementation of the
ExpressionEngine interface
providing the "native"e; expression language for hierarchical
configurations.FileSystem that uses java.io.File or HttpClient
DynamicCombinedConfiguration allows a set of CombinedConfigurations to be used.
Interface used for registering and retrieving PUBLICID to URL mappings.
Interface that identifies the class as using an EntityResolver
A Configuration implementation that reads the platform specific
environment variables using the map returned by
System.getenv().
A specialized lookup implementation that allows access to environment
variables.
A base class for objects that can generate configuration events.
Definition of an interface for evaluating keys for hierarchical
configurations.
Lookup that allows expressions to be evaluated.
The key and corresponding object that will be made available to the
JexlContext for use in expressions.
List wrapper used to allow the Variables list to be created as beans in
DefaultConfigurationBuilder.
A reloading strategy that will reload the configuration every time its
underlying file is changed.
A persistent configuration loaded and saved to a file.
Some FileSystems allow options to be passed on File operations.
Abstract layer to allow various types of file systems.
Interface used to install or locate the FileSystem
A specialized configuration class that extends its base class by the
ability of keeping more structure in the stored properties.
A specialized visitor base class that can be used for storing the tree of
configuration nodes.
A data class for storing (hierarchical) property information.
Definition of a visitor class for traversing a node and all of its
children.
A specialized SAX2 XML parser that "parses" hierarchical
configuration objects.
A specialized hierarchical configuration implementation for parsing ini
files.
A base class for hierarchical configurations with specific reloading
requirements.
Deprecated.
This class is deprecated.
Deprecated.
This class has been replaced by HierarchicalINIConfiguration,
which provides a superset of the functionality offered by this class.
A strategy that never triggers a reloading.
This Configuration class allows you to interface with a JNDI datasource.
A simple class acting as lock.
A strategy to reload configuration based on management requests.
MBean definition for managing configuration reload.
A Map based Configuration.
A specialized implementation of the
NodeCombiner interface
that performs a merge from two passed in node hierarchies.This class provides access to multiple configuration files that reside in a location that
can be specified by a pattern allowing applications to be multi-tenant.
A simple data class used by
ExpressionEngine to store
the results of the prepareAdd() operation.
A base class for node combiner implementations.
A concrete combiner implementation that is able to construct an override
combination.
This exception is thrown when parse errors are encountered.
Wraps a HierarchicalConfiguration and allows subtrees to be access via a configured path with
replaceable tokens derived from the ConfigurationInterpolator.
This is the "classic" Properties loader which loads the values from
a single or multiple files (which can be chained with "include =".
A default implementation of the
IOFactory interface.
Definition of an interface that allows customization of read and write
operations.
This class is used to read properties lines.
This class is used to write properties lines.
A helper class used by
PropertiesConfiguration to keep
the layout of a properties file.A utility class to convert the configuration properties into any type.
NeXT / OpenStep style configuration.
Token literal values and constants.
Token Manager.
Interface that allows other objects to synchronize on a root lock.
A strategy to decide if a configuration should be reloaded.
A configuration wrapper around a
ServletConfig.A configuration wrapper to read the initialization parameters of a servlet
context.
A configuration wrapper around a
FilterConfig.A configuration wrapper to read the parameters of a servlet request.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
Strict comparator for configurations.
A specialized hierarchical configuration class that wraps a single node of
its parent configuration.
A subset of another configuration.
A configuration based on the system properties.
Describes the input token stream.
Token Manager Error.
Utility methods.
A specialized implementation of the
NodeCombiner interface
that constructs a union from two passed in node hierarchies.
A file-based reloading strategy that uses Commons VFS to determine when a
file was changed.
FileSystem that uses Commons VFS
A specialized node implementation to be used in view configurations.
An implementation of the
BeanDeclaration interface that is
suitable for XML configuration files.A specialized hierarchical configuration class that is able to parse XML
documents.
This configuration implements the XML properties format introduced in Java
5.0, see http://java.sun.com/j2se/1.5.0/docs/api/java/util/Properties.html.
Property list file (plist) in XML FORMAT as used by Mac OS X (http://www.apple.com/DTDs/PropertyList-1.0.dtd).
Container for array elements.
Node extension with addXXX methods to parse the typed data passed by the SAX handler.
A specialized implementation of the
ExpressionEngine interface
that is able to evaluate XPATH expressions.
DefaultConfigurationBuilderinstead; this class provides the same features as ConfigurationFactory plus some more; it can also process the same configuration definition files.