Interface | Description |
---|---|
Ceasable |
This mixin might be implemented by a component in order to provide cease
facilities.
|
Ceasable.CeaseAutomaton |
The
Ceasable.CeaseAutomaton interface defines those methods related to the
cease life-cycle. |
Ceasable.CeaseBuilder<B extends Ceasable.CeaseBuilder<B>> |
To enable the
Ceasable functionality to be invoked in a builder
chain. |
Ceasable.UncheckedCeasable |
See
Ceasable without any checked exception being declared. |
CeasableHandle<H> |
The
CeasableHandle interface defines those methods related to the
handle based cease life-cycle. |
CeasableHandle.CeaseAutomatonHandle<H> |
The
CeasableHandle.CeaseAutomatonHandle interface defines those methods related
to the handle based cease life-cycle. |
Closable |
This mixin might be implemented by a component in order to provide closing
connection(s) facilities.
|
Closable.CloseAutomaton |
The
Closable.CloseAutomaton interface defines those methods related to the
closing of connection(s) life-cycle. |
ClosableHandle<H> |
The
ClosableHandle interface defines those methods related to the
handle based close life-cycle. |
ClosableHandle.CloseAutomatonHandle<H> |
The
ClosableHandle.CloseAutomatonHandle interface defines those methods related
to the handle based close life-cycle. |
ClosedAccessor |
Provides an accessor for a closed property.
|
ClosedAccessor.ClosedMutator |
Provides a mutator for a closed property.
|
ClosedAccessor.ClosedProperty |
Provides a closed property.
|
Component |
Per definition any
Component at least must provide a
Destroyable.destroy() method. |
CompositeComponent |
Any composite implementation of the refcodes frameworks should implement this
CompositeComponent interface so that any therein contained
Component instances' state change methods are supported by the
CompositeComponent as well and forwarded to the Component
contained in the CompositeComponent instance. |
CompositeComponent.ExtendedCompositeComponent<CTX,CON> |
The
CompositeComponent.ExtendedCompositeComponent provides extended functionality to
the CompositeComponent 's functionality by including extended
Openable functionality (ConnectionOpenable ) and extends
Initializable functionality (Configurable ). |
CompositeComponentHandle<H,REF> |
Similar to the
CompositeComponent , the
CompositeComponentHandle provides all the defined handle based
functionality, implementing classes provide the means to invoke those methods
in case them are supported by the referenced components. |
Configurable<CTX> |
This mixin might be implemented by a component in order to provide initialize
facilities wit a configuration provided via
Configurable.initialize(Object) . |
Configurable.ConfigureAutomaton<CTX> |
The
Configurable.ConfigureAutomaton interface defines those methods related to
the initialize life-cycle with a provided context. |
Configurable.ConfigureBuilder<CTX,B extends Configurable.ConfigureBuilder<CTX,B>> |
To enable the
Initializable functionality to be invoked in a
builder chain. |
ConfigurableComponent<CTX> |
A
ConfigurableComponent can be configured invoking the method
Configurable.initialize(Object) . |
ConfigurableHandle<H,CTX> |
The
ConfigurableHandle interface defines those methods related to the
handle based initialize/configure life-cycle. |
ConfigurableHandle.ConfigureAutomatonHandle<H,CTX> |
The
ConfigurableHandle.ConfigureAutomatonHandle interface defines those methods
related to the handle based initialize/configure life-cycle. |
ConfigurableLifeCycleComponent<CTX> |
A component implementing the
ConfigurableLifeCycleComponent interface
supports a life-cycle. |
ConfigurableLifeCycleComponent.ConfigurableLifeCycleAutomaton<CTX> |
A system implementing the
ConfigurableLifeCycleComponent.ConfigurableLifeCycleAutomaton
interface supports managing ConfigurableLifeCycleComponent
instances and takes care that the open/close statuses are invoked in the
correct order by throwing according exceptions in case the
open/close-cycle is invoked in the wrong order. |
ConfigurableLifeCycleComponentHandle<H,CTX> |
The
ConfigurableLifeCycleComponentHandle manages various
LifeCycleStatus states for ConfigurableLifeCycleComponent
instances each related to a handle. |
ConfigurableLifeCycleComponentHandle.ConfigurableLifeCycleAutomatonHandle<H,CTX> |
The
ConfigurableLifeCycleComponentHandle.ConfigurableLifeCycleAutomatonHandle is an automaton managing
various LifeCycleStatus states for Component instances
each related to a handle. |
ConnectableComponent |
Any
Component which operates established connections may implement
the ConnectableComponent interface providing a minimal set of
functionality to work with connections; to test whether a connection is open
and to close an open connection. |
ConnectableComponent.ConnectableAutomaton |
The
ConnectableComponent.ConnectableAutomaton extends the ConnectableComponent
with automaton functionality to get detailed status information regarding
connections. |
ConnectionAccessor<CON> |
Provides an accessor for a connection property for e.g. an
InputStream or an OutputStream . |
ConnectionAccessor.ConnectionMutator<CON> |
Provides a mutator for a connection property for e.g. an
InputStream or an OutputStream . |
ConnectionAccessor.ConnectionProperty<CON> |
Provides a connection property for e.g. an
InputStream or an
OutputStream . |
ConnectionComponent<CON> |
A component implementing the
ConnectionComponent interface supports a
connection. |
ConnectionComponent.ConnectionAutomaton<CON> |
A system implementing the
ConnectionComponent.ConnectionAutomaton interface supports
managing ConnectionComponent instances and takes care that the
open/close statuses are invoked in the correct order by throwing
according exceptions in case the open/close-cycle is invoked in the wrong
order. |
ConnectionComponentHandle<H,CON> |
The
ConnectionComponentHandle manages various
ConnectionStatus states for ConnectionComponent instances
each related to a handle. |
ConnectionComponentHandle.ConnectionAutomatonHandle<H,CON> |
The
ConnectionComponentHandle.ConnectionAutomatonHandle is an automaton managing various
ConnectionStatus states for ConnectionComponent instances
each related to a handle. |
ConnectionOpenable<CON> |
This mixin might be implemented by a component in order to provide opening
connection(s) facilities.
|
ConnectionOpenable.ConnectionOpenAutomaton<CON> |
The
ConnectionOpenable.ConnectionOpenAutomaton interface defines those methods
related to the opening of connection(s) life-cycle. |
ConnectionOpenableHandle<H,CON> |
The
ConnectionOpenableHandle interface defines those methods related
to the handle based open/connect life-cycle. |
ConnectionOpenableHandle.ConnectionOpenAutomatonHandle<H,CON> |
The
ConnectionOpenableHandle.ConnectionOpenAutomatonHandle interface defines those methods
related to the handle based open/connect life-cycle. |
ConnectionStatusAccessor |
Provides an accessor for a
ConnectionStatus property. |
ConnectionStatusAccessor.ConnectionStatusMutator |
Provides a mutator for a
ConnectionStatus property. |
ConnectionStatusAccessor.ConnectionStatusProperty |
Provides a
ConnectionStatus property. |
ConnectionStatusHandle<H> | |
ContextAccessor<CTX> |
Provides an accessor for a context property for e.g. a service or a
component.
|
ContextAccessor.ContextBuilder<CTX,B extends ContextAccessor.ContextBuilder<CTX,B>> |
Provides a builder method for a context property returning the builder
for applying multiple build operations.
|
ContextAccessor.ContextMutator<CTX> |
Provides a mutator for a context property for e.g. a service or a
component.
|
ContextAccessor.ContextProperty<CTX> |
Provides a context property for e.g. a service or a component.
|
Decomposeable |
This mixin might be implemented by a component in order to provide
decomposition facilities.
|
Decomposeable.DecomposeAutomaton |
The
Decomposeable.DecomposeAutomaton interface defines those methods related to
the decompose life-cycle. |
DecomposeableHandle<H> |
The
DecomposeableHandle interface defines those methods related to
the handle based decompose life-cycle. |
DecomposeableHandle.DecomposeAutomatonHandle<H> |
The
DecomposeableHandle.DecomposeAutomatonHandle interface defines those methods
related to the handle based decompose life-cycle. |
Destroyable |
This mixin might be implemented by a
Component in order to provide
destroy facilities. |
Destroyable.DestroyAutomaton |
The
Destroyable.DestroyAutomaton interface defines those methods related to
the destroy life-cycle. |
DestroyableHandle<H> |
The
DestroyableHandle interface defines those methods related to the
handle based destroy life-cycle. |
DestroyableHandle.DestroyAutomatonHandle<H> |
The
DestroyableHandle.DestroyAutomatonHandle interface defines those methods
related to the handle based destroy life-cycle. |
DeviceComponent |
A component implementing the
DeviceComponent interface supports a
connecting. |
DeviceComponent.DeviceAutomaton |
A system implementing the
DeviceComponent.DeviceAutomaton interface supports
managing DeviceComponent instances and takes care that the
open/close statuses are invoked in the correct order by throwing
according exceptions in case the open/close-cycle is invoked in the wrong
order. |
DeviceComponentHandle<H> |
The
DeviceComponentHandle manages various ConnectionStatus
states for DeviceComponent instances each related to a handle. |
DeviceComponentHandle.DeviceAutomatonHandle<H> |
The
DeviceComponentHandle.DeviceAutomatonHandle is an automaton managing various
ConnectionStatus states for Component instances each
related to a handle. |
Digester<J> |
A
Digester provides the functionality to consume a job (which is
pushed from the outside) for further processing. |
DigesterComponent<J> | |
DisposableHandle<H> |
The
DisposableHandle interface defines those methods related to the
handle based dispose life-cycle. |
DisposableHandle.DisposeAutomatonHandle<H> |
The
DisposableHandle.DisposeAutomatonHandle interface defines those methods
related to the handle based dispose life-cycle. |
DisposeAutomaton |
The
DisposeAutomaton interface defines those methods related to the
dispose life-cycle. |
Flushable |
This mixin might be implemented by a component in order to provide flush
facilities.
|
FlushHandle<H> |
The
FlushHandle interface defines those methods related to the handle
based flush operation. |
HandleAccessor<H> |
Provides an accessor for a handle property for e.g. key / handle pair.
|
HandleAccessor.HandleMutator<H> |
Provides a mutator for a handle property for e.g. key / handle pair.
|
HandleAccessor.HandleProperty<H> |
Provides a handle property for e.g. key / handle pair.
|
HandleDirectory<H,REF> |
The handle directory enables listing of all known data managed by the
implementing component.
|
HandleGenerator<H> |
Generates handles of the generic type.
|
HandleLookup<H,REF> |
Any system in this framework being able to work with handles provides an
implementation of the handle lookup interface.
|
Initializable |
This mixin might be implemented by a component in order to provide
initializing facilities.
|
Initializable.InitializeAutomaton |
The
Initializable.InitializeAutomaton interface defines those methods related
to the initialize life-cycle. |
Initializable.InitializeBuilder<B extends Initializable.InitializeBuilder<B>> |
To enable the
Initializable functionality to be invoked in a
builder chain. |
Initializable.UncheckedInitializable |
See
Initializable without any checked exception being declared. |
InitializableHandle<H> |
The
InitializableHandle interface defines those methods related to
the handle based initialize life-cycle. |
InitializableHandle.InitializeAutomatonHandle<H> |
The
InitializableHandle.InitializeAutomatonHandle interface defines those methods
related to the handle based initialize life-cycle. |
InitializeableComponent |
A
InitializeableComponent can be initialized invoking the method
Initializable.initialize() . |
InitializedAccessor |
Provides an accessor for a initialized property.
|
InitializedAccessor.InitializedMutator |
Provides a mutator for a initialized property.
|
InitializedAccessor.InitializedProperty |
Provides a initialized property.
|
InitializedHandle<H> |
Provides access to the initialized handle reference.
|
InputOutputComponent<INPUT,OUTPUT> |
A component implementing the
InputOutputComponent interface supports
a connection. |
InputOutputComponent.InputOutputAutomaton<INPUT,OUTPUT> |
A system implementing the
InputOutputComponent.InputOutputAutomaton interface supports
managing InputOutputComponent instances and takes care that the
open/close statuses are invoked in the correct order by throwing
according exceptions in case the open/close-cycle is invoked in the wrong
order. |
InputOutputConnectionAccessor<INPUT,OUTPUT> |
Provides an accessor for a connection property for e.g. an
InputStream or an OutputStream . |
InputOutputConnectionAccessor.InputOutputConnectionMutator<INPUT,OUTPUT> |
Provides a mutator for a connection property for e.g. an
InputStream or an OutputStream . |
InputOutputConnectionAccessor.InputOutputConnectionProperty<INPUT,OUTPUT> |
Provides a connection property for e.g. an
InputStream or an
OutputStream . |
InputOutputOpenable<INPUT,OUTPUT> |
This mixin might be implemented by a component in order to provide opening
connection(s) facilities.
|
InputOutputOpenable.InputOutputOpenAutomaton<INPUT,OUTPUT> |
The
InputOutputOpenable.InputOutputOpenAutomaton interface defines those methods
related to the opening of connection(s) life-cycle. |
InputOutputOpenableHandle<H,INPUT,OUTPUT> |
The
InputOutputOpenableHandle interface defines those methods related
to the handle based open/connect life-cycle. |
InputOutputOpenableHandle.InputOutputOpenAutomatonHandle<H,INPUT,OUTPUT> |
The
InputOutputOpenableHandle.InputOutputOpenAutomatonHandle interface defines those
methods related to the handle based open/connect life-cycle. |
LifeCycleComponent |
A component implementing the
LifeCycleComponent interface supports a
life-cycle. |
LifeCycleComponent.LifeCycleAutomaton |
A system implementing the
LifeCycleComponent.LifeCycleAutomaton interface supports
managing LifeCycleComponent instances and takes care that the
life-cycle stages are invoked in the correct order by throwing according
exceptions in case the life-cycle is invoked in the wrong order. |
LifeCycleComponent.UncheckedLifeCycleComponent |
Same as the
LifeCycleComponent though without the need to
try-catch any exceptions on the various life-cycle stages. |
LifeCycleComponentHandle<H> |
The
LifeCycleComponentHandle manages various LifeCycleStatus
states for LifeCycleComponent instances each related to a handle. |
LifeCycleComponentHandle.LifeCycleAutomatonHandle<H> |
The
LifeCycleComponentHandle.LifeCycleAutomatonHandle is an automaton managing various
LifeCycleStatus states for Component instances each
related to a handle. |
LifeCycleStatusAccessor |
Provides an accessor for a
LifeCycleStatus property. |
LifeCycleStatusAccessor.LifeCycleStatusMutator |
Provides a mutator for a
LifeCycleStatus property. |
LifeCycleStatusAccessor.LifeCycleStatusProperty |
Provides a
LifeCycleStatus property. |
LifeCycleStatusHandle<H> | |
Openable |
This mixin might be implemented by a component in order to provide opening
connection(s) facilities.
|
Openable.OpenAutomaton |
The
Openable.OpenAutomaton interface defines those methods related to the
opening of connection(s) life-cycle. |
OpenableHandle<H> |
The
OpenableHandle interface defines those methods related to the
handle based open/connect life-cycle. |
OpenableHandle.OpenAutomatonHandle<H> |
The
OpenableHandle.OpenAutomatonHandle interface defines those methods related
to the handle based open/connect life-cycle. |
OpenedAccessor |
Provides an accessor for a opened property.
|
OpenedAccessor.OpenedMutator |
Provides a mutator for a opened property.
|
OpenedAccessor.OpenedProperty |
Provides a opened property.
|
OpenedHandle<H> |
Provides access to the opened (connected) handle reference.
|
Pausable |
This mixin might be implemented by a component in order to provide pause
facilities.
|
Pausable.PauseAutomaton |
The
Pausable.PauseAutomaton interface defines those methods related to the
pause life-cycle. |
Pausable.PauseBuilder<B extends Pausable.PauseBuilder<B>> |
To enable the
Pausable functionality to be invoked in a builder
chain. |
Pausable.UncheckedPausable |
See
Pausable without any checked exception being declared. |
PausableHandle<H> |
The
PausableHandle interface defines those methods related to the
handle based pause life-cycle. |
PausableHandle.PauseAutomatonHandle<H> |
The
PausableHandle.PauseAutomatonHandle interface defines those methods related
to the handle based pause life-cycle. |
ProgressAccessor |
Provides an accessor for a progress property.
|
ProgressAccessor.ProgressMutator |
Provides a mutator for a progress property.
|
ProgressAccessor.ProgressProperty |
Provides a progress property.
|
ProgressHandle<H> |
Whenever a handle is associated with a progress, then a component providing
such handles should implement this interface.
|
Resetable |
This mixin might be implemented by a component in order to provide reset
facilities.
|
ResetHandle<H> |
The
ResetHandle interface defines those methods related to the handle
based reset operation. |
Resumable |
This mixin might be implemented by a component in order to provide resume
facilities.
|
Resumable.ResumeAutomaton |
The
Resumable.ResumeAutomaton interface defines those methods related to
the resume life-cycle. |
Resumable.ResumeBuilder<B extends Resumable.ResumeBuilder<B>> |
To enable the
Resumable functionality to be invoked in a builder
chain. |
Resumable.UncheckedResumable |
See
Resumable without any checked exception being declared. |
ResumableHandle<H> |
The
ResumableHandle interface defines those methods related to the
handle based resume life-cycle. |
ResumableHandle.ResumeAutomatonHandle<H> |
The
ResumableHandle.ResumeAutomatonHandle interface defines those methods related
to the handle based resume life-cycle. |
RunningAccessor |
Provides an accessor for a running property.
|
RunningAccessor.RunningMutator |
Provides a mutator for a running property.
|
RunningAccessor.RunningProperty |
Provides a running property.
|
RunningHandle<H> |
Provides access to the running handle reference.
|
Startable |
This mixin might be implemented by a component in order to provide start
facilities.
|
Startable.StartAutomaton |
The
Startable.StartAutomaton interface defines those methods related to the
start life-cycle. |
Startable.StartBuilder<B extends Startable.StartBuilder<B>> |
To enable the
Startable functionality to be invoked in a builder
chain. |
Startable.UncheckedStartable |
See
Startable without any checked exception being declared. |
StartableHandle<H> |
The
StartableHandle interface defines those methods related to the
handle based start life-cycle. |
StartableHandle.StartAutomatonHandle<H> |
The
StartableHandle.StartAutomatonHandle interface defines those methods related
to the handle based start life-cycle. |
Stoppable |
This mixin might be implemented by a component in order to provide stop
facilities.
|
Stoppable.StopAutomaton |
The
Stoppable.StopAutomaton interface defines those methods related to the
stop life-cycle. |
Stoppable.StopBuilder<B extends Stoppable.StopBuilder<B>> |
To enable the
Stoppable functionality to be invoked in a builder
chain. |
Stoppable.UncheckedStoppable |
See
Stoppable without any checked exception being declared. |
StoppableHandle<H> |
The
StoppableHandle interface defines those methods related to the
handle based stop life-cycle. |
StoppableHandle.StopAutomatonHandle<H> |
The
StoppableHandle.StopAutomatonHandle interface defines those methods related
to the handle based stop life-cycle. |
Class | Description |
---|---|
ComponentUtility |
Enum | Description |
---|---|
ConnectionStatus | |
LifeCycleStatus |
Exception | Description |
---|---|
AbstractComponentException |
This exception is the base exception for the component package.
|
CeaseException |
Thrown in case ceasing a component caused problems.
|
ConfigureException |
Thrown in case initializing a component caused problems.
|
DigestException |
Thrown in case digesting (processing) a job by a
Digester.digest(Object) caused problems; the cause is usually wrapped
by this Exception . |
HandleTimeoutRuntimeException |
This exception is thrown in case a handle was provided which was unknown to
the invoked component.
|
IllegaleHandleStateChangeRuntimeException |
This exception is thrown in case a handle was provided whose reference does
not support a given operation.
|
InitializeException |
Thrown in case initializing a component caused problems.
|
OpenException |
Thrown in case opening or accessing an open line (connection, junction, link)
caused problems.
|
OpenTimeoutException |
Thrown in case opening or accessing an open line (connection, junction, link)
caused timeout problems.
|
PauseException |
Thrown in case pausing a component caused problems.
|
ResumeException |
Thrown in case resuming a component caused problems.
|
StartException |
Thrown in case starting a component caused problems.
|
StopException |
Thrown in case stopping a component caused problems.
|
UnknownHandleRuntimeException |
This exception is thrown in case a handle was provided which was unknown to
the invoked component.
|
UnsupportedHandleOperationRuntimeException |
This exception is thrown in case a handle was provided whose reference does
not support a given operation.
|
Copyright © 2015. All rights reserved.