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.
An IArgs implementation allowing to concat two IArgs together.
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
A factory for IFacade instances to an 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 NullPreferences
A 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.
 
 
 
 
A VM singleton for a IPreferencesFactory
A 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.
 
An IReporter that may be used to intercept the reporting information and "replay" them later on on another IReporter instance.
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.
 
A simple adapter from a String to ILocator.
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.