All Classes

Class Summary
AbstractConfiguration	This is an abstract `Configuration` implementation that deals with methods that can be abstracted away from underlying implementations.
AbstractLogEnabled	Utility class to allow construction of easy components that will perform logging.
AbstractLoggable	Utility class to allow construction of easy components that will perform logging.
AvalonFormatter	This formatter extends ExtendedPatternFormatter so that CascadingExceptions are formatted with all nested exceptions.
CascadingError	Class from which all exceptions should inherit.
CascadingException	Class from which all exceptions should inherit.
CascadingRuntimeException	Class from which all exceptions should inherit.
CascadingThrowable	Interface which all cascadign throwables should implement.
Component	This interface identifies classes that can be used as `Components` by a `Composable`.
ComponentException	The exception thrown to indicate a problem with Components.
ComponentManager	A `ComponentManager` selects `Component`s based on a role.
ComponentSelector	A `ComponentSelector` selects `Component`s based on a hint.
Composable	A `Composable` class is one that needs to connect to software components using a "role" abstraction, thus not depending on particular implementations but on behavioral interfaces.
Configurable	This interface should be implemented by classes that need to be configured with custom parameters before initialization.
Configuration	`Configuration` is a interface encapsulating a configuration node used to retrieve configuration values.
ConfigurationException	Thrown when a `Configurable` component cannot be configured properly, or if a value cannot be retrieved properly.
ConfigurationUtil	This class has a bunch of utility methods to work with configuration objects.
ConsoleLogger	Logger sending everything to the standard output streams.
ContainerUtil	Utility class that makes it easier to transfer a component throught it's lifecycle stages.
Context	The context is the interface through which the component and its container communicate.
ContextException	Exception signalling a badly formed Context.
Contextualizable	This inteface should be implemented by components that need a Context to work.
DefaultComponentManager	This class is a static implementation of a ComponentManager.
DefaultComponentSelector	This is the default implementation of the ComponentSelector.
DefaultConfiguration	This is the default `Configuration` implementation.
DefaultConfigurationBuilder	A DefaultConfigurationBuilder builds `Configuration`s from XML, via a SAX2 compliant parser.
DefaultConfigurationSerializer	A ConfigurationSerializer serializes configurations via SAX2 compliant parser.
DefaultContext	Default implementation of Context.
DefaultServiceManager	This class is a static implementation of a `ServiceManager`.
DefaultServiceSelector	This is the default implementation of the ServiceSelector
Disposable	The Disposable interface is used when components need to deallocate and dispose resources prior to their destruction.
Enum	Basic enum class for type-safe enums.
ExceptionUtil	This class provides basic facilities for manipulating exceptions.
Executable	The Executable can be implemented by components that need to perform some work.
Initializable	The Initializable interface is used by components that need to allocate resources prior to them becoming active.
Jdk14Logger	The default JDK 1.4 wrapper class for Logger.
Log4JLogger	The default Log4J wrapper class for Logger.
LogEnabled	Components that need to log can implement this interface to be provided Loggers.
Loggable	Components that need to log can implement this interface to be provided Loggers.
Logger	This is a facade for the different logging subsystems.
LogKit2AvalonLoggerAdapter	A basic adapter that adapts an Avalon Logger to a Logkit Logger.
LogKitLogger	The default LogKit wrapper class for Logger.
NamespacedSAXConfigurationHandler	A SAXConfigurationHandler helps build Configurations out of sax events, including namespace information.
NullLogger	The Null Logger class.
ParameterException	Thrown when a `Parameterizable` component cannot be parameterized properly, or if a value cannot be retrieved properly.
Parameterizable	Components should implement this interface if they wish to be provided with parameters during startup.
Parameters	The `Parameters` class represents a set of key-value pairs.
Recomposable	Extends composer to allow recomposing.
Reconfigurable	Extends `Configurable` to allow reconfiguration at runtime.
Recontextualizable	Extends Contextualizable to allow recontextualizing.
Reparameterizable	Components should implement this interface if they wish to be provided with parameters during its lifetime.
Resolvable	This interface is used to indicate objects that need to be resolved in some particular context.
SAXConfigurationHandler	A SAXConfigurationHandler helps build Configurations out of sax events.
Serviceable	A Serviceable is a class that need to connect to software components using a "role" abstraction, thus not depending on particular implementations but on behavioral interfaces.
ServiceException	The exception thrown to indicate a problem with service.
ServiceManager	A `ServiceManager` selects `Object`s based on a role.
ServiceSelector	A `ServiceSelector` selects Objects based on a supplied policy.
SingleThreaded	A interface to mark a component as SingleThreaded.
Startable	The Startable interface is used when components need to be "running" to be active.
Suspendable	The Suspendable interface is used when a component will need to temporarily halt execution of a component.
ThreadSafe	A interface to mark a component as ThreadSafe or reentrant.
ValuedEnum	Basic enum class for type-safe enums with values.
Version	This class is used to hold version information pertaining to a Component or interface.
WrapperComponentManager	This is a ComponentManager implementation that can wrap around a ServiceManager object effectively adapting a ServiceManager interface to a ComponentManager interface.
WrapperComponentSelector	This is a ServiceSelector implementation that can wrap around a legacy ComponentSelector object effectively adapting a ComponentSelector interface to a ServiceSelector interface.
WrapperServiceManager	This is a ServiceManager implementation that can wrap around a legacy ComponentManager object effectively adapting a ComponentManager interface to a ServiceManager interface.
WrapperServiceSelector	This is a ServiceSelector implementation that can wrap around a legacy ComponentSelector object effectively adapting a ComponentSelector interface to a ServiceSelector interface.