Package org.refcodes.component

Interface Summary

Interface	Description
BidirectionalConnectionAccessor<INPUT,OUTPUT>	Provides an accessor for a connection property for e.g. an InputStream or an OutputStream.
BidirectionalConnectionAccessor.BidirectionalConnectionMutator<INPUT,OUTPUT>	Provides a mutator for a connection property for e.g. an InputStream or an OutputStream.
BidirectionalConnectionAccessor.BidirectionalConnectionProperty<INPUT,OUTPUT>	Provides a connection property for e.g. an InputStream or an OutputStream.
BidirectionalConnectionComponent<INPUT,OUTPUT>	A component implementing the BidirectionalConnectionComponent interface supports a connection.
BidirectionalConnectionComponent.BidirectionalConnectionAutomaton<INPUT,OUTPUT>	A system implementing the BidirectionalConnectionComponent.BidirectionalConnectionAutomaton interface supports managing BidirectionalConnectionComponent 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.
BidirectionalConnectionOpenable<INPUT,OUTPUT>	This mixin might be implemented by a component in order to provide opening connection(s) facilities.
BidirectionalConnectionOpenable.BidirectionalConnectionOpenAutomaton<INPUT,OUTPUT>	The BidirectionalConnectionOpenable.BidirectionalConnectionOpenAutomaton interface defines those methods related to the opening of connection(s) life-cycle.
BidirectionalConnectionOpenableHandle<H,INPUT,OUTPUT>	The BidirectionalConnectionOpenableHandle interface defines those methods related to the handle based open/connect life-cycle.
BidirectionalConnectionOpenableHandle.BidirectionalConnectionOpenAutomatonHandle<H,INPUT,OUTPUT>	The BidirectionalConnectionOpenableHandle.BidirectionalConnectionOpenAutomatonHandle interface defines those methods related to the handle based open/connect life-cycle.
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.
Closable.CloseBuilder<B extends Closable.CloseBuilder<B>>	To enable the Closable functionality to be invoked in a builder chain.
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.
ConnectionComponent.ConnectionComponentBuilder<CON,B extends ConnectionComponent.ConnectionComponentBuilder<CON,B>>	Similar to the ConnectionComponent with additional according builder methods.
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.
ConnectionOpenable.ConnectionOpenBuilder<CON,B extends ConnectionOpenable.ConnectionOpenBuilder<CON,B>>	To enable the Startable functionality to be invoked in a builder chain.
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>	The Interface ConnectionStatusHandle.
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.
Digester<J>	A Digester provides the functionality to consume a job (which is pushed from the outside) for further processing.
DigesterComponent<J>	Lifts the Digester mixin to the level of a Component.
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.
Flushable.FlushBuilder<B extends Flushable.FlushBuilder<B>>	The Interface FlushBuilder.
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.
HealthChecker
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.
InitializableComponent	A InitializableComponent can be initialized invoking the method Initializable.initialize().
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.
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.
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.
LifeCycleRequestAccessor	Provides an accessor for a LifeCycleRequest property.
LifeCycleRequestAccessor.LifeCycleRequestMutator	Provides a mutator for a LifeCycleRequest property.
LifeCycleRequestAccessor.LifeCycleRequestProperty	Provides a LifeCycleRequest property.
LifeCycleStatusAccessor	Provides an accessor for a LifeCycleStatus property.
LifeCycleStatusAccessor.LifeCycleStatusBuilder<B extends LifeCycleStatusAccessor.LifeCycleStatusBuilder<B>>	Provides a builder method for a LifeCycleStatus property returning the builder for applying multiple build operations.
LifeCycleStatusAccessor.LifeCycleStatusMutator	Provides a mutator for a LifeCycleStatus property.
LifeCycleStatusAccessor.LifeCycleStatusProperty	Provides a LifeCycleStatus property.
LifeCycleStatusHandle<H>	The Interface LifeCycleStatusHandle.
LinkComponent	A component implementing the LinkComponent interface supports establishing a connection (not necessarily a network connection).
LinkComponent.LinkAutomaton	A system implementing the LinkComponent.LinkAutomaton interface supports managing LinkComponent 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.
LinkComponent.LinkComponentBuilder<B extends LinkComponent.LinkComponentBuilder<B>>	Similar to the LinkComponent with additional according builder methods.
LinkComponentHandle<H>	The LinkComponentHandle manages various ConnectionStatus states for LinkComponent instances each related to a handle.
LinkComponentHandle.DeviceAutomatonHandle<H>	The LinkComponentHandle.DeviceAutomatonHandle is an automaton managing various ConnectionStatus states for Component instances each related to a handle.
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.
Openable.OpenBuilder<B extends Openable.OpenBuilder<B>>	To enable the Startable functionality to be invoked in a builder chain.
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.
Reloadable	This mixin might be implemented by a component in order to provide reload facilities.
Reloadable.ReloadBuilder<B extends Reloadable.ReloadBuilder<B>>	The Interface ReloadBuilder.
ReloadHandle<H>	The ReloadHandle interface defines those methods related to the handle based reload operation.
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 Summary

Class	Description
AbstractConnectableAutomaton	The AbstractConnectableAutomaton implements the very basic AbstractConnectableAutomaton functionality.
AbstractDeviceAutomaton	The AbstractDeviceAutomaton implements the very basic AbstractDeviceAutomaton functionality.
ComponentUtility	The Class ComponentUtility.
CompositeComponentImpl<C extends Component>	The CompositeComponentImpl is an implementation of the CompositeComponent.
CompositeComponentImpl.ExtendedCompositeComponentImpl<C extends Component,CTX,CON>	The CompositeComponentImpl.ExtendedCompositeComponentImpl is an implementation of the CompositeComponent.ExtendedCompositeComponent.
ConfigurableLifeCycleAutomatonImpl<CTX>	This class implements a ConfigurableLifeCycleComponent.ConfigurableLifeCycleAutomaton.
ConnectionAutomatonImpl<CON>	This class implements a ConnectionComponent.ConnectionAutomaton.
DeviceAutomatonImpl	This class implements a LifeCycleComponent.LifeCycleAutomaton.
HandleGeneratorImpl	Plain straight forward String instances generating HandleGenerator basically being a plain good old UniqueIdGeneratorImpl.
LifeCycleAutomatonImpl	This class implements a LifeCycleComponent.LifeCycleAutomaton.
LifeCycleAutomatonImpl.ManualLifeCycleAutomatonImpl	Opens the otherwise protected LifeCycleAutomatonImpl.ManualLifeCycleAutomatonImpl.setLifeCycleStatus(LifeCycleStatus) to be public in order to force any lifecycle status to be set.

Enum Summary

Enum	Description
ConnectionRequest	An enumeration describing the connection requests.
ConnectionStatus	The Enum ConnectionStatus.
ExecutionStatus
LifeCycleRequest	An enumeration describing the lifecycle requests regarding a component..
LifeCycleStatus	The Enum LifeCycleStatus.

Exception Summary

Exception	Description
CeaseException	Thrown in case ceasing a component caused problems.
CeaseException.CeaseRuntimeException	Unchecked exception with the same semantics as the CeaseException.
CloseException	Thrown in case closing an open line (connection, junction, link) caused problems.
CloseException.CloseRuntimeException	Unchecked exception with the same semantics as the CloseException.
ComponentException	This exception is the base exception for the component package.
ComponentRuntimeException	This exception is the base runtime exception for the component package.
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.
IllegalHandleStateChangeRuntimeException	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.
InitializeException.InitializeRuntimeException	Unchecked exception with the same semantics as the CloseException.
OpenException	Thrown in case opening or accessing an open line (connection, junction, link) caused problems.
OpenException.OpenRuntimeException	Unchecked exception with the same semantics as the OpenException.
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.
PauseException.PauseRuntimeException	Unchecked exception with the same semantics as the PauseException.
ResumeException	Thrown in case resuming a component caused problems.
ResumeException.ResumeRuntimeException	Unchecked exception with the same semantics as the ResumeException.
StartException	Thrown in case starting a component caused problems.
StartException.StartRuntimeException	Unchecked exception with the same semantics as the StartException.
StopException	Thrown in case stopping a component caused problems.
StopException.StopRuntimeException	Unchecked exception with the same semantics as the StopException.
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.