All Classes and Interfaces
Class
Description
This is an alternate implementation for
FutureTask, which is in some
cases not flexible enough.Abstract
ILock implementation.Abstract
ILockStrategy implementation.Supports reading and writing to a random access data container.
An event indicating the activation of an application component.
A VM wide singleton for the
IAdapterOutlet.A tool class for handling adapter objects.
The transformation is defined by two matrices, each defining a coordinate
system.
The transformation is defined explicitly.
A concrete generic implementation for
IArgs.Tool class to ease handling of arguments.
An argument declaration supporting argument reordering/ naming and default
values.
An iterator over an array
Utility methods to handle attachment relationships between files.
A generic object to be used as a key with
IAttributeSupport.An event representing an objects state change.
A convenience implementation for listening to attribute change events.
A default implementation for
IAttributeSupport.Base32 - encodes and decodes 'Canonical' Base32
An encoder for the BASE 64 code.
A
PrefValueHolder implementation for boolean typed values.todo 1 length reply may be invalid
An adapter from a byte[] object to
ILocator.A very simple cache implementation.
An entry in the cache implementation.
An event indicating the negatively acknowledged outcome of an execution.
An event indicating the request to deny positive termination.
A tool class for the handling of strings.
An
ILocator for java resources identified directly by a class loader.Tool methods for handling
ClassLoader instances.An
ILocator for java resources relative to a given class.Tool class to enhance the reflective capabilities about classes.
A common superclass for implementing
IFunctor.A convenience implementation to plugin
INotificationSupport.A common implementation of
IStartStop.A stream that reads from all its inputs until all are empty.
A stream object wrapping console output.
The console writer wraps System.out in a writer that is never closed
accidently.
A common utility
IFunctor returning a constant value.A simple
IPasswordProvider to return a constant value.Simple string conversion utilities;
An event indicating the creation of a new instance by a factory.
An event indicating the de-activation of an application component.
A common superclass for implementing
IDeclaration.A generic implementation for
IDeclarationBlock.A common superclass for
IDeclarationElement instances.An exception while accepting a declaration.
This
IArgs implementation allows the declaration of arguments.The default reporting implementation for the Stage kernel.
An adapter for implementing a delegation model.
An event indicating the destruction of an instance.
A
Reader that is aware of embedded tags.Echo the incoming arguments.
Helper implementation for empty argument list.
Helper implementation for an empty declaration block.
An Enumeration without elements.
An Iterator over an empty collection.
Wraps an enumeration into an Iterator API.
The abstract superclass for an enumeration implementation.
The meta data for an enumeration implementation.
A writer that escapes predefined character sequences.
Abstract superclass for event implementations.
Helper object for management and dispatching of events.
The type of an
Event.Tool class for dealing with Exceptions.
A common superclass for implementaing the facade pattern.
Tool class to handle common IFacadeFactory scenarios.
An exception while accessing an object field.
A VM singleton for accessing an
IFileEnvironment.File based implementation of
ILocator.The factory for
FileLocator objects.Some utility methods to ease life with
File instances.A Helper reader that repeatedly returns the characters in a predefined
pattern until it is closed.
Generic implementation of
IFunctorCall.An exception while performing an
IFunctor.Tool class for handling functor specific tasks.
A very simple implementation of a generic
IPool.Tool class for common geometry tasks.
A stream object dumping its data in hex format.
Helper class for faster mapping of bytes to their hex equivalent
A reader that encodes literal line breaks to html tags.
An object supporting handling reflective access to fields of a delegate.
An object supporting handling reflective calls to fields of a delegate.
An object supporting reflective calls to its fields.
An object supporting reflective calls to its fields.
Component lifecycle feature.
A factory instance that can create an adapter object of type
clazz on behalf of the object object.The outlet, supporting multiple
IAdapterFactory instances.An object that is able to be adapted to another type.
The arguments for executing an
IFunctor implementation.The declaration for an argument to an
IFunctorCall.This interface declares support for "generic attributes".
A simple interface for providing complete authentication.
An object supporting reflective get operations.
An object supporting reflective method calls
Deprecated.
An interface indicating support for complete access (get and set) to a
ClassLoader.An interface indicating support for getting a
ClassLoader.Component lifecycle feature.
A declaration allows to modify the state and or behavior of an
IFunctorCall.A group of
IDeclaration instances.A concrete named declaration.
An object that may have declarations.
An object indicating an event.
An object that supports event broadcasting.
An object that handles exceptions.
An object hiding the real implementation object
An object that is able to create its own
IFacade.An object able to access a field within a delegate
An object able to access a field within a delegate
An object describing the process / VM file system context.
An iconified behavior.
An object representing the actual call of an
IFunctor.A factory for
IFunctorCall objects.A factory for
IFunctor objects.An object that supports execution of functors.
Component lifecycle feature.
This interface declares the ability of a dynamically loaded component to be
instantiated.
An object that supports handling reflective calls to the methods of a
delegate.
An object that supports handling reflective calls to the behavior of a
delegate.
An object supporting reflective access to its methods.
An object supporting reflective access to its methods.
An interface describing the ability to provide information about the current
context into a data stream.
The locator specifies the physical location of a resource.
A factory for
ILocator objects.ILocatorNameFilter objects can filter ILocator objects when listing their children.Indicate support for locating the receivers resource physically.
Classes implementing this interface can be used in conjunction with the
singleton LogConfigurator to configure Logger instances created by the class
LogTools.
An interface indicating support for assigning a
MessageBundle.An interface indicating support for accessing a
MessageBundle.This interface declares the components ability to provide meta information.
An object able to access a method within a delegate
An object able to access a method within a delegate
An
IFunctor that can be identified via a unique id.Called to inform a listener about an event occurrence.
The implementor supports registration of
INotificationListener
objects to be informed about event.Abstract superclass for implementing the resource installation behavior.
An abstraction to access a file to be deployed along with the application via
the class loader.
An abstraction to access a directory structure to be deployed along with the
application via the class loader.
An abstraction to access a directory structure to be deployed along with the
application via the class loader.
A
PrefValueHolder implementation for integer typed values.Implement an Iterator over a virtual collection of numbers defined by an
interval.
A hash map that uses primitive ints for the key rather than objects.
A simple interface for a password provider.
A simple interface for a password validator.
A pool of objects.
A factory for the lifecycle management of objects in a generic pool
implementation.
Yet another preferences abstraction.
A factory for
IPreferences root objects.An object that has preferences.
An object that can be synched with its preferences.
An object acting as a stand-in for another object.
An interface for an object that can randomly access bytes in a data stream.
An object that is aware of its referents.
An interface to report different types of information to the user.
An object that supports state notifications.
An interface for accessing a generic resource associated with a tracked
Reference by the ResourceTracker.An object supporting state dumps.
A interface that indicates the availability of "scoping" for a standard Java
Preferences implementation.http://www.iso.org/iso/en/prods-services/popstds/currencycodeslist.html
This describes the components ability to explicitly start or stop its
lifecycle.
This describes a components ability to check its consistency with any
physical representation, for example a file system.
Wraps an iterator into an enumeration API.
An interface for readers that can escape character sequences.
Generic interface for objects holding references to others.
This defines the ability of a component to support generic key/value mappings
from string to string.
An exception that may be used to indicate that an exceptional condition is
"expected" in the sense that you will need no further tools to investigate
the reason, such as a stack trace.
A tool for intercepting and handling lifecycle related events.
A utility class to simplify the task of loading files and / or directories.
An implementation of ILocationProvider.
This
ILocator serves as an adapter for an ILocatorSupport
instance.Singleton access to the
ILocatorFactory.Tool methods for dealing with
ILocator.A viewport implementation for
ILocator.Singleton holding a ILogConfigurator instance.
An
InputStream that logs any char read.An output stream that logs any char written.
A reader that logs any char read.
Tool methods to ease life with java.util.logging.
A writer that logs any char written.
A tool class for Map extensions.
Tool class for math related functions
A wrapper class for defining and accessing ResourceBundles.
An exception while performing an object method.
An exception in the execution of a method.
An exception in the lookup of method.
An iterator to enumerate sequentially the elements in a hierarchical
collection.
A common utility
IFunctor doing just nothing.An output stream killing its data.
A dummy
IPasswordProvider for example to use in a batch environment.A "null"
IPreferences implementation.A factory for
NullPreferencesA null implementation for
IReporter.An implementation of NumberWrapper that represents a single number object.
An implementation of NumberWrapper that represents an interval of numbers.
An implementation of NumberWrapper that represents an enumeration of single
number objects.
A parser able to read a definition of numbers.
An abstract class for the implementation of objects that may occur in the
definition of a number string.
Failure while creating a new object via reflection.
A tool class for convenient object related tasks.
An event indicating the positively acknowledged outcome of an execution.
An event indicating the the request to positively terminate.
A map that wraps two other maps.
A VM singleton for accessing a
IPasswordProvider.A tool class for handling passwords and authentication
A generic reference to some trackable resource.
Adapt
Preferences to IPreferences.A VM singleton for a
IPreferencesFactoryA tool class for some common tasks when dealing with
IPreferences.An
IValueHolder implementation that is backed up by preferences.A wrapper around a byte array to allow random access like API.
Implements random access to a file.
Filter implementation for random access.
A viewport in an existing
IRandomAccess.A simple read only locator.
Helper object for implementing
IReporterSupport.A thread for monitoring a reference queue.
An object to keep track of platform resources that should be disposed upon
garbage collection of some container object.
An event indicating that a component is resumed.
This iterator enumerates the elements of a list in reverse order.
An event indicating a selection.
A simple usable formatter for java logging
An enumeration of a single object.
An iterator over a single object.
Only accept log requests within a dedicated thread.
A generic reference to some trackable resource.
The standard implementation for
IAdapterOutlet.A general implementation for an object providing
IVariableNamespace.An event indicating the start of an application component.
An event indicating the stop of an application component.
An event indicating that the stop for an application component was requested.
A simple adapter from
InputStream to ILocator.A tool class for the handling of streams.
Create an OID unique to the running VM.
A
PrefValueHolder implementation for String typed values.A tool class for the handling of strings.
An event indicating that a component is supended.
A simple ExecutorService running all commands synchronously.
A simple ExecutorService running all commands synchronously.
Tool methods to implement a file based synchronization with other platform
processes.
Only accept log requests within threads that are tagged with the receiver
object.
Helper object for implementing
ITaskListenerSupport.experimental
experimental
A stream wrapper that deferrs writing to the final destination until the
stream is closed.
Tools for dealing with temporary files and directories.
A shape that can be transformed with lazy access to the transformed shape.
A "non persistent" locator.
A thread safe, quite trivial formatter for date/calendar objects.
A thread safe, quite trivial formatter for integer numbers
A message to enable tunneling through signatures that allow for runtime
exceptions only.
A reader that can unescape character data from a wrapped reader.
A environment that allows per thread usage of IVariableSupport objects.
A generic reference to some trackable resource.
Handles wildcards for filename matching.
A reader that encodes XML special characters to entities.
INotificationSupport